CMP0065: Restrict the use of CMAKE_SHARED_LIBRARY_LINK_<LANG>_FLAGS

This new policy restricts the addition of the shared library link flags
to executables only when the ENABLE_EXPORTS property is set to True.
This commit is contained in:
Chuck Atkins 2015-08-24 14:33:31 -04:00 committed by Brad King
parent 402bf096ec
commit 9784af1b50
25 changed files with 204 additions and 7 deletions

View File

@ -122,3 +122,4 @@ All Policies
/policy/CMP0062 /policy/CMP0062
/policy/CMP0063 /policy/CMP0063
/policy/CMP0064 /policy/CMP0064
/policy/CMP0065

View File

@ -245,6 +245,7 @@ Variables that Control the Build
/variable/CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG /variable/CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_CONFIG
/variable/CMAKE_CONFIG_POSTFIX /variable/CMAKE_CONFIG_POSTFIX
/variable/CMAKE_DEBUG_POSTFIX /variable/CMAKE_DEBUG_POSTFIX
/variable/CMAKE_ENABLE_EXPORTS
/variable/CMAKE_EXE_LINKER_FLAGS_CONFIG /variable/CMAKE_EXE_LINKER_FLAGS_CONFIG
/variable/CMAKE_EXE_LINKER_FLAGS /variable/CMAKE_EXE_LINKER_FLAGS
/variable/CMAKE_Fortran_FORMAT /variable/CMAKE_Fortran_FORMAT

27
Help/policy/CMP0065.rst Normal file
View File

@ -0,0 +1,27 @@
CMP0065
-------
Do not add flags to export symbols from executables without
the :prop_tgt:`ENABLE_EXPORTS` target property.
CMake 3.3 and below, for historical reasons, always linked executables
on some platforms with flags like ``-rdynamic`` to export symbols from
the executables for use by any plugins they may load via ``dlopen``.
CMake 3.4 and above prefer to do this only for executables that are
explicitly marked with the :prop_tgt:`ENABLE_EXPORTS` target property.
The ``OLD`` behavior of this policy is to always use the additional link
flags when linking executables regardless of the value of the
:prop_tgt:`ENABLE_EXPORTS` target property.
The ``NEW`` behavior of this policy is to only use the additional link
flags when linking executables if the :prop_tgt:`ENABLE_EXPORTS` target
property is set to ``True``.
This policy was introduced in CMake version 3.4. Unlike most policies,
CMake version |release| does *not* warn by default when this policy
is not set and simply uses OLD behavior. See documentation of the
:variable:`CMAKE_POLICY_WARNING_CMP0065 <CMAKE_POLICY_WARNING_CMP<NNNN>>`
variable to control the warning.
.. include:: DEPRECATED.txt

View File

@ -7,7 +7,7 @@ Normally an executable does not export any symbols because it is the
final program. It is possible for an executable to export symbols to final program. It is possible for an executable to export symbols to
be used by loadable modules. When this property is set to true CMake be used by loadable modules. When this property is set to true CMake
will allow other targets to "link" to the executable with the will allow other targets to "link" to the executable with the
TARGET_LINK_LIBRARIES command. On all platforms a target-level :command:`TARGET_LINK_LIBRARIES` command. On all platforms a target-level
dependency on the executable is created for targets that link to it. dependency on the executable is created for targets that link to it.
For DLL platforms an import library will be created for the exported For DLL platforms an import library will be created for the exported
symbols and then used for linking. All Windows-based systems symbols and then used for linking. All Windows-based systems
@ -17,3 +17,6 @@ module will "link" to the executable using a flag like
"-bundle_loader". For other non-DLL platforms the link rule is simply "-bundle_loader". For other non-DLL platforms the link rule is simply
ignored since the dynamic loader will automatically bind symbols when ignored since the dynamic loader will automatically bind symbols when
the module is loaded. the module is loaded.
This property is initialized by the value of the variable
:variable:`CMAKE_ENABLE_EXPORTS` if it is set when a target is created.

View File

@ -0,0 +1,6 @@
restrict-shlib-link-flags-to-enable-exports
-------------------------------------------
* CMake no longer links executables with flags to export symbols
unless the :prop_tgt:`ENABLE_EXPORTS` target property is set.
See policy :policy:`CMP0065`.

View File

