Merge tag 'upstream/2.8.12.1'

Upstream version 2.8.12.1
ci/unstable
Modestas Vainius 11 years ago
commit 7fcbec3931

@ -1,3 +1,29 @@
Changes in CMake 2.8.12.1 (since 2.8.12)
----------------------------------------
Brad King (9):
MSVC: Add /FS flag for cl >= 18 to allow parallel compilation (#14492)
Genex: Reject $<TARGET_FILE:...> for object libraries (#14532)
Check for OBJECT_LIBRARY source files at start of generation
CMP0022: Plain target_link_libraries must populate link interface
Do not export INTERFACE_LINK_LIBRARIES from non-linkable targets
CMP0022: Warn about a given target at most once
Fix summary documentation of INTERFACE_LINK_LIBRARIES
file(GENERATE): Clear internal records between configures
cmake: Validate -E cmake_automoc argument count (#14545)
Modestas Vainius (1):
Fix spelling in INTERFACE_LINK_LIBRARIES documentation (#14542)
Stephen Kelly (5):
CMP0022: Output link interface mismatch for static library warning
Don't add invalid content to static lib INTERFACE_LINK_LIBRARIES.
CMP0022: Add unit test for null pointer check and message.
CMP0022: Add test for target_link_libraries plain signature
Automoc: Add directory-level COMPILE_DEFINITIONS to command line (#14535)
Vladislav Vinogradov (1):
FindCUDA: Fix NPP library search for CUDA 5.5
Changes in CMake 2.8.12 (since 2.8.12-rc4)
------------------------------------------
Brad King (4):

@ -263,6 +263,12 @@
# Only available for CUDA version 3.2+.
# CUDA_npp_LIBRARY -- NVIDIA Performance Primitives library.
# Only available for CUDA version 4.0+.
# CUDA_nppc_LIBRARY -- NVIDIA Performance Primitives library (core).
# Only available for CUDA version 5.5+.
# CUDA_nppi_LIBRARY -- NVIDIA Performance Primitives library (image processing).
# Only available for CUDA version 5.5+.
# CUDA_npps_LIBRARY -- NVIDIA Performance Primitives library (signal processing).
# Only available for CUDA version 5.5+.
# CUDA_nvcuvenc_LIBRARY -- CUDA Video Encoder library.
# Only available for CUDA version 3.2+.
# Windows only.
@ -496,6 +502,9 @@ if(NOT "${CUDA_TOOLKIT_ROOT_DIR}" STREQUAL "${CUDA_TOOLKIT_ROOT_DIR_INTERNAL}")
unset(CUDA_curand_LIBRARY CACHE)
unset(CUDA_cusparse_LIBRARY CACHE)
unset(CUDA_npp_LIBRARY CACHE)
unset(CUDA_nppc_LIBRARY CACHE)
unset(CUDA_nppi_LIBRARY CACHE)
unset(CUDA_npps_LIBRARY CACHE)
unset(CUDA_nvcuvenc_LIBRARY CACHE)
unset(CUDA_nvcuvid_LIBRARY CACHE)
endif()
@ -700,7 +709,13 @@ if(NOT CUDA_VERSION VERSION_LESS "3.2")
find_cuda_helper_libs(nvcuvid)
endif()
endif()
if(NOT CUDA_VERSION VERSION_LESS "4.0")
if(CUDA_VERSION VERSION_GREATER "5.0")
# In CUDA 5.5 NPP was splitted onto 3 separate libraries.
find_cuda_helper_libs(nppc)
find_cuda_helper_libs(nppi)
find_cuda_helper_libs(npps)
set(CUDA_npp_LIBRARY "${CUDA_nppc_LIBRARY};${CUDA_nppi_LIBRARY};${CUDA_npps_LIBRARY}")
elseif(NOT CUDA_VERSION VERSION_LESS "4.0")
find_cuda_helper_libs(npp)
endif()

@ -1,2 +1,5 @@
include(Platform/Windows-MSVC)
if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 18.0)
set(_FS_C " /FS")
endif()
__windows_compiler_msvc(C)

@ -1,3 +1,6 @@
include(Platform/Windows-MSVC)
set(_COMPILE_CXX " /TP")
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
set(_FS_CXX " /FS")
endif()
__windows_compiler_msvc(CXX)

@ -232,7 +232,7 @@ macro(__windows_compiler_msvc lang)
set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_LINKER> /lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
set(CMAKE_${lang}_COMPILE_OBJECT
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> /Fo<OBJECT> /Fd<OBJECT_DIR>/ -c <SOURCE>${CMAKE_END_TEMP_FILE}")
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> /Fo<OBJECT> /Fd<OBJECT_DIR>/${_FS_${lang}} -c <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
"<CMAKE_${lang}_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <FLAGS> <DEFINES> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE

@ -2,5 +2,5 @@
set(CMake_VERSION_MAJOR 2)
set(CMake_VERSION_MINOR 8)
set(CMake_VERSION_PATCH 12)
set(CMake_VERSION_TWEAK 0)
set(CMake_VERSION_TWEAK 1)
#set(CMake_VERSION_RC 0)

@ -185,6 +185,10 @@ bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
{
if(!target->IsLinkable())
{
return false;
}
const char *input = target->GetProperty("INTERFACE_LINK_LIBRARIES");
if (input)
{
@ -631,6 +635,7 @@ cmExportFileGenerator
if (iface->ImplementationIsInterface)
{
// Policy CMP0022 must not be NEW.
this->SetImportLinkProperty(suffix, target,
"IMPORTED_LINK_INTERFACE_LIBRARIES",
iface->Libraries, properties, missingTargets);

@ -1277,7 +1277,7 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
"No target \"" + name + "\"");
return std::string();
}
if(target->GetType() >= cmTarget::UTILITY &&
if(target->GetType() >= cmTarget::OBJECT_LIBRARY &&
target->GetType() != cmTarget::UNKNOWN_LIBRARY)
{
::reportError(context, content->GetOriginalExpression(),

@ -848,6 +848,14 @@ void cmGlobalGenerator::Configure()
delete this->LocalGenerators[i];
}
this->LocalGenerators.clear();
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = this->EvaluationFiles.begin();
li != this->EvaluationFiles.end();
++li)
{
delete *li;
}
this->EvaluationFiles.clear();
this->TargetDependencies.clear();
this->TotalTargets.clear();
this->ImportedTargets.clear();
@ -956,6 +964,8 @@ void cmGlobalGenerator::Generate()
return;
}
this->FinalizeTargetCompileDefinitions();
// Iterate through all targets and set up automoc for those which have
// the AUTOMOC property set
this->CreateAutomocTargets();
@ -1088,6 +1098,7 @@ bool cmGlobalGenerator::CheckTargets()
target.GetType() == cmTarget::STATIC_LIBRARY ||
target.GetType() == cmTarget::SHARED_LIBRARY ||
target.GetType() == cmTarget::MODULE_LIBRARY ||
target.GetType() == cmTarget::OBJECT_LIBRARY ||
target.GetType() == cmTarget::UTILITY)
{
if(!target.FindSourceFiles())
@ -1140,13 +1151,11 @@ void cmGlobalGenerator::CreateAutomocTargets()
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::CreateGeneratorTargets()
void cmGlobalGenerator::FinalizeTargetCompileDefinitions()
{
// Construct per-target generator information.
for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
{
cmGeneratorTargetsType generatorTargets;
cmMakefile *mf = this->LocalGenerators[i]->GetMakefile();
const std::vector<cmValueWithOrigin> noconfig_compile_definitions =
@ -1161,7 +1170,6 @@ void cmGlobalGenerator::CreateGeneratorTargets()
{
cmTarget* t = &ti->second;
{
for (std::vector<cmValueWithOrigin>::const_iterator it
= noconfig_compile_definitions.begin();
it != noconfig_compile_definitions.end(); ++it)
@ -1178,7 +1186,24 @@ void cmGlobalGenerator::CreateGeneratorTargets()
mf->GetProperty(defPropName.c_str()));
}
}
}
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::CreateGeneratorTargets()
{
// Construct per-target generator information.
for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
{
cmGeneratorTargetsType generatorTargets;
cmMakefile *mf = this->LocalGenerators[i]->GetMakefile();
cmTargets& targets = mf->GetTargets();
for(cmTargets::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
cmTarget* t = &ti->second;
cmGeneratorTarget* gt = new cmGeneratorTarget(t);
this->GeneratorTargets[t] = gt;
this->ComputeTargetObjects(gt);

@ -382,6 +382,7 @@ private:
void WriteSummary();
void WriteSummary(cmTarget* target);
void FinalizeTargetCompileDefinitions();
cmExternalMakefileProjectGenerator* ExtraGenerator;

@ -83,10 +83,12 @@ class cmTargetInternals
public:
cmTargetInternals()
{
this->PolicyWarnedCMP0022 = false;
this->SourceFileFlagsConstructed = false;
}
cmTargetInternals(cmTargetInternals const& r)
{
this->PolicyWarnedCMP0022 = false;
this->SourceFileFlagsConstructed = false;
// Only some of these entries are part of the object state.
// Others not copied here are result caches.
@ -109,6 +111,7 @@ public:
typedef std::map<TargetConfigPair, OptionalLinkInterface>
LinkInterfaceMapType;
LinkInterfaceMapType LinkInterfaceMap;
bool PolicyWarnedCMP0022;
typedef std::map<cmStdString, cmTarget::OutputInfo> OutputInfoMapType;
OutputInfoMapType OutputInfoMap;
@ -833,7 +836,7 @@ void cmTarget::DefineProperties(cmake *cm)
"CMAKE_LINK_INTERFACE_LIBRARIES if it is set when a target is "
"created. "
"This property is ignored for STATIC libraries.\n"
"This property is overriden by the INTERFACE_LINK_LIBRARIES property if "
"This property is overridden by the INTERFACE_LINK_LIBRARIES property if "
"policy CMP0022 is NEW.\n"
"This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
@ -844,18 +847,18 @@ void cmTarget::DefineProperties(cmake *cm)
"LINK_INTERFACE_LIBRARIES. "
"If set, this property completely overrides the generic property "
"for the named configuration.\n"
"This property is overriden by the INTERFACE_LINK_LIBRARIES property if "
"This property is overridden by the INTERFACE_LINK_LIBRARIES property if "
"policy CMP0022 is NEW.\n"
"This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
cm->DefineProperty
("INTERFACE_LINK_LIBRARIES", cmProperty::TARGET,
"List public interface libraries for a shared library or executable.",
"List public interface libraries for a library.",
"This property contains the list of transitive link dependencies. "
"When the target is linked into another target the libraries "
"listed (and recursively their link interface libraries) will be "
"provided to the other target also. "
"This property is overriden by the LINK_INTERFACE_LIBRARIES or "
"This property is overridden by the LINK_INTERFACE_LIBRARIES or "
"LINK_INTERFACE_LIBRARIES_<CONFIG> property if "
"policy CMP0022 is OLD or unset.\n"
"\n"
@ -2331,16 +2334,10 @@ void cmTarget::MergeLinkLibraries( cmMakefile& mf,
i += this->PrevLinkedLibraries.size();
for( ; i != libs.end(); ++i )
{
// We call this so that the dependencies get written to the cache
// This is equivalent to the target_link_libraries plain signature.
this->AddLinkLibrary( mf, selfname, i->first.c_str(), i->second );
if (this->GetType() == cmTarget::STATIC_LIBRARY)
{
this->AppendProperty("INTERFACE_LINK_LIBRARIES",
("$<LINK_ONLY:" +
this->GetDebugGeneratorExpressions(i->first.c_str(), i->second) +
">").c_str());
}
this->GetDebugGeneratorExpressions(i->first.c_str(), i->second).c_str());
}
this->PrevLinkedLibraries = libs;
}
@ -6412,12 +6409,20 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
// An explicit list of interface libraries may be set for shared
// libraries and executables that export symbols.
const char* explicitLibraries = 0;
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
std::string linkIfaceProp;
if(this->GetType() == cmTarget::SHARED_LIBRARY ||
if(this->PolicyStatusCMP0022 != cmPolicies::OLD &&
this->PolicyStatusCMP0022 != cmPolicies::WARN)
{
// CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES.
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
explicitLibraries = this->GetProperty(linkIfaceProp.c_str());
}
else if(this->GetType() == cmTarget::SHARED_LIBRARY ||
this->IsExecutableWithExports())
{
// CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a
// shared lib or executable.
// Lookup the per-configuration property.
linkIfaceProp = "LINK_INTERFACE_LIBRARIES";
linkIfaceProp += suffix;
@ -6429,95 +6434,32 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
linkIfaceProp = "LINK_INTERFACE_LIBRARIES";
explicitLibraries = this->GetProperty(linkIfaceProp.c_str());
}
if (newExplicitLibraries
&& (!explicitLibraries ||
(explicitLibraries
&& strcmp(newExplicitLibraries, explicitLibraries) != 0)))
{
switch(this->GetPolicyStatusCMP0022())
}
if(explicitLibraries && this->PolicyStatusCMP0022 == cmPolicies::WARN &&
!this->Internal->PolicyWarnedCMP0022)
{
case cmPolicies::WARN:
// Compare the explicitly set old link interface properties to the
// preferred new link interface property one and warn if different.
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
if (newExplicitLibraries
&& strcmp(newExplicitLibraries, explicitLibraries) != 0)
{
cmOStringStream w;
w << (this->Makefile->GetPolicies()
w <<
(this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
<< "Target \"" << this->GetName() << "\" has a "
"INTERFACE_LINK_LIBRARIES property which differs from its "
<< linkIfaceProp << " properties."
"Target \"" << this->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property which differs from its " <<
linkIfaceProp << " properties."
"\n"
"INTERFACE_LINK_LIBRARIES:\n"
<< newExplicitLibraries
<< "\n"
<< linkIfaceProp << ":\n "
<< (explicitLibraries ? explicitLibraries : "(empty)") << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
// Fall through
case cmPolicies::OLD:
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
explicitLibraries = newExplicitLibraries;
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
break;
}
}
}
else if(this->GetType() == cmTarget::STATIC_LIBRARY)
{
if (newExplicitLibraries)
{
cmListFileBacktrace lfbt;
cmGeneratorExpression ge(lfbt);
cmGeneratorExpressionDAGChecker dagChecker(lfbt, this->GetName(),
"INTERFACE_LINK_LIBRARIES", 0, 0);
std::vector<std::string> ifaceLibs;
cmSystemTools::ExpandListArgument(
ge.Parse(newExplicitLibraries)->Evaluate(
this->Makefile,
config,
false,
headTarget,
this, &dagChecker), ifaceLibs);
LinkImplementation const* impl = this->GetLinkImplementation(config,
headTarget);
if (ifaceLibs != impl->Libraries)
{
switch(this->GetPolicyStatusCMP0022())
{
case cmPolicies::WARN:
{
cmOStringStream w;
w << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
<< "Static library target \"" << this->GetName() << "\" has a "
"INTERFACE_LINK_LIBRARIES property. This should be preferred "
"as the source of the link interface for this library. "
"Ignoring the property and using the link implementation "
"as the link interface instead.";
" " << newExplicitLibraries << "\n" <<
linkIfaceProp << ":\n"
" " << (explicitLibraries ? explicitLibraries : "(empty)") << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
// Fall through
case cmPolicies::OLD:
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
explicitLibraries = newExplicitLibraries;
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
break;
}
}
else
{
iface.Libraries = impl->Libraries;
if(this->LinkLanguagePropagatesToDependents())
{
// Targets using this archive need its language runtime libraries.
iface.Languages = impl->Languages;
}
}
this->Internal->PolicyWarnedCMP0022 = true;
}
}
@ -6588,11 +6530,12 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
}
}
}
else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
// The implementation shouldn't be the interface if CMP0022 is NEW. That
// way, the LINK_LIBRARIES property can be set directly without having to
// empty the INTERFACE_LINK_LIBRARIES
else if (this->PolicyStatusCMP0022 == cmPolicies::WARN
|| this->PolicyStatusCMP0022 == cmPolicies::OLD)
// If CMP0022 is NEW then the plain tll signature sets the
// INTERFACE_LINK_LIBRARIES, so if we get here then the project
// cleared the property explicitly and we should not fall back
// to the link implementation.
{
// The link implementation is the default link interface.
LinkImplementation const* impl = this->GetLinkImplementation(config,
@ -6605,6 +6548,70 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
// Targets using this archive need its language runtime libraries.
iface.Languages = impl->Languages;
}
if(this->PolicyStatusCMP0022 == cmPolicies::WARN &&
!this->Internal->PolicyWarnedCMP0022)
{
// Compare the link implementation fallback link interface to the
// preferred new link interface property and warn if different.
cmListFileBacktrace lfbt;
cmGeneratorExpression ge(lfbt);
cmGeneratorExpressionDAGChecker dagChecker(lfbt, this->GetName(),
"INTERFACE_LINK_LIBRARIES", 0, 0);
std::vector<std::string> ifaceLibs;
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
cmSystemTools::ExpandListArgument(
ge.Parse(newExplicitLibraries)->Evaluate(this->Makefile,
config,
false,
headTarget,
this, &dagChecker),
ifaceLibs);
if (ifaceLibs != impl->Libraries)
{
std::string oldLibraries;
std::string newLibraries;
const char *sep = "";
for(std::vector<std::string>::const_iterator it
= impl->Libraries.begin(); it != impl->Libraries.end(); ++it)
{
oldLibraries += sep;
oldLibraries += *it;
sep = ";";
}
sep = "";
for(std::vector<std::string>::const_iterator it
= ifaceLibs.begin(); it != ifaceLibs.end(); ++it)
{
newLibraries += sep;
newLibraries += *it;
sep = ";";
}
if(oldLibraries.empty())
{ oldLibraries = "(empty)"; }
if(newLibraries.empty())
{ newLibraries = "(empty)"; }
cmOStringStream w;
w <<
(this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
"Target \"" << this->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property. "
"This should be preferred as the source of the link interface "
"for this library but because CMP0022 is not set CMake is "
"ignoring the property and using the link implementation "
"as the link interface instead."
"\n"
"INTERFACE_LINK_LIBRARIES:\n"
" " << newLibraries << "\n"
"Link implementation:\n"
" " << oldLibraries << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
this->Internal->PolicyWarnedCMP0022 = true;
}
}
}
if(this->GetType() == cmTarget::STATIC_LIBRARY)

@ -379,15 +379,26 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const char* lib,
{
this->Makefile
->AddLinkLibraryForTarget(this->Target->GetName(), lib, llt);
if (this->CurrentProcessingState != ProcessingKeywordPublicInterface
if(this->CurrentProcessingState == ProcessingLinkLibraries)
{
this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
return true;
}
else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface
&& this->CurrentProcessingState != ProcessingPlainPublicInterface)
{
if (this->Target->GetType() == cmTarget::STATIC_LIBRARY)
{
std::string configLib = this->Target
->GetDebugGeneratorExpressions(lib, llt);
if (cmGeneratorExpression::IsValidTargetName(lib)
|| cmGeneratorExpression::Find(lib) != std::string::npos)
{
configLib = "$<LINK_ONLY:" + configLib + ">";
}
this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
("$<LINK_ONLY:" +
this->Target->GetDebugGeneratorExpressions(lib, llt) +
">").c_str());
configLib.c_str());
}
// Not a 'public' or 'interface' library. Do not add to interface
// property.

@ -88,14 +88,19 @@ public:
"See the IMPORTED mode of the add_library command for more "
"information. "
"\n"
"Library dependencies are transitive by default. "
"Library dependencies are transitive by default with this signature. "
"When this target is linked into another target then the libraries "
"linked to this target will appear on the link line for the other "
"target too. "
"See the INTERFACE_LINK_LIBRARIES target property to override the "
"set of transitive link dependencies for a target. "
"This transitive \"link interface\" is stored in the "
"INTERFACE_LINK_LIBRARIES target property when policy CMP0022 is set "
"to NEW and may be overridden by setting the property directly. "
"("
"When CMP0022 is not set to NEW, transitive linking is builtin "
"but may be overridden by the LINK_INTERFACE_LIBRARIES property. "
"Calls to other signatures of this command may set the property "
"making any libraries linked exclusively by this signature private."
")"
"\n"
"CMake will also propagate \"usage requirements\" from linked library "
"targets. "

@ -1734,7 +1734,7 @@ int cmake::ExecuteCMakeCommand(std::vector<std::string>& args)
{
return cmake::ExecuteEchoColor(args);
}
else if (args[1] == "cmake_automoc")
else if (args[1] == "cmake_automoc" && args.size() >= 4)
{
cmQtAutomoc automoc;
const char *config = args[3].empty() ? 0 : args[3].c_str();

@ -22,6 +22,16 @@ generate_export_header(staticlib1)
add_library(staticlib2 STATIC staticlib2.cpp)
generate_export_header(staticlib2)
target_link_libraries(staticlib1 LINK_PUBLIC staticlib2)
if (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
target_link_libraries(staticlib1 LINK_PRIVATE "-Wl,-v")
endif()
add_executable(staticlib_exe staticlib_exe.cpp)
target_link_libraries(staticlib_exe staticlib1)
add_library(onlyplainlib1 SHARED onlyplainlib1.cpp)
add_library(onlyplainlib2 SHARED onlyplainlib2.cpp)
target_link_libraries(onlyplainlib2 onlyplainlib1)
add_executable(onlyplainlib_user onlyplainlib_user.cpp)
target_link_libraries(onlyplainlib_user onlyplainlib2)

@ -0,0 +1,13 @@
#include "onlyplainlib1.h"
OnlyPlainLib1::OnlyPlainLib1()
: result(0)
{
}
int OnlyPlainLib1::GetResult()
{
return result;
}

@ -0,0 +1,14 @@
struct
#ifdef _WIN32
__declspec(dllexport)
#endif
OnlyPlainLib1
{
OnlyPlainLib1();
int GetResult();
private:
int result;
};

@ -0,0 +1,8 @@
#include "onlyplainlib2.h"
OnlyPlainLib1 onlyPlainLib2()
{
OnlyPlainLib1 opl1;
return opl1;
}

@ -0,0 +1,7 @@
#include "onlyplainlib1.h"
#ifdef _WIN32
__declspec(dllexport)
#endif
OnlyPlainLib1 onlyPlainLib2();

@ -0,0 +1,7 @@
#include "onlyplainlib2.h"
int main(int argc, char **argv)
{
return onlyPlainLib2().GetResult();
}

@ -16,7 +16,10 @@
#include <QObject>
class Foo : public QObject
class Foo
#ifdef FOO
: public QObject
#endif
{
Q_OBJECT
public:

@ -0,0 +1,7 @@
enable_language(CXX)
add_library(testLib empty_vs6_1.cpp)
add_executable(testExe empty_vs6_2.cpp)
target_link_libraries(testExe testLib)
export(TARGETS testExe FILE "${CMAKE_CURRENT_BINARY_DIR}/cmp0022NOWARN-exe.cmake")

@ -0,0 +1,8 @@
enable_language(CXX)
add_library(foo SHARED empty_vs6_1.cpp)
add_library(bar SHARED empty_vs6_2.cpp)
target_link_libraries(bar foo)
add_executable(zot empty.cpp)
target_link_libraries(zot bar)

@ -5,4 +5,8 @@ add_library(foo STATIC empty_vs6_1.cpp)
add_library(bar STATIC empty_vs6_2.cpp)
add_library(bat STATIC empty_vs6_3.cpp)
target_link_libraries(foo bar)
target_link_libraries(bar bat)
# The last element here needs to contain a space so that it is a single
# element which is not a valid target name. As bar is a STATIC library,
# this tests that the LINK_ONLY generator expression is not used for
# that element, creating an error.
target_link_libraries(bar bat "-lz -lm")

@ -0,0 +1,19 @@
CMake Warning \(dev\) in CMakeLists.txt:
Policy CMP0022 is not set: INTERFACE_LINK_LIBRARIES defines the link
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has an INTERFACE_LINK_LIBRARIES property. This should be
preferred as the source of the link interface for this library but because
CMP0022 is not set CMake is ignoring the property and using the link
implementation as the link interface instead.
INTERFACE_LINK_LIBRARIES:
foo
Link implementation:
\(empty\)
This warning is for project developers. Use -Wno-dev to suppress it.

@ -0,0 +1,10 @@
project(CMP0022-WARN-empty-old)
add_library(foo SHARED empty_vs6_1.cpp)
add_library(bar SHARED empty_vs6_2.cpp)
set_property(TARGET bar PROPERTY INTERFACE_LINK_LIBRARIES foo)
add_library(user empty.cpp)
target_link_libraries(user bar)

@ -3,8 +3,17 @@ CMake Warning \(dev\) in CMakeLists.txt:
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Static library target "bar" has a INTERFACE_LINK_LIBRARIES property. This
should be preferred as the source of the link interface for this library.
Ignoring the property and using the link implementation as the link
interface instead.
Target "bar" has an INTERFACE_LINK_LIBRARIES property. This should be
preferred as the source of the link interface for this library but because
CMP0022 is not set CMake is ignoring the property and using the link
implementation as the link interface instead.
INTERFACE_LINK_LIBRARIES:
foo
Link implementation:
bat
This warning is for project developers. Use -Wno-dev to suppress it.$

@ -1,10 +1,10 @@
CMake Warning \(dev\) in CMakeLists.txt:
^CMake Warning \(dev\) in CMakeLists.txt:
Policy CMP0022 is not set: INTERFACE_LINK_LIBRARIES defines the link
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has a INTERFACE_LINK_LIBRARIES property which differs from its
LINK_INTERFACE_LIBRARIES properties.
Target "bar" has an INTERFACE_LINK_LIBRARIES property which differs from
its LINK_INTERFACE_LIBRARIES properties.
INTERFACE_LINK_LIBRARIES:

@ -3,8 +3,8 @@ CMake Warning \(dev\) in CMakeLists.txt:
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has a INTERFACE_LINK_LIBRARIES property which differs from its
LINK_INTERFACE_LIBRARIES properties.
Target "bar" has an INTERFACE_LINK_LIBRARIES property which differs from
its LINK_INTERFACE_LIBRARIES properties.
INTERFACE_LINK_LIBRARIES:

@ -9,3 +9,8 @@ set_property(TARGET bar PROPERTY LINK_INTERFACE_LIBRARIES bat)
add_library(user empty.cpp)
target_link_libraries(user bar)
# Use "bar" again with a different "head" target to check
# that the warning does not appear again.
add_library(user2 empty_vs6_3.cpp)
target_link_libraries(user2 bar)

@ -0,0 +1,9 @@
enable_language(CXX)
cmake_policy(SET CMP0022 NEW)
add_library(testLib empty_vs6_1.cpp)
add_executable(testExe empty_vs6_2.cpp)
target_link_libraries(testExe testLib)
export(TARGETS testExe FILE "${CMAKE_CURRENT_BINARY_DIR}/cmp0022NEW-exe.cmake")

@ -3,7 +3,11 @@ include(RunCMake)
run_cmake(CMP0022-WARN)
run_cmake(CMP0022-WARN-tll)
run_cmake(CMP0022-WARN-static)
run_cmake(CMP0022-WARN-empty-old)
run_cmake(CMP0022-NOWARN-exe)
run_cmake(CMP0022-NOWARN-shared)
run_cmake(CMP0022-NOWARN-static)
run_cmake(CMP0022-NOWARN-static-link_libraries)
run_cmake(CMP0022-export)
run_cmake(CMP0022-export-exe)
run_cmake(CMP0022-install-export)

@ -0,0 +1,26 @@
CMake Error at BadTargetTypeObject.cmake:3 \(add_custom_target\):
Error evaluating generator expression:
\$<TARGET_FILE:objlib>
Target "objlib" is not an executable or library.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
+
CMake Error at BadTargetTypeObject.cmake:3 \(add_custom_target\):
Error evaluating generator expression:
\$<TARGET_SONAME_FILE:objlib>
Target "objlib" is not an executable or library.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
+
CMake Error at BadTargetTypeObject.cmake:3 \(add_custom_target\):
Error evaluating generator expression:
\$<TARGET_LINKER_FILE:objlib>
Target "objlib" is not an executable or library.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

@ -0,0 +1,7 @@
enable_language(C)
add_library(objlib OBJECT empty.c)
add_custom_target(check ALL COMMAND echo
$<TARGET_FILE:objlib>
$<TARGET_SONAME_FILE:objlib>
$<TARGET_LINKER_FILE:objlib>
)

@ -7,4 +7,5 @@ run_cmake(BadNOT)
run_cmake(BadStrEqual)
run_cmake(BadZero)
run_cmake(BadTargetName)
run_cmake(BadTargetTypeObject)
run_cmake(BadInstallPrefix)

@ -0,0 +1,9 @@
CMake Error at MissingSource.cmake:1 \(add_library\):
Cannot find source file:
missing.c
Tried extensions( \.[A-Za-z+]+|
)*
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

@ -0,0 +1 @@
add_library(A OBJECT missing.c)

@ -12,6 +12,7 @@ run_cmake(Install)
run_cmake(LinkObjLHS)
run_cmake(LinkObjRHS1)
run_cmake(LinkObjRHS2)
run_cmake(MissingSource)
run_cmake(ObjWithObj)
run_cmake(PostBuild)
run_cmake(PreBuild)

Loading…
Cancel
Save