diff options
Diffstat (limited to 'Source/cmComputeLinkInformation.cxx')
| -rw-r--r-- | Source/cmComputeLinkInformation.cxx | 1085 |
1 files changed, 439 insertions, 646 deletions
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index 5b42b1a62c..e1a7bee305 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -240,45 +240,42 @@ because this need be done only for shared libraries without soname-s. */ -cmComputeLinkInformation -::cmComputeLinkInformation(const cmGeneratorTarget* target, - const std::string& config) +cmComputeLinkInformation::cmComputeLinkInformation( + const cmGeneratorTarget* target, const std::string& config) { // Store context information. this->Target = target; this->Makefile = this->Target->Target->GetMakefile(); this->GlobalGenerator = - this->Target->GetLocalGenerator()->GetGlobalGenerator(); + this->Target->GetLocalGenerator()->GetGlobalGenerator(); this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance(); // Check whether to recognize OpenBSD-style library versioned names. - this->OpenBSD = this->Makefile->GetState() - ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING"); + this->OpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool( + "FIND_LIBRARY_USE_OPENBSD_VERSIONING"); // The configuration being linked. this->Config = config; // Allocate internals. - this->OrderLinkerSearchPath = - new cmOrderDirectories(this->GlobalGenerator, target, - "linker search path"); - this->OrderRuntimeSearchPath = - new cmOrderDirectories(this->GlobalGenerator, target, - "runtime search path"); + this->OrderLinkerSearchPath = new cmOrderDirectories( + this->GlobalGenerator, target, "linker search path"); + this->OrderRuntimeSearchPath = new cmOrderDirectories( + this->GlobalGenerator, target, "runtime search path"); this->OrderDependentRPath = 0; // Get the language used for linking this target. this->LinkLanguage = this->Target->GetLinkerLanguage(config); - if(this->LinkLanguage.empty()) - { + if (this->LinkLanguage.empty()) { // The Compute method will do nothing, so skip the rest of the // initialization. return; - } + } // Check whether we should use an import library for linking a target. this->UseImportLibrary = - this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")?true:false; + this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX") ? true + : false; // Check whether we should skip dependencies on shared library files. this->LinkDependsNoShared = @@ -288,14 +285,13 @@ cmComputeLinkInformation // to use when creating a plugin (module) that obtains symbols from // the program that will load it. this->LoaderFlag = 0; - if(!this->UseImportLibrary && - this->Target->GetType() == cmState::MODULE_LIBRARY) - { + if (!this->UseImportLibrary && + this->Target->GetType() == cmState::MODULE_LIBRARY) { std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_"; loader_flag_var += this->LinkLanguage; loader_flag_var += "_FLAG"; this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var); - } + } // Get options needed to link libraries. this->LibLinkFlag = @@ -307,11 +303,10 @@ cmComputeLinkInformation // Get options needed to specify RPATHs. this->RuntimeUseChrpath = false; - if(this->Target->GetType() != cmState::STATIC_LIBRARY) - { + if (this->Target->GetType() != cmState::STATIC_LIBRARY) { const char* tType = - ((this->Target->GetType() == cmState::EXECUTABLE)? - "EXECUTABLE" : "SHARED_LIBRARY"); + ((this->Target->GetType() == cmState::EXECUTABLE) ? "EXECUTABLE" + : "SHARED_LIBRARY"); std::string rtVar = "CMAKE_"; rtVar += tType; rtVar += "_RUNTIME_"; @@ -320,9 +315,8 @@ cmComputeLinkInformation std::string rtSepVar = rtVar + "_SEP"; this->RuntimeFlag = this->Makefile->GetSafeDefinition(rtVar); this->RuntimeSep = this->Makefile->GetSafeDefinition(rtSepVar); - this->RuntimeAlways = - (this->Makefile-> - GetSafeDefinition("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH")); + this->RuntimeAlways = (this->Makefile->GetSafeDefinition( + "CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH")); this->RuntimeUseChrpath = this->Target->IsChrpathUsed(config); @@ -333,14 +327,14 @@ cmComputeLinkInformation rlVar += this->LinkLanguage; rlVar += "_FLAG"; this->RPathLinkFlag = this->Makefile->GetSafeDefinition(rlVar); - } + } // Check if we need to include the runtime search path at link time. { - std::string var = "CMAKE_SHARED_LIBRARY_LINK_"; - var += this->LinkLanguage; - var += "_WITH_RUNTIME_PATH"; - this->LinkWithRuntimePath = this->Makefile->IsOn(var); + std::string var = "CMAKE_SHARED_LIBRARY_LINK_"; + var += this->LinkLanguage; + var += "_WITH_RUNTIME_PATH"; + this->LinkWithRuntimePath = this->Makefile->IsOn(var); } // Check the platform policy for missing soname case. @@ -358,41 +352,30 @@ cmComputeLinkInformation // Choose a mode for dealing with shared library dependencies. this->SharedDependencyMode = SharedDepModeNone; - if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) - { + if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) { this->SharedDependencyMode = SharedDepModeLink; - } - else if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) - { + } else if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) { this->SharedDependencyMode = SharedDepModeLibDir; - } - else if(!this->RPathLinkFlag.empty()) - { + } else if (!this->RPathLinkFlag.empty()) { this->SharedDependencyMode = SharedDepModeDir; - this->OrderDependentRPath = - new cmOrderDirectories(this->GlobalGenerator, target, - "dependent library path"); - } + this->OrderDependentRPath = new cmOrderDirectories( + this->GlobalGenerator, target, "dependent library path"); + } // Add the search path entries requested by the user to path ordering. - this->OrderLinkerSearchPath - ->AddUserDirectories(this->Target->GetLinkDirectories()); - this->OrderRuntimeSearchPath - ->AddUserDirectories(this->Target->GetLinkDirectories()); + this->OrderLinkerSearchPath->AddUserDirectories( + this->Target->GetLinkDirectories()); + this->OrderRuntimeSearchPath->AddUserDirectories( + this->Target->GetLinkDirectories()); // Set up the implicit link directories. this->LoadImplicitLinkInfo(); - this->OrderLinkerSearchPath - ->SetImplicitDirectories(this->ImplicitLinkDirs); - this->OrderRuntimeSearchPath - ->SetImplicitDirectories(this->ImplicitLinkDirs); - if(this->OrderDependentRPath) - { - this->OrderDependentRPath - ->SetImplicitDirectories(this->ImplicitLinkDirs); - this->OrderDependentRPath - ->AddLanguageDirectories(this->RuntimeLinkDirs); - } + this->OrderLinkerSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs); + this->OrderRuntimeSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs); + if (this->OrderDependentRPath) { + this->OrderDependentRPath->SetImplicitDirectories(this->ImplicitLinkDirs); + this->OrderDependentRPath->AddLanguageDirectories(this->RuntimeLinkDirs); + } // Decide whether to enable compatible library search path mode. // There exists code that effectively does @@ -407,18 +390,15 @@ cmComputeLinkInformation // containing libraries linked with a full path to the -L path. this->OldLinkDirMode = this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW; - if(this->OldLinkDirMode) - { + if (this->OldLinkDirMode) { // Construct a mask to not bother with this behavior for link // directories already specified by the user. - std::vector<std::string> const& dirs = - this->Target->GetLinkDirectories(); + std::vector<std::string> const& dirs = this->Target->GetLinkDirectories(); this->OldLinkDirMask.insert(dirs.begin(), dirs.end()); - } + } - this->CMP0060Warn = - this->Makefile->PolicyOptionalWarningEnabled( - "CMAKE_POLICY_WARNING_CMP0060"); + this->CMP0060Warn = this->Makefile->PolicyOptionalWarningEnabled( + "CMAKE_POLICY_WARNING_CMP0060"); } cmComputeLinkInformation::~cmComputeLinkInformation() @@ -443,10 +423,9 @@ std::string cmComputeLinkInformation::GetRPathLinkString() { // If there is no separate linker runtime search flag (-rpath-link) // there is no reason to compute a string. - if(!this->OrderDependentRPath) - { + if (!this->OrderDependentRPath) { return ""; - } + } // Construct the linker runtime search path. return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":"); @@ -471,22 +450,20 @@ cmComputeLinkInformation::GetSharedLibrariesLinked() bool cmComputeLinkInformation::Compute() { // Skip targets that do not link. - if(!(this->Target->GetType() == cmState::EXECUTABLE || - this->Target->GetType() == cmState::SHARED_LIBRARY || - this->Target->GetType() == cmState::MODULE_LIBRARY || - this->Target->GetType() == cmState::STATIC_LIBRARY)) - { + if (!(this->Target->GetType() == cmState::EXECUTABLE || + this->Target->GetType() == cmState::SHARED_LIBRARY || + this->Target->GetType() == cmState::MODULE_LIBRARY || + this->Target->GetType() == cmState::STATIC_LIBRARY)) { return false; - } + } // We require a link language for the target. - if(this->LinkLanguage.empty()) - { - cmSystemTools:: - Error("CMake can not determine linker language for target: ", - this->Target->GetName().c_str()); + if (this->LinkLanguage.empty()) { + cmSystemTools::Error( + "CMake can not determine linker language for target: ", + this->Target->GetName().c_str()); return false; - } + } // Compute the ordered link line items. cmComputeLinkDepends cld(this->Target, this->Config); @@ -494,64 +471,52 @@ bool cmComputeLinkInformation::Compute() cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute(); // Add the link line items. - for(cmComputeLinkDepends::EntryVector::const_iterator - lei = linkEntries.begin(); - lei != linkEntries.end(); ++lei) - { - if(lei->IsSharedDep) - { + for (cmComputeLinkDepends::EntryVector::const_iterator lei = + linkEntries.begin(); + lei != linkEntries.end(); ++lei) { + if (lei->IsSharedDep) { this->AddSharedDepItem(lei->Item, lei->Target); - } - else - { + } else { this->AddItem(lei->Item, lei->Target); - } } + } // Restore the target link type so the correct system runtime // libraries are found. - const char* lss = - this->Target->GetProperty("LINK_SEARCH_END_STATIC"); - if(cmSystemTools::IsOn(lss)) - { + const char* lss = this->Target->GetProperty("LINK_SEARCH_END_STATIC"); + if (cmSystemTools::IsOn(lss)) { this->SetCurrentLinkType(LinkStatic); - } - else - { + } else { this->SetCurrentLinkType(this->StartLinkType); - } + } // Finish listing compatibility paths. - if(this->OldLinkDirMode) - { + if (this->OldLinkDirMode) { // For CMake 2.4 bug-compatibility we need to consider the output // directories of targets linked in another configuration as link // directories. std::set<cmGeneratorTarget const*> const& wrongItems = - cld.GetOldWrongConfigItems(); - for(std::set<cmGeneratorTarget const*>::const_iterator i = - wrongItems.begin(); i != wrongItems.end(); ++i) - { + cld.GetOldWrongConfigItems(); + for (std::set<cmGeneratorTarget const*>::const_iterator i = + wrongItems.begin(); + i != wrongItems.end(); ++i) { cmGeneratorTarget const* tgt = *i; - bool implib = - (this->UseImportLibrary && - (tgt->GetType() == cmState::SHARED_LIBRARY)); - std::string lib = tgt->GetFullPath(this->Config , implib, true); + bool implib = (this->UseImportLibrary && + (tgt->GetType() == cmState::SHARED_LIBRARY)); + std::string lib = tgt->GetFullPath(this->Config, implib, true); this->OldLinkDirItems.push_back(lib); - } } + } // Finish setting up linker search directories. - if(!this->FinishLinkerSearchDirectories()) - { + if (!this->FinishLinkerSearchDirectories()) { return false; - } + } // Add implicit language runtime libraries and directories. this->AddImplicitLinkInfo(); - if (!this->CMP0060WarnItems.empty()) - { + if (!this->CMP0060WarnItems.empty()) { std::ostringstream w; /* clang-format off */ w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0060) << "\n" @@ -565,7 +530,7 @@ bool cmComputeLinkInformation::Compute() /* clang-format on */ this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), this->Target->GetBacktrace()); - } + } return true; } @@ -574,16 +539,14 @@ void cmComputeLinkInformation::AddImplicitLinkInfo() { // The link closure lists all languages whose implicit info is needed. cmGeneratorTarget::LinkClosure const* lc = - this->Target->GetLinkClosure(this->Config); - for(std::vector<std::string>::const_iterator li = lc->Languages.begin(); - li != lc->Languages.end(); ++li) - { + this->Target->GetLinkClosure(this->Config); + for (std::vector<std::string>::const_iterator li = lc->Languages.begin(); + li != lc->Languages.end(); ++li) { // Skip those of the linker language. They are implicit. - if(*li != this->LinkLanguage) - { + if (*li != this->LinkLanguage) { this->AddImplicitLinkInfo(*li); - } } + } } void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang) @@ -593,31 +556,27 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang) std::string libVar = "CMAKE_"; libVar += lang; libVar += "_IMPLICIT_LINK_LIBRARIES"; - if(const char* libs = this->Makefile->GetDefinition(libVar)) - { + if (const char* libs = this->Makefile->GetDefinition(libVar)) { std::vector<std::string> libsVec; cmSystemTools::ExpandListArgument(libs, libsVec); - for(std::vector<std::string>::const_iterator i = libsVec.begin(); - i != libsVec.end(); ++i) - { - if(this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) - { + for (std::vector<std::string>::const_iterator i = libsVec.begin(); + i != libsVec.end(); ++i) { + if (this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) { this->AddItem(*i, 0); - } } } + } // Add linker search paths for this language that are not // implied by the linker language. std::string dirVar = "CMAKE_"; dirVar += lang; dirVar += "_IMPLICIT_LINK_DIRECTORIES"; - if(const char* dirs = this->Makefile->GetDefinition(dirVar)) - { + if (const char* dirs = this->Makefile->GetDefinition(dirVar)) { std::vector<std::string> dirsVec; cmSystemTools::ExpandListArgument(dirs, dirsVec); this->OrderLinkerSearchPath->AddLanguageDirectories(dirsVec); - } + } } void cmComputeLinkInformation::AddItem(std::string const& item, @@ -626,176 +585,141 @@ void cmComputeLinkInformation::AddItem(std::string const& item, // Compute the proper name to use to link this library. const std::string& config = this->Config; bool impexe = (tgt && tgt->IsExecutableWithExports()); - if(impexe && !this->UseImportLibrary && !this->LoaderFlag) - { + if (impexe && !this->UseImportLibrary && !this->LoaderFlag) { // Skip linking to executables on platforms with no import // libraries or loader flags. return; - } + } - if(tgt && tgt->IsLinkable()) - { + if (tgt && tgt->IsLinkable()) { // This is a CMake target. Ask the target for its real name. - if(impexe && this->LoaderFlag) - { + if (impexe && this->LoaderFlag) { // This link item is an executable that may provide symbols // used by this target. A special flag is needed on this // platform. Add it now. std::string linkItem; linkItem = this->LoaderFlag; - std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, - true); + std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, true); linkItem += exe; this->Items.push_back(Item(linkItem, true, tgt)); this->Depends.push_back(exe); - } - else if(tgt->GetType() == cmState::INTERFACE_LIBRARY) - { + } else if (tgt->GetType() == cmState::INTERFACE_LIBRARY) { // Add the interface library as an item so it can be considered as part // of COMPATIBLE_INTERFACE_ enforcement. The generators will ignore // this for the actual link line. this->Items.push_back(Item(std::string(), false, tgt)); - } - else - { + } else { // Decide whether to use an import library. - bool implib = - (this->UseImportLibrary && - (impexe || tgt->GetType() == cmState::SHARED_LIBRARY)); + bool implib = (this->UseImportLibrary && + (impexe || tgt->GetType() == cmState::SHARED_LIBRARY)); // Pass the full path to the target file. std::string lib = tgt->GetFullPath(config, implib, true); - if(!this->LinkDependsNoShared || - tgt->GetType() != cmState::SHARED_LIBRARY) - { + if (!this->LinkDependsNoShared || + tgt->GetType() != cmState::SHARED_LIBRARY) { this->Depends.push_back(lib); - } + } this->AddTargetItem(lib, tgt); this->AddLibraryRuntimeInfo(lib, tgt); - } } - else - { + } else { // This is not a CMake target. Use the name given. - if(cmSystemTools::FileIsFullPath(item.c_str())) - { - if(cmSystemTools::FileIsDirectory(item)) - { + if (cmSystemTools::FileIsFullPath(item.c_str())) { + if (cmSystemTools::FileIsDirectory(item)) { // This is a directory. this->AddDirectoryItem(item); - } - else - { + } else { // Use the full path given to the library file. this->Depends.push_back(item); this->AddFullItem(item); this->AddLibraryRuntimeInfo(item); - } } - else - { + } else { // This is a library or option specified by the user. this->AddUserItem(item, true); - } } + } } void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, const cmGeneratorTarget* tgt) { // If dropping shared library dependencies, ignore them. - if(this->SharedDependencyMode == SharedDepModeNone) - { + if (this->SharedDependencyMode == SharedDepModeNone) { return; - } + } // The user may have incorrectly named an item. Skip items that are // not full paths to shared libraries. - if(tgt) - { + if (tgt) { // The target will provide a full path. Make sure it is a shared // library. - if(tgt->GetType() != cmState::SHARED_LIBRARY) - { + if (tgt->GetType() != cmState::SHARED_LIBRARY) { return; - } } - else - { + } else { // Skip items that are not full paths. We will not be able to // reliably specify them. - if(!cmSystemTools::FileIsFullPath(item.c_str())) - { + if (!cmSystemTools::FileIsFullPath(item.c_str())) { return; - } + } // Get the name of the library from the file name. std::string file = cmSystemTools::GetFilenameName(item); - if(!this->ExtractSharedLibraryName.find(file.c_str())) - { + if (!this->ExtractSharedLibraryName.find(file.c_str())) { // This is not the name of a shared library. return; - } } + } // If in linking mode, just link to the shared library. - if(this->SharedDependencyMode == SharedDepModeLink) - { + if (this->SharedDependencyMode == SharedDepModeLink) { this->AddItem(item, tgt); return; - } + } // Get a full path to the dependent shared library. // Add it to the runtime path computation so that the target being // linked will be able to find it. std::string lib; - if(tgt) - { + if (tgt) { lib = tgt->GetFullPath(this->Config, this->UseImportLibrary); this->AddLibraryRuntimeInfo(lib, tgt); - } - else - { + } else { lib = item; this->AddLibraryRuntimeInfo(lib); - } + } // Check if we need to include the dependent shared library in other // path ordering. cmOrderDirectories* order = 0; - if(this->SharedDependencyMode == SharedDepModeLibDir && - !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) - { + if (this->SharedDependencyMode == SharedDepModeLibDir && + !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) { // Add the item to the linker search path. order = this->OrderLinkerSearchPath; - } - else if(this->SharedDependencyMode == SharedDepModeDir) - { + } else if (this->SharedDependencyMode == SharedDepModeDir) { // Add the item to the separate dependent library search path. order = this->OrderDependentRPath; - } - if(order) - { - if(tgt) - { + } + if (order) { + if (tgt) { std::string soName = tgt->GetSOName(this->Config); - const char* soname = soName.empty()? 0 : soName.c_str(); + const char* soname = soName.empty() ? 0 : soName.c_str(); order->AddRuntimeLibrary(lib, soname); - } - else - { + } else { order->AddRuntimeLibrary(lib); - } } + } } void cmComputeLinkInformation::ComputeLinkTypeInfo() { // Check whether archives may actually be shared libraries. - this->ArchivesMayBeShared = this->CMakeInstance->GetState() - ->GetGlobalPropertyAsBool("TARGET_ARCHIVES_MAY_BE_SHARED_LIBS"); + this->ArchivesMayBeShared = + this->CMakeInstance->GetState()->GetGlobalPropertyAsBool( + "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS"); // First assume we cannot do link type stuff. this->LinkTypeEnabled = false; @@ -804,15 +728,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() const char* static_link_type_flag = 0; const char* shared_link_type_flag = 0; const char* target_type_str = 0; - switch(this->Target->GetType()) - { - case cmState::EXECUTABLE: target_type_str = "EXE"; break; - case cmState::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break; - case cmState::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break; - default: break; - } - if(target_type_str) - { + switch (this->Target->GetType()) { + case cmState::EXECUTABLE: + target_type_str = "EXE"; + break; + case cmState::SHARED_LIBRARY: + target_type_str = "SHARED_LIBRARY"; + break; + case cmState::MODULE_LIBRARY: + target_type_str = "SHARED_MODULE"; + break; + default: + break; + } + if (target_type_str) { std::string static_link_type_flag_var = "CMAKE_"; static_link_type_flag_var += target_type_str; static_link_type_flag_var += "_LINK_STATIC_"; @@ -828,22 +757,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() shared_link_type_flag_var += "_FLAGS"; shared_link_type_flag = this->Makefile->GetDefinition(shared_link_type_flag_var); - } + } // We can support link type switching only if all needed flags are // known. - if(static_link_type_flag && *static_link_type_flag && - shared_link_type_flag && *shared_link_type_flag) - { + if (static_link_type_flag && *static_link_type_flag && + shared_link_type_flag && *shared_link_type_flag) { this->LinkTypeEnabled = true; this->StaticLinkTypeFlag = static_link_type_flag; this->SharedLinkTypeFlag = shared_link_type_flag; - } + } // Lookup the starting link type from the target (linked statically?). - const char* lss = - this->Target->GetProperty("LINK_SEARCH_START_STATIC"); - this->StartLinkType = cmSystemTools::IsOn(lss)? LinkStatic : LinkShared; + const char* lss = this->Target->GetProperty("LINK_SEARCH_START_STATIC"); + this->StartLinkType = cmSystemTools::IsOn(lss) ? LinkStatic : LinkShared; this->CurrentLinkType = this->StartLinkType; } @@ -864,50 +791,44 @@ void cmComputeLinkInformation::ComputeItemParserInfo() LinkShared); this->AddLinkExtension(mf->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"), LinkUnknown); - if(const char* linkSuffixes = - mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) - { + if (const char* linkSuffixes = + mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) { std::vector<std::string> linkSuffixVec; cmSystemTools::ExpandListArgument(linkSuffixes, linkSuffixVec); - for(std::vector<std::string>::iterator i = linkSuffixVec.begin(); - i != linkSuffixVec.end(); ++i) - { + for (std::vector<std::string>::iterator i = linkSuffixVec.begin(); + i != linkSuffixVec.end(); ++i) { this->AddLinkExtension(i->c_str(), LinkUnknown); - } } - if(const char* sharedSuffixes = - mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) - { + } + if (const char* sharedSuffixes = + mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) { std::vector<std::string> sharedSuffixVec; cmSystemTools::ExpandListArgument(sharedSuffixes, sharedSuffixVec); - for(std::vector<std::string>::iterator i = sharedSuffixVec.begin(); - i != sharedSuffixVec.end(); ++i) - { + for (std::vector<std::string>::iterator i = sharedSuffixVec.begin(); + i != sharedSuffixVec.end(); ++i) { this->AddLinkExtension(i->c_str(), LinkShared); - } } + } // Compute a regex to match link extensions. - std::string libext = this->CreateExtensionRegex(this->LinkExtensions, - LinkUnknown); + std::string libext = + this->CreateExtensionRegex(this->LinkExtensions, LinkUnknown); // Create regex to remove any library extension. std::string reg("(.*)"); reg += libext; - this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions, - reg); + this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions, reg); // Create a regex to match a library name. Match index 1 will be // the prefix if it exists and empty otherwise. Match index 2 will // be the library name. Match index 3 will be the library // extension. reg = "^("; - for(std::set<std::string>::iterator p = this->LinkPrefixes.begin(); - p != this->LinkPrefixes.end(); ++p) - { + for (std::set<std::string>::iterator p = this->LinkPrefixes.begin(); + p != this->LinkPrefixes.end(); ++p) { reg += *p; reg += "|"; - } + } reg += ")"; reg += "([^/:]*)"; @@ -920,65 +841,57 @@ void cmComputeLinkInformation::ComputeItemParserInfo() this->ExtractAnyLibraryName.compile(reg_any.c_str()); // Create a regex to match static library names. - if(!this->StaticLinkExtensions.empty()) - { + if (!this->StaticLinkExtensions.empty()) { std::string reg_static = reg; - reg_static += this->CreateExtensionRegex(this->StaticLinkExtensions, - LinkStatic); + reg_static += + this->CreateExtensionRegex(this->StaticLinkExtensions, LinkStatic); #ifdef CM_COMPUTE_LINK_INFO_DEBUG - fprintf(stderr, "static regex [%s]\n", reg_static.c_str()); + fprintf(stderr, "static regex [%s]\n", reg_static.c_str()); #endif this->ExtractStaticLibraryName.compile(reg_static.c_str()); - } + } // Create a regex to match shared library names. - if(!this->SharedLinkExtensions.empty()) - { + if (!this->SharedLinkExtensions.empty()) { std::string reg_shared = reg; this->SharedRegexString = this->CreateExtensionRegex(this->SharedLinkExtensions, LinkShared); reg_shared += this->SharedRegexString; #ifdef CM_COMPUTE_LINK_INFO_DEBUG - fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str()); + fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str()); #endif this->ExtractSharedLibraryName.compile(reg_shared.c_str()); - } + } } void cmComputeLinkInformation::AddLinkPrefix(const char* p) { - if(p && *p) - { + if (p && *p) { this->LinkPrefixes.insert(p); - } + } } void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type) { - if(e && *e) - { - if(type == LinkStatic) - { + if (e && *e) { + if (type == LinkStatic) { this->StaticLinkExtensions.push_back(e); - } - if(type == LinkShared) - { + } + if (type == LinkShared) { this->SharedLinkExtensions.push_back(e); - } - this->LinkExtensions.push_back(e); } + this->LinkExtensions.push_back(e); + } } -std::string -cmComputeLinkInformation -::CreateExtensionRegex(std::vector<std::string> const& exts, LinkType type) +std::string cmComputeLinkInformation::CreateExtensionRegex( + std::vector<std::string> const& exts, LinkType type) { // Build a list of extension choices. std::string libext = "("; const char* sep = ""; - for(std::vector<std::string>::const_iterator i = exts.begin(); - i != exts.end(); ++i) - { + for (std::vector<std::string>::const_iterator i = exts.begin(); + i != exts.end(); ++i) { // Separate this choice from the previous one. libext += sep; sep = "|"; @@ -990,20 +903,17 @@ cmComputeLinkInformation #else libext += *i; #endif - } + } // Finish the list. libext += ")"; // Add an optional OpenBSD version component. - if(this->OpenBSD) - { + if (this->OpenBSD) { libext += "(\\.[0-9]+\\.[0-9]+)?"; - } - else if(type == LinkShared) - { + } else if (type == LinkShared) { libext += "(\\.[0-9]+)?"; - } + } libext += "$"; return libext; @@ -1013,21 +923,17 @@ std::string cmComputeLinkInformation::NoCaseExpression(const char* str) { std::string ret; const char* s = str; - while(*s) - { - if(*s == '.') - { + while (*s) { + if (*s == '.') { ret += *s; - } - else - { + } else { ret += "["; ret += static_cast<char>(tolower(*s)); ret += static_cast<char>(toupper(*s)); ret += "]"; - } - s++; } + s++; + } return ret; } @@ -1035,14 +941,11 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt) { // If we are changing the current link type add the flag to tell the // linker about it. - if(this->CurrentLinkType != lt) - { + if (this->CurrentLinkType != lt) { this->CurrentLinkType = lt; - if(this->LinkTypeEnabled) - { - switch(this->CurrentLinkType) - { + if (this->LinkTypeEnabled) { + switch (this->CurrentLinkType) { case LinkStatic: this->Items.push_back(Item(this->StaticLinkTypeFlag, false)); break; @@ -1051,9 +954,9 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt) break; default: break; - } } } + } } void cmComputeLinkInformation::AddTargetItem(std::string const& item, @@ -1065,39 +968,34 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item, // shared and static libraries but static-mode can handle only // static libraries. If a previous user item changed the link type // to static we need to make sure it is back to shared. - if(target->GetType() != cmState::STATIC_LIBRARY) - { + if (target->GetType() != cmState::STATIC_LIBRARY) { this->SetCurrentLinkType(LinkShared); - } + } // Keep track of shared library targets linked. - if(target->GetType() == cmState::SHARED_LIBRARY) - { + if (target->GetType() == cmState::SHARED_LIBRARY) { this->SharedLibrariesLinked.insert(target); - } + } // Handle case of an imported shared library with no soname. - if(this->NoSONameUsesPath && - target->IsImportedSharedLibWithoutSOName(this->Config)) - { + if (this->NoSONameUsesPath && + target->IsImportedSharedLibWithoutSOName(this->Config)) { this->AddSharedLibNoSOName(item); return; - } + } // If this platform wants a flag before the full path, add it. - if(!this->LibLinkFileFlag.empty()) - { + if (!this->LibLinkFileFlag.empty()) { this->Items.push_back(Item(this->LibLinkFileFlag, false)); - } + } // For compatibility with CMake 2.4 include the item's directory in // the linker search path. - if(this->OldLinkDirMode && !target->IsFrameworkOnApple() && - this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) == - this->OldLinkDirMask.end()) - { + if (this->OldLinkDirMode && !target->IsFrameworkOnApple() && + this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) == + this->OldLinkDirMask.end()) { this->OldLinkDirItems.push_back(item); - } + } // Now add the full path to the library. this->Items.push_back(Item(item, true, target)); @@ -1106,31 +1004,27 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item, void cmComputeLinkInformation::AddFullItem(std::string const& item) { // Check for the implicit link directory special case. - if(this->CheckImplicitDirItem(item)) - { + if (this->CheckImplicitDirItem(item)) { return; - } + } // Check for case of shared library with no builtin soname. - if(this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item)) - { + if (this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item)) { return; - } + } // Full path libraries should specify a valid library file name. // See documentation of CMP0008. std::string generator = this->GlobalGenerator->GetName(); - if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && - (generator.find("Visual Studio") != generator.npos || - generator.find("Xcode") != generator.npos)) - { + if (this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW && + (generator.find("Visual Studio") != generator.npos || + generator.find("Xcode") != generator.npos)) { std::string file = cmSystemTools::GetFilenameName(item); - if(!this->ExtractAnyLibraryName.find(file.c_str())) - { + if (!this->ExtractAnyLibraryName.find(file.c_str())) { this->HandleBadFullItem(item, file); return; - } } + } // This is called to handle a link item that is a full path. // If the target is not a static library make sure the link type is @@ -1138,35 +1032,29 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item) // shared and static libraries but static-mode can handle only // static libraries. If a previous user item changed the link type // to static we need to make sure it is back to shared. - if(this->LinkTypeEnabled) - { + if (this->LinkTypeEnabled) { std::string name = cmSystemTools::GetFilenameName(item); - if(this->ExtractSharedLibraryName.find(name)) - { + if (this->ExtractSharedLibraryName.find(name)) { this->SetCurrentLinkType(LinkShared); - } - else if(!this->ExtractStaticLibraryName.find(item)) - { + } else if (!this->ExtractStaticLibraryName.find(item)) { // We cannot determine the type. Assume it is the target's // default type. this->SetCurrentLinkType(this->StartLinkType); - } } + } // For compatibility with CMake 2.4 include the item's directory in // the linker search path. - if(this->OldLinkDirMode && - this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) == - this->OldLinkDirMask.end()) - { + if (this->OldLinkDirMode && + this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) == + this->OldLinkDirMask.end()) { this->OldLinkDirItems.push_back(item); - } + } // If this platform wants a flag before the full path, add it. - if(!this->LibLinkFileFlag.empty()) - { + if (!this->LibLinkFileFlag.empty()) { this->Items.push_back(Item(this->LibLinkFileFlag, false)); - } + } // Now add the full path to the library. this->Items.push_back(Item(item, true)); @@ -1177,49 +1065,43 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item) // We only switch to a pathless item if the link type may be // enforced. Fortunately only platforms that support link types // seem to have magic per-architecture implicit link directories. - if(!this->LinkTypeEnabled) - { + if (!this->LinkTypeEnabled) { return false; - } + } // Check if this item is in an implicit link directory. std::string dir = cmSystemTools::GetFilenamePath(item); - if(this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end()) - { + if (this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end()) { // Only libraries in implicit link directories are converted to // pathless items. return false; - } + } // Only apply the policy below if the library file is one that can // be found by the linker. std::string file = cmSystemTools::GetFilenameName(item); - if(!this->ExtractAnyLibraryName.find(file)) - { + if (!this->ExtractAnyLibraryName.find(file)) { return false; - } + } // Check the policy for whether we should use the approach below. - switch (this->Target->GetPolicyStatusCMP0060()) - { + switch (this->Target->GetPolicyStatusCMP0060()) { case cmPolicies::WARN: - if (this->CMP0060Warn) - { + if (this->CMP0060Warn) { // Print the warning at most once for this item. std::string const& wid = "CMP0060-WARNING-GIVEN-" + item; - if (!this->CMakeInstance->GetPropertyAsBool(wid)) - { + if (!this->CMakeInstance->GetPropertyAsBool(wid)) { this->CMakeInstance->SetProperty(wid, "1"); this->CMP0060WarnItems.insert(item); - } } + } case cmPolicies::OLD: break; case cmPolicies::REQUIRED_ALWAYS: case cmPolicies::REQUIRED_IF_USED: case cmPolicies::NEW: return false; - } + } // Many system linkers support multiple architectures by // automatically selecting the implicit linker search path for the @@ -1247,17 +1129,15 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // libfoo.a ==> -Wl,-Bstatic -lfoo // Pass flags through untouched. - if(item[0] == '-' || item[0] == '$' || item[0] == '`') - { + if (item[0] == '-' || item[0] == '$' || item[0] == '`') { // if this is a -l option then we might need to warn about // CMP0003 so put it in OldUserFlagItems, if it is not a -l // or -Wl,-l (-framework -pthread), then allow it without a // CMP0003 as -L will not affect those other linker flags - if(item.find("-l") == 0 || item.find("-Wl,-l") == 0) - { + if (item.find("-l") == 0 || item.find("-Wl,-l") == 0) { // This is a linker option provided by the user. this->OldUserFlagItems.push_back(item); - } + } // Restore the target link type since this item does not specify // one. @@ -1266,7 +1146,7 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // Use the item verbatim. this->Items.push_back(Item(item, false)); return; - } + } // Parse out the prefix, base, and suffix components of the // library name. If the name matches that of a shared or static @@ -1279,9 +1159,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // libraries. On AIX a library with the name libfoo.a can be // shared! std::string lib; - if(this->ExtractSharedLibraryName.find(item)) - { - // This matches a shared library file name. + if (this->ExtractSharedLibraryName.find(item)) { +// This matches a shared library file name. #ifdef CM_COMPUTE_LINK_INFO_DEBUG fprintf(stderr, "shared regex matched [%s] [%s] [%s]\n", this->ExtractSharedLibraryName.match(1).c_str(), @@ -1293,10 +1172,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // Use just the library name so the linker will search. lib = this->ExtractSharedLibraryName.match(2); - } - else if(this->ExtractStaticLibraryName.find(item)) - { - // This matches a static library file name. + } else if (this->ExtractStaticLibraryName.find(item)) { +// This matches a static library file name. #ifdef CM_COMPUTE_LINK_INFO_DEBUG fprintf(stderr, "static regex matched [%s] [%s] [%s]\n", this->ExtractStaticLibraryName.match(1).c_str(), @@ -1308,10 +1185,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // Use just the library name so the linker will search. lib = this->ExtractStaticLibraryName.match(2); - } - else if(this->ExtractAnyLibraryName.find(item)) - { - // This matches a library file name. + } else if (this->ExtractAnyLibraryName.find(item)) { +// This matches a library file name. #ifdef CM_COMPUTE_LINK_INFO_DEBUG fprintf(stderr, "any regex matched [%s] [%s] [%s]\n", this->ExtractAnyLibraryName.match(1).c_str(), @@ -1324,21 +1199,18 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, // Use just the library name so the linker will search. lib = this->ExtractAnyLibraryName.match(2); - } - else - { + } else { // This is a name specified by the user. - if(pathNotKnown) - { + if (pathNotKnown) { this->OldUserFlagItems.push_back(item); - } + } // We must ask the linker to search for a library with this name. // Restore the target link type since this item does not specify // one. this->SetCurrentLinkType(this->StartLinkType); lib = item; - } + } // Create an option to ask the linker to search for the library. std::string out = this->LibLinkFlag; @@ -1355,14 +1227,13 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item, void cmComputeLinkInformation::AddFrameworkItem(std::string const& item) { // Try to separate the framework name and path. - if(!this->SplitFramework.find(item.c_str())) - { + if (!this->SplitFramework.find(item.c_str())) { std::ostringstream e; e << "Could not parse framework path \"" << item << "\" " << "linked by target " << this->Target->GetName() << "."; cmSystemTools::Error(e.str().c_str()); return; - } + } std::string fw_path = this->SplitFramework.match(1); std::string fw = this->SplitFramework.match(2); @@ -1388,15 +1259,12 @@ void cmComputeLinkInformation::AddFrameworkItem(std::string const& item) void cmComputeLinkInformation::AddDirectoryItem(std::string const& item) { - if(this->Makefile->IsOn("APPLE") - && cmSystemTools::IsPathToFramework(item.c_str())) - { + if (this->Makefile->IsOn("APPLE") && + cmSystemTools::IsPathToFramework(item.c_str())) { this->AddFrameworkItem(item); - } - else - { + } else { this->DropDirectoryItem(item); - } + } } void cmComputeLinkInformation::DropDirectoryItem(std::string const& item) @@ -1417,21 +1285,19 @@ void cmComputeLinkInformation::ComputeFrameworkInfo() std::vector<std::string> implicitDirVec; // Get platform-wide implicit directories. - if(const char* implicitLinks = this->Makefile->GetDefinition - ("CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES")) - { + if (const char* implicitLinks = this->Makefile->GetDefinition( + "CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES")) { cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec); - } + } // Get language-specific implicit directories. std::string implicitDirVar = "CMAKE_"; implicitDirVar += this->LinkLanguage; implicitDirVar += "_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES"; - if(const char* implicitDirs = - this->Makefile->GetDefinition(implicitDirVar)) - { + if (const char* implicitDirs = + this->Makefile->GetDefinition(implicitDirVar)) { cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec); - } + } this->FrameworkPathsEmmitted.insert(implicitDirVec.begin(), implicitDirVec.end()); @@ -1442,10 +1308,9 @@ void cmComputeLinkInformation::ComputeFrameworkInfo() void cmComputeLinkInformation::AddFrameworkPath(std::string const& p) { - if(this->FrameworkPathsEmmitted.insert(p).second) - { + if (this->FrameworkPathsEmmitted.insert(p).second) { this->FrameworkPaths.push_back(p); - } + } } bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item) @@ -1454,18 +1319,16 @@ bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item) // library is given via path and was not built with an soname. If // this is a shared library that might be the case. std::string file = cmSystemTools::GetFilenameName(item); - if(this->ExtractSharedLibraryName.find(file)) - { + if (this->ExtractSharedLibraryName.find(file)) { // If we can guess the soname fairly reliably then assume the // library has one. Otherwise assume the library has no builtin // soname. std::string soname; - if(!cmSystemTools::GuessLibrarySOName(item, soname)) - { + if (!cmSystemTools::GuessLibrarySOName(item, soname)) { this->AddSharedLibNoSOName(item); return true; - } } + } return false; } @@ -1489,10 +1352,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, // Do not depend on things that do not exist. std::vector<std::string>::iterator i = std::find(this->Depends.begin(), this->Depends.end(), item); - if(i != this->Depends.end()) - { + if (i != this->Depends.end()) { this->Depends.erase(i); - } + } // Tell the linker to search for the item and provide the proper // path for it. Do not contribute to any CMP0003 warning (do not @@ -1501,16 +1363,12 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, this->OrderLinkerSearchPath->AddLinkLibrary(item); // Produce any needed message. - switch(this->Target->GetPolicyStatusCMP0008()) - { - case cmPolicies::WARN: - { + switch (this->Target->GetPolicyStatusCMP0008()) { + case cmPolicies::WARN: { // Print the warning at most once for this item. std::string wid = "CMP0008-WARNING-GIVEN-"; wid += item; - if(!this->CMakeInstance->GetState() - ->GetGlobalPropertyAsBool(wid)) - { + if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(wid)) { this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1"); std::ostringstream w; /* clang-format off */ @@ -1520,9 +1378,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, << "which is a full-path but not a valid library file name."; /* clang-format on */ this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->GetBacktrace()); - } + this->Target->GetBacktrace()); } + } case cmPolicies::OLD: // OLD behavior does not warn. break; @@ -1530,8 +1388,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, // NEW behavior will not get here. break; case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - { + case cmPolicies::REQUIRED_ALWAYS: { std::ostringstream e; /* clang-format off */ e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n" @@ -1541,34 +1398,30 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, /* clang-format on */ this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Target->GetBacktrace()); - } - break; - } + } break; + } } bool cmComputeLinkInformation::FinishLinkerSearchDirectories() { // Support broken projects if necessary. - if(this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() || - !this->OldLinkDirMode) - { + if (this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() || + !this->OldLinkDirMode) { return true; - } + } // Enforce policy constraints. - switch(this->Target->GetPolicyStatusCMP0003()) - { + switch (this->Target->GetPolicyStatusCMP0003()) { case cmPolicies::WARN: - if(!this->CMakeInstance->GetState() - ->GetGlobalPropertyAsBool("CMP0003-WARNING-GIVEN")) - { - this->CMakeInstance->GetState() - ->SetGlobalProperty("CMP0003-WARNING-GIVEN", "1"); + if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool( + "CMP0003-WARNING-GIVEN")) { + this->CMakeInstance->GetState()->SetGlobalProperty( + "CMP0003-WARNING-GIVEN", "1"); std::ostringstream w; this->PrintLinkPolicyDiagnosis(w); this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), - this->Target->GetBacktrace()); - } + this->Target->GetBacktrace()); + } case cmPolicies::OLD: // OLD behavior is to add the paths containing libraries with // known full paths as link directories. @@ -1577,24 +1430,22 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() // Should never happen due to assignment of OldLinkDirMode return true; case cmPolicies::REQUIRED_IF_USED: - case cmPolicies::REQUIRED_ALWAYS: - { + case cmPolicies::REQUIRED_ALWAYS: { std::ostringstream e; e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n"; this->PrintLinkPolicyDiagnosis(e); this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Target->GetBacktrace()); return false; - } } + } // Add the link directories for full path items. - for(std::vector<std::string>::const_iterator - i = this->OldLinkDirItems.begin(); - i != this->OldLinkDirItems.end(); ++i) - { + for (std::vector<std::string>::const_iterator i = + this->OldLinkDirItems.begin(); + i != this->OldLinkDirItems.end(); ++i) { this->OrderLinkerSearchPath->AddLinkLibrary(*i); - } + } return true; } @@ -1612,52 +1463,47 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os) /* clang-format on */ // List the items that might need the old-style paths. - os << "This warning appears because target \"" - << this->Target->GetName() << "\" " + os << "This warning appears because target \"" << this->Target->GetName() + << "\" " << "links to some libraries for which the linker must search:\n"; { - // Format the list of unknown items to be as short as possible while - // still fitting in the allowed width (a true solution would be the - // bin packing problem if we were allowed to change the order). - std::string::size_type max_size = 76; - std::string line; - const char* sep = " "; - for(std::vector<std::string>::const_iterator - i = this->OldUserFlagItems.begin(); - i != this->OldUserFlagItems.end(); ++i) - { - // If the addition of another item will exceed the limit then - // output the current line and reset it. Note that the separator - // is either " " or ", " which is always 2 characters. - if(!line.empty() && (line.size() + i->size() + 2) > max_size) - { - os << line << "\n"; - sep = " "; - line = ""; + // Format the list of unknown items to be as short as possible while + // still fitting in the allowed width (a true solution would be the + // bin packing problem if we were allowed to change the order). + std::string::size_type max_size = 76; + std::string line; + const char* sep = " "; + for (std::vector<std::string>::const_iterator i = + this->OldUserFlagItems.begin(); + i != this->OldUserFlagItems.end(); ++i) { + // If the addition of another item will exceed the limit then + // output the current line and reset it. Note that the separator + // is either " " or ", " which is always 2 characters. + if (!line.empty() && (line.size() + i->size() + 2) > max_size) { + os << line << "\n"; + sep = " "; + line = ""; } - line += sep; - line += *i; - // Convert to the other separator. - sep = ", "; + line += sep; + line += *i; + // Convert to the other separator. + sep = ", "; } - if(!line.empty()) - { - os << line << "\n"; + if (!line.empty()) { + os << line << "\n"; } } // List the paths old behavior is adding. os << "and other libraries with known full path:\n"; std::set<std::string> emitted; - for(std::vector<std::string>::const_iterator - i = this->OldLinkDirItems.begin(); - i != this->OldLinkDirItems.end(); ++i) - { - if(emitted.insert(cmSystemTools::GetFilenamePath(*i)).second) - { + for (std::vector<std::string>::const_iterator i = + this->OldLinkDirItems.begin(); + i != this->OldLinkDirItems.end(); ++i) { + if (emitted.insert(cmSystemTools::GetFilenamePath(*i)).second) { os << " " << *i << "\n"; - } } + } // Explain. os << "CMake is adding directories in the second list to the linker " @@ -1673,34 +1519,29 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo() std::vector<std::string> implicitDirVec; // Get platform-wide implicit directories. - if(const char* implicitLinks = - (this->Makefile->GetDefinition - ("CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES"))) - { + if (const char* implicitLinks = (this->Makefile->GetDefinition( + "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES"))) { cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec); - } + } // Append library architecture to all implicit platform directories // and add them to the set - if(const char* libraryArch = - this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) - { + if (const char* libraryArch = + this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) { for (std::vector<std::string>::const_iterator i = implicitDirVec.begin(); - i != implicitDirVec.end(); ++i) - { + i != implicitDirVec.end(); ++i) { this->ImplicitLinkDirs.insert(*i + "/" + libraryArch); - } } + } // Get language-specific implicit directories. std::string implicitDirVar = "CMAKE_"; implicitDirVar += this->LinkLanguage; implicitDirVar += "_IMPLICIT_LINK_DIRECTORIES"; - if(const char* implicitDirs = - this->Makefile->GetDefinition(implicitDirVar)) - { + if (const char* implicitDirs = + this->Makefile->GetDefinition(implicitDirVar)) { cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec); - } + } // Store implicit link directories. this->ImplicitLinkDirs.insert(implicitDirVec.begin(), implicitDirVec.end()); @@ -1710,32 +1551,27 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo() std::string implicitLibVar = "CMAKE_"; implicitLibVar += this->LinkLanguage; implicitLibVar += "_IMPLICIT_LINK_LIBRARIES"; - if(const char* implicitLibs = - this->Makefile->GetDefinition(implicitLibVar)) - { + if (const char* implicitLibs = + this->Makefile->GetDefinition(implicitLibVar)) { cmSystemTools::ExpandListArgument(implicitLibs, implicitLibVec); - } + } // Store implicit link libraries. - for(std::vector<std::string>::const_iterator i = implicitLibVec.begin(); - i != implicitLibVec.end(); ++i) - { + for (std::vector<std::string>::const_iterator i = implicitLibVec.begin(); + i != implicitLibVec.end(); ++i) { // Items starting in '-' but not '-l' are flags, not libraries, // and should not be filtered by this implicit list. std::string const& item = *i; - if(item[0] != '-' || item[1] == 'l') - { + if (item[0] != '-' || item[1] == 'l') { this->ImplicitLinkLibs.insert(item); - } } + } // Get platform specific rpath link directories - if(const char *rpathDirs = - (this->Makefile->GetDefinition - ("CMAKE_PLATFORM_RUNTIME_PATH"))) - { + if (const char* rpathDirs = + (this->Makefile->GetDefinition("CMAKE_PLATFORM_RUNTIME_PATH"))) { cmSystemTools::ExpandListArgument(rpathDirs, this->RuntimeLinkDirs); - } + } } std::vector<std::string> const& @@ -1744,113 +1580,96 @@ cmComputeLinkInformation::GetRuntimeSearchPath() return this->OrderRuntimeSearchPath->GetOrderedDirectories(); } -void -cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath, - cmGeneratorTarget const* target) +void cmComputeLinkInformation::AddLibraryRuntimeInfo( + std::string const& fullPath, cmGeneratorTarget const* target) { // Ignore targets on Apple where install_name is not @rpath. // The dependenty library can be found with other means such as // @loader_path or full paths. - if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) - { - if(!target->HasMacOSXRpathInstallNameDir(this->Config)) - { + if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) { + if (!target->HasMacOSXRpathInstallNameDir(this->Config)) { return; - } } + } // Libraries with unknown type must be handled using just the file // on disk. - if(target->GetType() == cmState::UNKNOWN_LIBRARY) - { + if (target->GetType() == cmState::UNKNOWN_LIBRARY) { this->AddLibraryRuntimeInfo(fullPath); return; - } + } // Skip targets that are not shared libraries (modules cannot be linked). - if(target->GetType() != cmState::SHARED_LIBRARY) - { + if (target->GetType() != cmState::SHARED_LIBRARY) { return; - } + } // Try to get the soname of the library. Only files with this name // could possibly conflict. std::string soName = target->GetSOName(this->Config); - const char* soname = soName.empty()? 0 : soName.c_str(); + const char* soname = soName.empty() ? 0 : soName.c_str(); // Include this library in the runtime path ordering. this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath, soname); - if(this->LinkWithRuntimePath) - { + if (this->LinkWithRuntimePath) { this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath, soname); - } + } } -void -cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath) +void cmComputeLinkInformation::AddLibraryRuntimeInfo( + std::string const& fullPath) { // Get the name of the library from the file name. bool is_shared_library = false; std::string file = cmSystemTools::GetFilenameName(fullPath); - if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) - { + if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) { // Check that @rpath is part of the install name. // If it isn't, return. std::string soname; - if(!cmSystemTools::GuessLibraryInstallName(fullPath, soname)) - { + if (!cmSystemTools::GuessLibraryInstallName(fullPath, soname)) { return; - } + } - if(soname.find("@rpath") == std::string::npos) - { + if (soname.find("@rpath") == std::string::npos) { return; - } } + } is_shared_library = this->ExtractSharedLibraryName.find(file); - if(!is_shared_library) - { + if (!is_shared_library) { // On some platforms (AIX) a shared library may look static. - if(this->ArchivesMayBeShared) - { - if(this->ExtractStaticLibraryName.find(file.c_str())) - { + if (this->ArchivesMayBeShared) { + if (this->ExtractStaticLibraryName.find(file.c_str())) { // This is the name of a shared library or archive. is_shared_library = true; - } } } + } // It could be an Apple framework - if(!is_shared_library) - { - if(fullPath.find(".framework") != std::string::npos) - { - static cmsys::RegularExpression - splitFramework("^(.*)/(.*).framework/(.*)$"); - if(splitFramework.find(fullPath) && - (std::string::npos != - splitFramework.match(3).find(splitFramework.match(2)))) - { + if (!is_shared_library) { + if (fullPath.find(".framework") != std::string::npos) { + static cmsys::RegularExpression splitFramework( + "^(.*)/(.*).framework/(.*)$"); + if (splitFramework.find(fullPath) && + (std::string::npos != + splitFramework.match(3).find(splitFramework.match(2)))) { is_shared_library = true; - } } } + } - if(!is_shared_library) - { + if (!is_shared_library) { return; - } + } // Include this library in the runtime path ordering. this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath); - if(this->LinkWithRuntimePath) - { + if (this->LinkWithRuntimePath) { this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath); - } + } } static void cmCLI_ExpandListUnique(const char* str, @@ -1859,13 +1678,12 @@ static void cmCLI_ExpandListUnique(const char* str, { std::vector<std::string> tmp; cmSystemTools::ExpandListArgument(str, tmp); - for(std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end(); ++i) - { - if(emitted.insert(*i).second) - { + for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end(); + ++i) { + if (emitted.insert(*i).second) { out.push_back(*i); - } } + } } void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, @@ -1886,103 +1704,82 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs, bool use_build_rpath = (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) && !linking_for_install); - bool use_link_rpath = - outputRuntime && linking_for_install && + bool use_link_rpath = outputRuntime && linking_for_install && !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") && this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH"); // Construct the RPATH. std::set<std::string> emitted; - if(use_install_rpath) - { - const char* install_rpath = - this->Target->GetProperty("INSTALL_RPATH"); + if (use_install_rpath) { + const char* install_rpath = this->Target->GetProperty("INSTALL_RPATH"); cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted); - } - if(use_build_rpath || use_link_rpath) - { + } + if (use_build_rpath || use_link_rpath) { std::string rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT"); - const char *stagePath - = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX"); - const char *installPrefix - = this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); + const char* stagePath = + this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX"); + const char* installPrefix = + this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX"); cmSystemTools::ConvertToUnixSlashes(rootPath); std::vector<std::string> const& rdirs = this->GetRuntimeSearchPath(); - for(std::vector<std::string>::const_iterator ri = rdirs.begin(); - ri != rdirs.end(); ++ri) - { + for (std::vector<std::string>::const_iterator ri = rdirs.begin(); + ri != rdirs.end(); ++ri) { // Put this directory in the rpath if using build-tree rpath // support or if using the link path as an rpath. - if(use_build_rpath) - { + if (use_build_rpath) { std::string d = *ri; - if (!rootPath.empty() && d.find(rootPath) == 0) - { + if (!rootPath.empty() && d.find(rootPath) == 0) { d = d.substr(rootPath.size()); - } - else if (stagePath && *stagePath && d.find(stagePath) == 0) - { + } else if (stagePath && *stagePath && d.find(stagePath) == 0) { std::string suffix = d.substr(strlen(stagePath)); d = installPrefix; d += "/"; d += suffix; cmSystemTools::ConvertToUnixSlashes(d); - } - if(emitted.insert(d).second) - { + } + if (emitted.insert(d).second) { runtimeDirs.push_back(d); - } } - else if(use_link_rpath) - { + } else if (use_link_rpath) { // Do not add any path inside the source or build tree. const char* topSourceDir = this->CMakeInstance->GetHomeDirectory(); const char* topBinaryDir = - this->CMakeInstance->GetHomeOutputDirectory(); - if(!cmSystemTools::ComparePath(*ri, topSourceDir) && - !cmSystemTools::ComparePath(*ri, topBinaryDir) && - !cmSystemTools::IsSubDirectory(*ri, topSourceDir) && - !cmSystemTools::IsSubDirectory(*ri, topBinaryDir)) - { + this->CMakeInstance->GetHomeOutputDirectory(); + if (!cmSystemTools::ComparePath(*ri, topSourceDir) && + !cmSystemTools::ComparePath(*ri, topBinaryDir) && + !cmSystemTools::IsSubDirectory(*ri, topSourceDir) && + !cmSystemTools::IsSubDirectory(*ri, topBinaryDir)) { std::string d = *ri; - if (!rootPath.empty() && d.find(rootPath) == 0) - { + if (!rootPath.empty() && d.find(rootPath) == 0) { d = d.substr(rootPath.size()); - } - else if (stagePath && *stagePath && d.find(stagePath) == 0) - { + } else if (stagePath && *stagePath && d.find(stagePath) == 0) { std::string suffix = d.substr(strlen(stagePath)); d = installPrefix; d += "/"; d += suffix; cmSystemTools::ConvertToUnixSlashes(d); - } - if(emitted.insert(d).second) - { + } + if (emitted.insert(d).second) { runtimeDirs.push_back(d); - } } } } } + } // Add runtime paths required by the languages to always be // present. This is done even when skipping rpath support. { - cmGeneratorTarget::LinkClosure const* lc = - this->Target->GetLinkClosure(this->Config); - for(std::vector<std::string>::const_iterator li = lc->Languages.begin(); - li != lc->Languages.end(); ++li) - { - std::string useVar = "CMAKE_" + *li + - "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH"; - if(this->Makefile->IsOn(useVar)) - { - std::string dirVar = "CMAKE_" + *li + - "_IMPLICIT_LINK_DIRECTORIES"; - if(const char* dirs = this->Makefile->GetDefinition(dirVar)) - { - cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted); + cmGeneratorTarget::LinkClosure const* lc = + this->Target->GetLinkClosure(this->Config); + for (std::vector<std::string>::const_iterator li = lc->Languages.begin(); + li != lc->Languages.end(); ++li) { + std::string useVar = + "CMAKE_" + *li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH"; + if (this->Makefile->IsOn(useVar)) { + std::string dirVar = "CMAKE_" + *li + "_IMPLICIT_LINK_DIRECTORIES"; + if (const char* dirs = this->Makefile->GetDefinition(dirVar)) { + cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted); } } } @@ -2003,33 +1800,29 @@ std::string cmComputeLinkInformation::GetRPathString(bool for_install) std::string rpath = cmJoin(runtimeDirs, this->GetRuntimeSep()); // If the rpath will be replaced at install time, prepare space. - if(!for_install && this->RuntimeUseChrpath) - { - if(!rpath.empty()) - { + if (!for_install && this->RuntimeUseChrpath) { + if (!rpath.empty()) { // Add one trailing separator so the linker does not re-use the // rpath .dynstr entry for a symbol name that happens to match // the end of the rpath string. rpath += this->GetRuntimeSep(); - } + } // Make sure it is long enough to hold the replacement value. std::string::size_type minLength = this->GetChrpathString().length(); - while(rpath.length() < minLength) - { + while (rpath.length() < minLength) { rpath += this->GetRuntimeSep(); - } } + } return rpath; } std::string cmComputeLinkInformation::GetChrpathString() { - if(!this->RuntimeUseChrpath) - { + if (!this->RuntimeUseChrpath) { return ""; - } + } return this->GetRPathString(true); } |