@ -0,0 +1,22 @@
CMAKE_ENABLE_EXPORTS
--------------------
Specify whether an executable exports symbols for loadable modules.
Normally an executable does not export any symbols because it is the
final program. It is possible for an executable to export symbols to
be used by loadable modules. When this property is set to true CMake
will allow other targets to "link" to the executable with the
:command:`TARGET_LINK_LIBRARIES` command. On all platforms a target-level
dependency on the executable is created for targets that link to it.
For DLL platforms an import library will be created for the exported
symbols and then used for linking. All Windows-based systems
including Cygwin are DLL platforms. For non-DLL platforms that
require all symbols to be resolved at link time, such as Mac OS X, the
module will "link" to the executable using a flag like
"-bundle_loader". For other non-DLL platforms the link rule is simply
ignored since the dynamic loader will automatically bind symbols when
the module is loaded.
This variable is used to initialize the target property
:prop_tgt:`ENABLE_EXPORTS` for executable targets.

View File

@ -13,6 +13,8 @@ warn by default:
policy :policy:`CMP0056`. policy :policy:`CMP0056`.
* ``CMAKE_POLICY_WARNING_CMP0060`` controls the warning for * ``CMAKE_POLICY_WARNING_CMP0060`` controls the warning for
policy :policy:`CMP0060`. policy :policy:`CMP0060`.
* ``CMAKE_POLICY_WARNING_CMP0065`` controls the warning for
policy :policy:`CMP0065`.
This variable should not be set by a project in CMake code. Project This variable should not be set by a project in CMake code. Project
developers running CMake may set this variable in their cache to developers running CMake may set this variable in their cache to

View File

@ -1540,13 +1540,47 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR"); this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR");
// Flags to link an executable to shared libraries. // Flags to link an executable to shared libraries.
std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_";
linkFlagsVar += linkLanguage;
linkFlagsVar += "_FLAGS";
if( tgt.GetType() == cmTarget::EXECUTABLE ) if( tgt.GetType() == cmTarget::EXECUTABLE )
{ {
linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar); bool add_shlib_flags = false;
linkLibs += " "; switch(tgt.Target->GetPolicyStatusCMP0065())
{
case cmPolicies::WARN:
if(!tgt.GetPropertyAsBool("ENABLE_EXPORTS") &&
this->Makefile->PolicyOptionalWarningEnabled(
"CMAKE_POLICY_WARNING_CMP0065"))
{
std::ostringstream w;
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0065) << "\n"
"For compatibility with older versions of CMake, "
"additional flags may be added to export symbols on all "
"executables regardless of thier ENABLE_EXPORTS property.";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
case cmPolicies::OLD:
// OLD behavior is to always add the flags
add_shlib_flags = true;
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065)
);
case cmPolicies::NEW:
// NEW behavior is to only add the flags if ENABLE_EXPORTS is on
add_shlib_flags = tgt.GetPropertyAsBool("ENABLE_EXPORTS");
break;
}
if(add_shlib_flags)
{
std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_";
linkFlagsVar += linkLanguage;
linkFlagsVar += "_FLAGS";
linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar);
linkLibs += " ";
}
} }
// Append the framework search path flags. // Append the framework search path flags.

View File

@ -220,6 +220,10 @@ class cmPolicy;
3, 3, 0, cmPolicies::WARN) \ 3, 3, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0064, \ SELECT(POLICY, CMP0064, \
"Support new TEST if() operator.", \ "Support new TEST if() operator.", \
3, 4, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0065, \
"Do not add flags to export symbols from executables without " \
"the ENABLE_EXPORTS target property.", \
3, 4, 0, cmPolicies::WARN) 3, 4, 0, cmPolicies::WARN)
#define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1) #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)

View File

@ -347,6 +347,7 @@ void cmTarget::SetMakefile(cmMakefile* mf)
{ {
this->SetPropertyDefault("ANDROID_GUI", 0); this->SetPropertyDefault("ANDROID_GUI", 0);
this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0); this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0);
this->SetPropertyDefault("ENABLE_EXPORTS", 0);
} }
if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY if(this->TargetTypeValue == cmTarget::SHARED_LIBRARY
|| this->TargetTypeValue == cmTarget::MODULE_LIBRARY) || this->TargetTypeValue == cmTarget::MODULE_LIBRARY)

View File

@ -41,7 +41,8 @@
F(CMP0046) \ F(CMP0046) \
F(CMP0052) \ F(CMP0052) \
F(CMP0060) \ F(CMP0060) \
F(CMP0063) F(CMP0063) \
F(CMP0065)
class cmake; class cmake;
class cmMakefile; class cmMakefile;

View File

