kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: Centralize default link interface computation 

When LINK_INTERFACE_LIBRARIES is not set we use the link implementation
to implicitly define the link interface.  These changes centralize the
decision so that all linkable targets internally have a link interface.
This commit is contained in:
Brad King 2009-07-06 16:25:20 -04:00
parent 26df00f83a
commit 06b0a692f4
6 changed files with 85 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Source/cmComputeLinkDepends.cxx
View File

@ -223,7 +223,7 @@ std::vector<cmComputeLinkDepends::LinkEntry> const&
cmComputeLinkDepends::Compute()
{
// Follow the link dependencies of the target to be linked.
this->AddTargetLinkEntries(-1, this->Target->GetOriginalLinkLibraries());
this->AddDirectLinkEntries();
// Complete the breadth-first search of dependencies.
while(!this->BFSQueue.empty())
@ -364,13 +364,14 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
// Handle dependent shared libraries.
this->QueueSharedDependencies(depender_index, iface->SharedDeps);
}
else if(!entry.Target->IsImported() &&
entry.Target->GetType() != cmTarget::EXECUTABLE)
// Support for CMP0003.
for(std::vector<std::string>::const_iterator
oi = iface->WrongConfigLibraries.begin();
oi != iface->WrongConfigLibraries.end(); ++oi)
{
// Use the target's link implementation as the interface.
this->AddTargetLinkEntries(depender_index,
entry.Target->GetOriginalLinkLibraries());
this->CheckWrongConfigItem(depender_index, *oi);
}
}
}
else
@ -516,11 +517,11 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
}
//----------------------------------------------------------------------------
void
cmComputeLinkDepends::AddTargetLinkEntries(int depender_index,
LinkLibraryVectorType const& libs)
void cmComputeLinkDepends::AddDirectLinkEntries()
{
// Look for entries meant for this configuration.
// Add direct link dependencies in this configuration.
int depender_index = -1;
LinkLibraryVectorType const& libs=this->Target->GetOriginalLinkLibraries();
std::vector<std::string> actual_libs;
for(cmTarget::LinkLibraryVectorType::const_iterator li = libs.begin();
li != libs.end(); ++li)
@ -534,8 +535,6 @@ cmComputeLinkDepends::AddTargetLinkEntries(int depender_index,
this->CheckWrongConfigItem(depender_index, li->first);
}
}
// Add these entries.
this->AddLinkEntries(depender_index, actual_libs);
}

3
Source/cmComputeLinkDepends.h
View File

@ -83,8 +83,7 @@ private:
AllocateLinkEntry(std::string const& item);
int AddLinkEntry(int depender_index, std::string const& item);
void AddVarLinkEntries(int depender_index, const char* value);
void AddTargetLinkEntries(int depender_index,
LinkLibraryVectorType const& libs);
void AddDirectLinkEntries();
void AddLinkEntries(int depender_index,
std::vector<std::string> const& libs);
cmTarget* FindTargetToLink(int depender_index, const char* name);

45
Source/cmExportFileGenerator.cxx
View File

@ -150,10 +150,8 @@ cmExportFileGenerator
}
// Add the transitive link dependencies for this configuration.
if(cmTargetLinkInterface const* iface =
target->GetLinkInterface(config))
if(cmTargetLinkInterface const* iface = target->GetLinkInterface(config))
{
// This target provides a link interface, so use it.
this->SetImportLinkProperty(suffix, target,
"IMPORTED_LINK_INTERFACE_LIBRARIES",
iface->Libraries, properties);
@ -161,47 +159,6 @@ cmExportFileGenerator
"IMPORTED_LINK_DEPENDENT_LIBRARIES",
iface->SharedDeps, properties);
}
else if(target->GetType() == cmTarget::STATIC_LIBRARY ||
target->GetType() == cmTarget::SHARED_LIBRARY)
{
// The default link interface for static and shared libraries is
// their link implementation library list.
this->SetImportLinkProperties(config, suffix, target, properties);
}
}
//----------------------------------------------------------------------------
void
cmExportFileGenerator
::SetImportLinkProperties(const char* config, std::string const& suffix,
cmTarget* target, ImportPropertyMap& properties)
{
// Compute which library configuration to link.
cmTarget::LinkLibraryType linkType = target->ComputeLinkType(config);
// Construct the list of libs linked for this configuration.
std::vector<std::string> actual_libs;
cmTarget::LinkLibraryVectorType const& libs =
target->GetOriginalLinkLibraries();
for(cmTarget::LinkLibraryVectorType::const_iterator li = libs.begin();
li != libs.end(); ++li)
{
// Skip entries that will resolve to the target itself, are empty,
// or are not meant for this configuration.
if(li->first == target->GetName() || li->first.empty() ||
!(li->second == cmTarget::GENERAL || li->second == linkType))
{
continue;
}
// Store this entry.
actual_libs.push_back(li->first);
}
// Store the entries in the property.
this->SetImportLinkProperty(suffix, target,
"IMPORTED_LINK_INTERFACE_LIBRARIES",
actual_libs, properties);
}
//----------------------------------------------------------------------------

3
Source/cmExportFileGenerator.h
View File

