Memoize includes and defines from interface libraries.

This is similar in spirit to commit e48d8420 (Cache context-independent
includes on evaluation., 2013-02-03), but it is needed since commit
a1c4905f (Use the link information as a source of compile definitions
and includes., 2013-02-12), which changed how includes and defines
are determined. As they are now determined through the link interface,
we need to cache the result of evaluating them through that.

In the case of the includes, the result was already being cached
and then immediately disposed. Store the result as a member variable
instead to make use of the caching.
This commit is contained in:
Stephen Kelly 2013-02-22 13:03:35 +01:00
parent f7474f3a01
commit 42ebb1886f
1 changed files with 88 additions and 44 deletions

View File

@ -92,6 +92,7 @@ public:
// Others not copied here are result caches. // Others not copied here are result caches.
this->SourceEntries = r.SourceEntries; this->SourceEntries = r.SourceEntries;
} }
~cmTargetInternals();
typedef cmTarget::SourceFileFlags SourceFileFlags; typedef cmTarget::SourceFileFlags SourceFileFlags;
std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap; std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap;
bool SourceFileFlagsConstructed; bool SourceFileFlagsConstructed;
@ -138,8 +139,35 @@ public:
}; };
std::vector<IncludeDirectoriesEntry*> IncludeDirectoriesEntries; std::vector<IncludeDirectoriesEntry*> IncludeDirectoriesEntries;
std::vector<cmValueWithOrigin> LinkInterfaceIncludeDirectoriesEntries; std::vector<cmValueWithOrigin> LinkInterfaceIncludeDirectoriesEntries;
std::vector<IncludeDirectoriesEntry*>
CachedLinkInterfaceIncludeDirectoriesEntries;
std::map<std::string, std::string> CachedLinkInterfaceCompileDefinitions;
std::map<std::string, bool> CacheLinkInterfaceIncludeDirectoriesDone;
std::map<std::string, bool> CacheLinkInterfaceCompileDefinitionsDone;
}; };
//----------------------------------------------------------------------------
void deleteAndClear(
std::vector<cmTargetInternals::IncludeDirectoriesEntry*> &entries)
{
for (std::vector<cmTargetInternals::IncludeDirectoriesEntry*>::const_iterator
it = entries.begin(),
end = entries.end();
it != end; ++it)
{
delete *it;
}
entries.clear();
}
//----------------------------------------------------------------------------
cmTargetInternals::~cmTargetInternals()
{
deleteAndClear(CachedLinkInterfaceIncludeDirectoriesEntries);
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmTarget::cmTarget() cmTarget::cmTarget()
{ {
@ -2654,20 +2682,6 @@ void cmTarget::GatherDependencies( const cmMakefile& mf,
} }
} }
//----------------------------------------------------------------------------
void deleteAndClear(
std::vector<cmTargetInternals::IncludeDirectoriesEntry*> &entries)
{
for (std::vector<cmTargetInternals::IncludeDirectoriesEntry*>::const_iterator
it = entries.begin(),
end = entries.end();
it != end; ++it)
{
delete *it;
}
entries.clear();
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmTarget::SetProperty(const char* prop, const char* value) void cmTarget::SetProperty(const char* prop, const char* value)
{ {
@ -2870,9 +2884,9 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
config, config,
debugIncludes); debugIncludes);
std::vector<cmTargetInternals::IncludeDirectoriesEntry*> std::string configString = config ? config : "";
linkInterfaceIncludeDirectoriesEntries; if (!this->Internal->CacheLinkInterfaceIncludeDirectoriesDone[configString])
{
for (std::vector<cmValueWithOrigin>::const_iterator for (std::vector<cmValueWithOrigin>::const_iterator
it = this->Internal->LinkInterfaceIncludeDirectoriesEntries.begin(), it = this->Internal->LinkInterfaceIncludeDirectoriesEntries.begin(),
end = this->Internal->LinkInterfaceIncludeDirectoriesEntries.end(); end = this->Internal->LinkInterfaceIncludeDirectoriesEntries.end();
@ -2880,7 +2894,8 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
{ {
{ {
cmGeneratorExpression ge(lfbt); cmGeneratorExpression ge(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(it->Value); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(it->Value);
std::string result = cge->Evaluate(this->Makefile, config, std::string result = cge->Evaluate(this->Makefile, config,
false, this, 0, 0); false, this, 0, 0);
if (!this->Makefile->FindTargetToUse(result.c_str())) if (!this->Makefile->FindTargetToUse(result.c_str()))
@ -2890,21 +2905,32 @@ std::vector<std::string> cmTarget::GetIncludeDirectories(const char *config)
} }
cmGeneratorExpression ge(it->Backtrace); cmGeneratorExpression ge(it->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse( cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(
"$<TARGET_PROPERTY:" + it->Value + ",INTERFACE_INCLUDE_DIRECTORIES>"); "$<TARGET_PROPERTY:" +
it->Value + ",INTERFACE_INCLUDE_DIRECTORIES>");
linkInterfaceIncludeDirectoriesEntries.push_back( this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries.push_back(
new cmTargetInternals::IncludeDirectoriesEntry(cge)); new cmTargetInternals::IncludeDirectoriesEntry(cge));
} }
}
processIncludeDirectories(this, processIncludeDirectories(this,
linkInterfaceIncludeDirectoriesEntries, this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries,
includes, includes,
uniqueIncludes, uniqueIncludes,
&dagChecker, &dagChecker,
config, config,
debugIncludes); debugIncludes);
deleteAndClear(linkInterfaceIncludeDirectoriesEntries); if (!this->Makefile->IsGeneratingBuildSystem())
{
deleteAndClear(
this->Internal->CachedLinkInterfaceIncludeDirectoriesEntries);
}
else
{
this->Internal->CacheLinkInterfaceIncludeDirectoriesDone[configString]
= true;
}
return includes; return includes;
} }
@ -2957,16 +2983,34 @@ std::string cmTarget::GetCompileDefinitions(const char *config)
} }
} }
std::string configString = config ? config : "";
if (!this->Internal->CacheLinkInterfaceCompileDefinitionsDone[configString])
{
cmGeneratorExpression ge2(lfbt); cmGeneratorExpression ge2(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge2 = ge2.Parse(depString); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge2 =
std::string depResult = cge2->Evaluate(this->Makefile, ge2.Parse(depString);
this->Internal->CachedLinkInterfaceCompileDefinitions[configString] =
cge2->Evaluate(this->Makefile,
config, config,
false, false,
this, this,
&dagChecker); &dagChecker);
if (!depResult.empty()) }
if (!this->Internal->CachedLinkInterfaceCompileDefinitions[configString]
.empty())
{ {
result += (result.empty() ? "" : ";") + depResult; result += (result.empty() ? "" : ";")
+ this->Internal->CachedLinkInterfaceCompileDefinitions[configString];
}
if (!this->Makefile->IsGeneratingBuildSystem())
{
this->Internal->CachedLinkInterfaceCompileDefinitions[configString] = "";
}
else
{
this->Internal->CacheLinkInterfaceCompileDefinitionsDone[configString]
= true;
} }
return result; return result;