@ -0,0 +1,15 @@
function(BuildTargetInSubProject P T E)
try_compile(RESULTVAR
${CMAKE_CURRENT_BINARY_DIR}/subproject
${CMAKE_CURRENT_SOURCE_DIR}/subproject
${P} ${T} OUTPUT_VARIABLE O)
if(E AND RESULTVAR)
message(STATUS "${P} target ${T} succeeded as expected")
elseif(E AND NOT RESULTVAR)
message(FATAL_ERROR "${P} target ${T} failed but should have succeeded. Output:${O}")
elseif(NOT E AND NOT RESULTVAR)
message(STATUS "${P} target ${T} failed as expected")
elseif(NOT E AND RESULTVAR)
message(FATAL_ERROR "${P} target ${T} succeeded but should have failed. Output:${O}")
endif()
endfunction()

View File

@ -0,0 +1,3 @@
cmake_minimum_required(VERSION 3.3)
project(${RunCMake_TEST} NONE)
include(${RunCMake_TEST}.cmake)

View File

@ -0,0 +1,4 @@
enable_language(C)
include(BuildTargetInSubProject.cmake)
BuildTargetInSubProject(TestPolicyCMP0065 FooNEWBad FALSE)

View File

@ -0,0 +1,4 @@
enable_language(C)
include(BuildTargetInSubProject.cmake)
BuildTargetInSubProject(TestPolicyCMP0065 FooNEWGood TRUE)

View File

@ -0,0 +1,4 @@
enable_language(C)
include(BuildTargetInSubProject.cmake)
BuildTargetInSubProject(TestPolicyCMP0065 FooOLDBad1 FALSE)

View File

@ -0,0 +1,4 @@
enable_language(C)
include(BuildTargetInSubProject.cmake)
BuildTargetInSubProject(TestPolicyCMP0065 FooOLDBad2 FALSE)

View File

@ -0,0 +1,8 @@
include(RunCMake)
run_cmake(OLDBad1)
run_cmake(OLDBad2)
run_cmake(NEWBad)
run_cmake(NEWGood)
run_cmake(WARN-OFF)
run_cmake(WARN-ON)

View File

@ -0,0 +1,3 @@
enable_language(C)
add_executable(main subproject/main.c)

View File

@ -0,0 +1,10 @@
CMake Warning \(dev\) in CMakeLists.txt:
Policy CMP0065 is not set: Do not add flags to export symbols from
executables without the ENABLE_EXPORTS target property. Run "cmake
--help-policy CMP0065" for policy details. Use the cmake_policy command to
set the policy and suppress this warning.
For compatibility with older versions of CMake, additional flags may be
added to export symbols on all executables regardless of thier
ENABLE_EXPORTS property.
This warning is for project developers. Use -Wno-dev to suppress it.

View File

@ -0,0 +1,3 @@
set(CMAKE_POLICY_WARNING_CMP0065 1)
enable_language(C)
add_executable(main subproject/main.c)

View File

@ -0,0 +1,22 @@
cmake_minimum_required(VERSION 3.3)
project(TestPolicyCMP0065 C)
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS BADFLAGS)
#----------------------------------------------------------------------
cmake_policy(SET CMP0065 OLD)
add_executable(FooOLDBad1 main.c)
#----------------------------------------------------------------------
cmake_policy(SET CMP0065 OLD)
add_executable(FooOLDBad2 main.c)
set_target_properties(FooOLDBad2 PROPERTIES ENABLE_EXPORTS ON)
#----------------------------------------------------------------------
cmake_policy(SET CMP0065 NEW)
add_executable(FooNEWGood main.c)
#----------------------------------------------------------------------
cmake_policy(SET CMP0065 NEW)
add_executable(FooNEWBad main.c)
set_target_properties(FooNEWBad PROPERTIES ENABLE_EXPORTS ON)

View File

@ -0,0 +1,7 @@
#include <stdio.h>
int main(int argc, char **argv)
{
printf("Hello World\n");
return 0;
}

View File

@ -104,6 +104,13 @@ add_RunCMake_test(CMP0057)
add_RunCMake_test(CMP0059) add_RunCMake_test(CMP0059)
add_RunCMake_test(CMP0060) add_RunCMake_test(CMP0060)
add_RunCMake_test(CMP0064) add_RunCMake_test(CMP0064)
# The test for Policy 65 requires the use of the
# CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode
# generators ignore. The policy will have no effect on those generators.
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
add_RunCMake_test(CMP0065)
endif()
if(CMAKE_GENERATOR MATCHES "Make") if(CMAKE_GENERATOR MATCHES "Make")
add_RunCMake_test(Make) add_RunCMake_test(Make)
endif() endif()

View File

@ -19,6 +19,7 @@
\* CMP0052 \* CMP0052
\* CMP0060 \* CMP0060
\* CMP0063 \* CMP0063
\* CMP0065
Call Stack \(most recent call first\): Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\) CMakeLists.txt:3 \(include\)