@ -67,9 +67,6 @@ protected:
void SetImportDetailProperties(const char* config,
std::string const& suffix, cmTarget* target,
ImportPropertyMap& properties);
void SetImportLinkProperties(const char* config,
std::string const& suffix, cmTarget* target,
ImportPropertyMap& properties);
void SetImportLinkProperty(std::string const& suffix,
cmTarget* target, const char* propName,
std::vector<std::string> const& libs,

88
Source/cmTarget.cxx
View File

@ -3682,10 +3682,10 @@ cmTargetLinkInterface const* cmTarget::GetLinkInterface(const char* config)
return 0;
}
// Link interfaces are supported only for shared libraries and
// executables that export symbols.
if((this->GetType() != cmTarget::SHARED_LIBRARY &&
!this->IsExecutableWithExports()))
// Link interfaces are not supported for executables that do not
// export symbols.
if(this->GetType() == cmTarget::EXECUTABLE &&
!this->IsExecutableWithExports())
{
return 0;
}
@ -3724,23 +3724,27 @@ cmTarget::ComputeLinkInterface(const char* config)
suffix += "NOCONFIG";
}
// Lookup the link interface libraries.
const char* libs = 0;
// An explicit list of interface libraries may be set for shared
// libraries and executables that export symbols.
const char* explicitLibraries = 0;
if(this->GetType() == cmTarget::SHARED_LIBRARY ||
this->IsExecutableWithExports())
{
// Lookup the per-configuration property.
std::string propName = "LINK_INTERFACE_LIBRARIES";
propName += suffix;
libs = this->GetProperty(propName.c_str());
explicitLibraries = this->GetProperty(propName.c_str());
// If not set, try the generic property.
if(!libs)
if(!explicitLibraries)
{
libs = this->GetProperty("LINK_INTERFACE_LIBRARIES");
explicitLibraries = this->GetProperty("LINK_INTERFACE_LIBRARIES");
}
}
// If still not set, there is no link interface.
if(!libs)
// There is no implicit link interface for executables, so if none
// was explicitly set, there is no link interface.
if(!explicitLibraries && this->GetType() == cmTarget::EXECUTABLE)
{
return cmsys::auto_ptr<cmTargetLinkInterface>();
}
@ -3752,23 +3756,31 @@ cmTarget::ComputeLinkInterface(const char* config)
return cmsys::auto_ptr<cmTargetLinkInterface>();
}
// Expand the list of libraries in the interface.
cmSystemTools::ExpandListArgument(libs, iface->Libraries);
// Is the link interface just the link implementation?
bool doLibraries = !explicitLibraries;
// Now we need to construct a list of shared library dependencies
// not included in the interface.
if(this->GetType() == cmTarget::SHARED_LIBRARY)
{
// Use a set to keep track of what libraries have been emitted to
// either list.
// Do we need to construct a list of shared library dependencies not
// included in the interface?
bool doSharedDeps = (explicitLibraries &&
this->GetType() == cmTarget::SHARED_LIBRARY);
// Keep track of what libraries have been emitted.
std::set<cmStdString> emitted;
std::set<cmStdString> emittedWrongConfig;
if(explicitLibraries)
{
// The interface libraries have been explicitly set.
cmSystemTools::ExpandListArgument(explicitLibraries, iface->Libraries);
for(std::vector<std::string>::const_iterator
li = iface->Libraries.begin();
li != iface->Libraries.end(); ++li)
li = iface->Libraries.begin(); li != iface->Libraries.end(); ++li)
{
emitted.insert(*li);
}
}
if(doLibraries || doSharedDeps)
{
// Compute which library configuration to link.
cmTarget::LinkLibraryType linkType = this->ComputeLinkType(config);
@ -3778,26 +3790,42 @@ cmTarget::ComputeLinkInterface(const char* config)
for(cmTarget::LinkLibraryVectorType::const_iterator li = llibs.begin();
li != llibs.end(); ++li)
{
// Skip entries that will resolve to the target itself, are empty,
// or are not meant for this configuration.
if(li->first == this->GetName() || li->first.empty() ||
!(li->second == cmTarget::GENERAL || li->second == linkType))
// Skip entries that resolve to the target itself or are empty.
std::string item = this->CheckCMP0004(li->first);
if(item == this->GetName() || item.empty())
{
continue;
}
// Skip entries that have already been emitted into either list.
if(!emitted.insert(li->first).second)
// Skip entries not meant for this configuration.
if(li->second != cmTarget::GENERAL && li->second != linkType)
{
// Support OLD behavior for CMP0003.
if(doLibraries && !emittedWrongConfig.insert(item).second)
{
iface->WrongConfigLibraries.push_back(item);
}
continue;
}
// Skip entries that have already been emitted.
if(!emitted.insert(item).second)
{
continue;
}
// Add this entry if it is a shared library.
if(cmTarget* tgt = this->Makefile->FindTargetToUse(li->first.c_str()))
// Emit this item.
if(doLibraries)
{
// This implementation dependency goes in the implicit interface.
iface->Libraries.push_back(item);
}
else if(cmTarget* tgt = this->Makefile->FindTargetToUse(item.c_str()))
{
// This is a runtime dependency on another shared library.
if(tgt->GetType() == cmTarget::SHARED_LIBRARY)
{
iface->SharedDeps.push_back(li->first);
iface->SharedDeps.push_back(item);
}
}
else

4
Source/cmTarget.h
View File

@ -46,6 +46,10 @@ struct cmTargetLinkInterface
// Shared library dependencies needed for linking on some platforms.
std::vector<std::string> SharedDeps;
// Libraries listed for other configurations.
// Needed only for OLD behavior of CMP0003.
std::vector<std::string> WrongConfigLibraries;
};
struct cmTargetLinkInterfaceMap: