From: Teresa Johnson Date: Tue, 10 Nov 2015 18:20:11 +0000 (+0000) Subject: [ThinLTO] WeakAny fixes/cleanup X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=649084b00b5bb85507168f6a7939ef2bad3a1fd5 [ThinLTO] WeakAny fixes/cleanup Ensure WeakAny variables are imported as ExternalWeak declarations. To handle WeakAny more consistently and fix this issue: 1) Update helper doImportAsDefinition to properly flag WeakAny variables and aliases as not importing defintions. Update callers of doImportAsDefinition to remove now redundant checks for WeakAny aliases, or ignore aliases, as appropriate. 2) Add any !doImportAsDefinition GVs to DoNotLinkFromSource set during linking of the GV prototype, where we usually add GVs to the DoNotLinkFromSource set for other reasons. Remove now unnecessary adding of WeakAny aliases to DoNotLinkFromSource set from copyGlobalAliasProto. Remove now unnecessary guard against linking non-imported function bodies from ModuleLinker::run. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@252626 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 010c5611949..88b019a6f92 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -626,9 +626,7 @@ void ModuleLinker::copyGVAttributes(GlobalValue *NewGV, // being imported as a declaration. In that case copy the attributes from the // base object. if (GA && !dyn_cast(NewGV)) { - assert(isPerformingImport() && - (GA->hasWeakAnyLinkage() || - !doImportAsDefinition(GA->getBaseObject()))); + assert(isPerformingImport() && !doImportAsDefinition(GA)); NewGV->copyAttributesFrom(GA->getBaseObject()); } else NewGV->copyAttributesFrom(SrcGV); @@ -651,12 +649,19 @@ static bool isLessConstraining(GlobalValue::VisibilityTypes a, bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) { if (!isPerformingImport()) return false; + auto *GA = dyn_cast(SGV); + if (GA) { + if (GA->hasWeakAnyLinkage()) + return false; + return doImportAsDefinition(GA->getBaseObject()); + } // Always import GlobalVariable definitions. The linkage changes // described in ModuleLinker::getLinkage ensure the correct behavior (e.g. // global variables with external linkage are transformed to - // available_externally defintions, which are ultimately turned into - // declaratios after the EliminateAvailableExternally pass). - if (dyn_cast(SGV) && !SGV->isDeclaration()) + // available_externally definitions, which are ultimately turned into + // declarations after the EliminateAvailableExternally pass). + if (dyn_cast(SGV) && !SGV->isDeclaration() && + !SGV->hasWeakAnyLinkage()) return true; // Only import the function requested for importing. auto *SF = dyn_cast(SGV); @@ -725,7 +730,7 @@ GlobalValue::LinkageTypes ModuleLinker::getLinkage(const GlobalValue *SGV) { // definitions upon import, so that they are available for inlining // and/or optimization, but are turned into declarations later // during the EliminateAvailableExternally pass. - if (doImportAsDefinition(SGV)) + if (doImportAsDefinition(SGV) && !dyn_cast(SGV)) return GlobalValue::AvailableExternallyLinkage; // An imported external declaration stays external. return SGV->getLinkage(); @@ -758,7 +763,7 @@ GlobalValue::LinkageTypes ModuleLinker::getLinkage(const GlobalValue *SGV) { // equivalent, so the issue described above for weak_any does not exist, // and the definition can be imported. It can be treated similarly // to an imported externally visible global value. - if (doImportAsDefinition(SGV)) + if (doImportAsDefinition(SGV) && !dyn_cast(SGV)) return GlobalValue::AvailableExternallyLinkage; else return GlobalValue::ExternalLinkage; @@ -775,7 +780,7 @@ GlobalValue::LinkageTypes ModuleLinker::getLinkage(const GlobalValue *SGV) { // If we are promoting the local to global scope, it is handled // similarly to a normal externally visible global. if (doPromoteLocalToGlobal(SGV)) { - if (doImportAsDefinition(SGV)) + if (doImportAsDefinition(SGV) && !dyn_cast(SGV)) return GlobalValue::AvailableExternallyLinkage; else return GlobalValue::ExternalLinkage; @@ -834,8 +839,7 @@ GlobalValue *ModuleLinker::copyGlobalAliasProto(TypeMapTy &TypeMap, // as a declaration as well, which involves converting it to a non-alias. // See comments in ModuleLinker::getLinkage for why we cannot import // weak_any defintions. - if (isPerformingImport() && (SGA->hasWeakAnyLinkage() || - !doImportAsDefinition(SGA->getBaseObject()))) { + if (isPerformingImport() && !doImportAsDefinition(SGA)) { // Need to convert to declaration. All aliases must be definitions. const GlobalValue *GVal = SGA->getBaseObject(); GlobalValue *NewGV; @@ -852,8 +856,6 @@ GlobalValue *ModuleLinker::copyGlobalAliasProto(TypeMapTy &TypeMap, NewGV->setLinkage(GlobalValue::ExternalWeakLinkage); else NewGV->setLinkage(GlobalValue::ExternalLinkage); - // Don't attempt to link body, needs to be a declaration. - DoNotLinkFromSource.insert(SGA); return NewGV; } // If there is no linkage to be performed or we're linking from the source, @@ -1427,6 +1429,9 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { } NewGV = copyGlobalValueProto(TypeMap, SGV, DGV); + + if (isPerformingImport() && !doImportAsDefinition(SGV)) + DoNotLinkFromSource.insert(SGV); } NewGV->setUnnamedAddr(HasUnnamedAddr); @@ -1892,10 +1897,6 @@ bool ModuleLinker::run() { if (DoNotLinkFromSource.count(&SF)) continue; - // When importing, only materialize the function requested for import. - if (isPerformingImport() && &SF != ImportFunction) - continue; - if (linkGlobalValueBody(SF)) return true; } diff --git a/test/Linker/funcimport.ll b/test/Linker/funcimport.ll index 97a34ffd233..2efbc29f5d3 100644 --- a/test/Linker/funcimport.ll +++ b/test/Linker/funcimport.ll @@ -85,6 +85,7 @@ ; reference should turned into an external_weak declaration. ; RUN: llvm-link %t2.bc -functionindex=%t3.thinlto.bc -import=callweakfunc:%t.bc -import=weakfunc:%t.bc -S 2>&1 | FileCheck %s --check-prefix=IMPORTWEAKFUNC ; IMPORTWEAKFUNC: Ignoring import request for weak-any function weakfunc +; IMPORTWEAKFUNC: @weakvar = extern_weak global i32, align 4 ; IMPORTWEAKFUNC: declare extern_weak void @weakfunc ; IMPORTWEAKFUNC: define available_externally void @callweakfunc @@ -158,6 +159,7 @@ entry: ret void } +@weakvar = weak global i32 1, align 4 define weak void @weakfunc() #0 { entry: ret void