X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FLinker%2FLinkModules.cpp;h=7ba622f6ee1d34460cabb9380a2d71e710f299bf;hp=7649d13929f442fa07914a40c6738b991eca48f8;hb=c6cd4955cdd9643c7a3ad7eeb30713a8dcb503dc;hpb=766278ea849cdbe780f543a864c1740429f9f0dc diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 7649d13929f..7ba622f6ee1 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -366,19 +366,13 @@ class ModuleLinker; /// speeds up linking for modules with many/ lazily linked functions of which /// few get used. class ValueMaterializerTy final : public ValueMaterializer { - TypeMapTy &TypeMap; - Module *DstM; - std::vector &LazilyLinkGlobalValues; ModuleLinker *ModLinker; public: - ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM, - std::vector &LazilyLinkGlobalValues, - ModuleLinker *ModLinker) - : ValueMaterializer(), TypeMap(TypeMap), DstM(DstM), - LazilyLinkGlobalValues(LazilyLinkGlobalValues), ModLinker(ModLinker) {} + ValueMaterializerTy(ModuleLinker *ModLinker) : ModLinker(ModLinker) {} - Value *materializeValueFor(Value *V) override; + Value *materializeDeclFor(Value *V) override; + void materializeInitFor(GlobalValue *New, GlobalValue *Old) override; }; class LinkDiagnosticInfo : public DiagnosticInfo { @@ -407,19 +401,8 @@ class ModuleLinker { /// but this allows us to reuse the ValueMapper code. ValueToValueMapTy ValueMap; - struct AppendingVarInfo { - GlobalVariable *NewGV; // New aggregate global in dest module. - const Constant *DstInit; // Old initializer from dest module. - const Constant *SrcInit; // Old initializer from src module. - }; - - std::vector AppendingVars; - // Set of items not to link in from source. - SmallPtrSet DoNotLinkFromSource; - - // Vector of GlobalValues to lazily link in. - std::vector LazilyLinkGlobalValues; + SmallPtrSet DoNotLinkFromSource; DiagnosticHandlerFunction DiagnosticHandler; @@ -428,7 +411,7 @@ class ModuleLinker { /// Function index passed into ModuleLinker for using in function /// importing/exporting handling. - FunctionInfoIndex *ImportIndex; + const FunctionInfoIndex *ImportIndex; /// Function to import from source module, all other functions are /// imported as declarations instead of definitions. @@ -445,13 +428,14 @@ class ModuleLinker { /// references. bool DoneLinkingBodies; + bool HasError = false; + public: ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM, DiagnosticHandlerFunction DiagnosticHandler, unsigned Flags, - FunctionInfoIndex *Index = nullptr, + const FunctionInfoIndex *Index = nullptr, Function *FuncToImport = nullptr) - : DstM(dstM), SrcM(srcM), TypeMap(Set), - ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues, this), + : DstM(dstM), SrcM(srcM), TypeMap(Set), ValMaterializer(this), DiagnosticHandler(DiagnosticHandler), Flags(Flags), ImportIndex(Index), ImportFunction(FuncToImport), HasExportedFunctions(false), DoneLinkingBodies(false) { @@ -466,7 +450,10 @@ public: } bool run(); + Value *materializeDeclFor(Value *V); + void materializeInitFor(GlobalValue *New, GlobalValue *Old); +private: bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; } bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; } bool shouldInternalizeLinkedSymbols() { @@ -484,13 +471,13 @@ public: /// Check if all global value body linking is complete. bool doneLinkingBodies() { return DoneLinkingBodies; } -private: bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest, const GlobalValue &Src); /// Helper method for setting a message and returning an error code. bool emitError(const Twine &Message) { DiagnosticHandler(LinkDiagnosticInfo(DS_Error, Message)); + HasError = true; return true; } @@ -517,11 +504,11 @@ private: GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) { // If the source has no name it can't link. If it has local linkage, // there is no name match-up going on. - if (!SrcGV->hasName() || SrcGV->hasLocalLinkage()) + if (!SrcGV->hasName() || GlobalValue::isLocalLinkage(getLinkage(SrcGV))) return nullptr; // Otherwise see if we have a match in the destination module's symtab. - GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName()); + GlobalValue *DGV = DstM->getNamedValue(getName(SrcGV)); if (!DGV) return nullptr; @@ -539,14 +526,13 @@ private: void upgradeMismatchedGlobalArray(StringRef Name); void upgradeMismatchedGlobals(); + bool linkIfNeeded(GlobalValue &GV); bool linkAppendingVarProto(GlobalVariable *DstGV, const GlobalVariable *SrcGV); bool linkGlobalValueProto(GlobalValue *GV); bool linkModuleFlagsMetadata(); - void linkAppendingVarInit(const AppendingVarInfo &AVI); - void linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src); bool linkFunctionBody(Function &Dst, Function &Src); void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src); @@ -635,19 +621,6 @@ void ModuleLinker::copyGVAttributes(GlobalValue *NewGV, forceRenaming(NewGV, getName(SrcGV)); } -static bool isLessConstraining(GlobalValue::VisibilityTypes a, - GlobalValue::VisibilityTypes b) { - if (a == GlobalValue::HiddenVisibility) - return false; - if (b == GlobalValue::HiddenVisibility) - return true; - if (a == GlobalValue::ProtectedVisibility) - return false; - if (b == GlobalValue::ProtectedVisibility) - return true; - return false; -} - bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) { if (!isPerformingImport()) return false; @@ -655,7 +628,10 @@ bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) { if (GA) { if (GA->hasWeakAnyLinkage()) return false; - return doImportAsDefinition(GA->getBaseObject()); + const GlobalObject *GO = GA->getBaseObject(); + if (!GO->hasLinkOnceODRLinkage()) + return false; + return doImportAsDefinition(GO); } // Always import GlobalVariable definitions, except for the special // case of WeakAny which are imported as ExternalWeak declarations @@ -869,13 +845,22 @@ GlobalValue *ModuleLinker::copyGlobalAliasProto(TypeMapTy &TypeMap, getLinkage(SGA), getName(SGA), DstM); } +static GlobalValue::VisibilityTypes +getMinVisibility(GlobalValue::VisibilityTypes A, + GlobalValue::VisibilityTypes B) { + if (A == GlobalValue::HiddenVisibility || B == GlobalValue::HiddenVisibility) + return GlobalValue::HiddenVisibility; + if (A == GlobalValue::ProtectedVisibility || + B == GlobalValue::ProtectedVisibility) + return GlobalValue::ProtectedVisibility; + return GlobalValue::DefaultVisibility; +} + void ModuleLinker::setVisibility(GlobalValue *NewGV, const GlobalValue *SGV, const GlobalValue *DGV) { GlobalValue::VisibilityTypes Visibility = SGV->getVisibility(); if (DGV) - Visibility = isLessConstraining(Visibility, DGV->getVisibility()) - ? DGV->getVisibility() - : Visibility; + Visibility = getMinVisibility(DGV->getVisibility(), Visibility); // For promoted locals, mark them hidden so that they can later be // stripped from the symbol table to reduce bloat. if (SGV->hasLocalLinkage() && doPromoteLocalToGlobal(SGV)) @@ -898,7 +883,11 @@ GlobalValue *ModuleLinker::copyGlobalValueProto(TypeMapTy &TypeMap, return NewGV; } -Value *ValueMaterializerTy::materializeValueFor(Value *V) { +Value *ValueMaterializerTy::materializeDeclFor(Value *V) { + return ModLinker->materializeDeclFor(V); +} + +Value *ModuleLinker::materializeDeclFor(Value *V) { auto *SGV = dyn_cast(V); if (!SGV) return nullptr; @@ -906,20 +895,45 @@ Value *ValueMaterializerTy::materializeValueFor(Value *V) { // If we are done linking global value bodies (i.e. we are performing // metadata linking), don't link in the global value due to this // reference, simply map it to null. - if (ModLinker->doneLinkingBodies()) + if (doneLinkingBodies()) return nullptr; - GlobalValue *DGV = ModLinker->copyGlobalValueProto(TypeMap, SGV); + linkGlobalValueProto(SGV); + if (HasError) + return nullptr; + Value *Ret = ValueMap[SGV]; + assert(Ret); + return Ret; +} - if (Comdat *SC = SGV->getComdat()) { - if (auto *DGO = dyn_cast(DGV)) { - Comdat *DC = DstM->getOrInsertComdat(SC->getName()); - DGO->setComdat(DC); - } +void ValueMaterializerTy::materializeInitFor(GlobalValue *New, + GlobalValue *Old) { + return ModLinker->materializeInitFor(New, Old); +} + +void ModuleLinker::materializeInitFor(GlobalValue *New, GlobalValue *Old) { + if (auto *F = dyn_cast(New)) { + if (!F->isDeclaration()) + return; + } else if (auto *V = dyn_cast(New)) { + if (V->hasInitializer()) + return; + } else { + auto *A = cast(New); + if (A->getAliasee()) + return; } - LazilyLinkGlobalValues.push_back(SGV); - return DGV; + if (Old->isDeclaration()) + return; + + if (isPerformingImport() && !doImportAsDefinition(Old)) + return; + + if (!New->hasLocalLinkage() && DoNotLinkFromSource.count(Old)) + return; + + linkGlobalValueBody(*Old); } bool ModuleLinker::getComdatLeader(Module *M, StringRef ComdatName, @@ -1294,70 +1308,100 @@ void ModuleLinker::upgradeMismatchedGlobals() { upgradeMismatchedGlobalArray("llvm.global_dtors"); } +static void getArrayElements(const Constant *C, + SmallVectorImpl &Dest) { + unsigned NumElements = cast(C->getType())->getNumElements(); + + for (unsigned i = 0; i != NumElements; ++i) + Dest.push_back(C->getAggregateElement(i)); +} + /// If there were any appending global variables, link them together now. /// Return true on error. bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, const GlobalVariable *SrcGV) { + ArrayType *SrcTy = + cast(TypeMap.get(SrcGV->getType()->getElementType())); + Type *EltTy = SrcTy->getElementType(); - if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) - return emitError("Linking globals named '" + SrcGV->getName() + - "': can only link appending global with another appending global!"); + if (DstGV) { + ArrayType *DstTy = cast(DstGV->getType()->getElementType()); - ArrayType *DstTy = cast(DstGV->getType()->getElementType()); - ArrayType *SrcTy = - cast(TypeMap.get(SrcGV->getType()->getElementType())); - Type *EltTy = DstTy->getElementType(); + if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) + return emitError( + "Linking globals named '" + SrcGV->getName() + + "': can only link appending global with another appending global!"); - // Check to see that they two arrays agree on type. - if (EltTy != SrcTy->getElementType()) - return emitError("Appending variables with different element types!"); - if (DstGV->isConstant() != SrcGV->isConstant()) - return emitError("Appending variables linked with different const'ness!"); + // Check to see that they two arrays agree on type. + if (EltTy != DstTy->getElementType()) + return emitError("Appending variables with different element types!"); + if (DstGV->isConstant() != SrcGV->isConstant()) + return emitError("Appending variables linked with different const'ness!"); - if (DstGV->getAlignment() != SrcGV->getAlignment()) - return emitError( - "Appending variables with different alignment need to be linked!"); + if (DstGV->getAlignment() != SrcGV->getAlignment()) + return emitError( + "Appending variables with different alignment need to be linked!"); - if (DstGV->getVisibility() != SrcGV->getVisibility()) - return emitError( - "Appending variables with different visibility need to be linked!"); + if (DstGV->getVisibility() != SrcGV->getVisibility()) + return emitError( + "Appending variables with different visibility need to be linked!"); - if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr()) - return emitError( - "Appending variables with different unnamed_addr need to be linked!"); + if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr()) + return emitError( + "Appending variables with different unnamed_addr need to be linked!"); - if (StringRef(DstGV->getSection()) != SrcGV->getSection()) - return emitError( + if (StringRef(DstGV->getSection()) != SrcGV->getSection()) + return emitError( "Appending variables with different section name need to be linked!"); + } - uint64_t NewSize = DstTy->getNumElements() + SrcTy->getNumElements(); + SmallVector DstElements; + if (DstGV) + getArrayElements(DstGV->getInitializer(), DstElements); + + SmallVector SrcElements; + getArrayElements(SrcGV->getInitializer(), SrcElements); + + StringRef Name = SrcGV->getName(); + bool IsNewStructor = + (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") && + cast(EltTy)->getNumElements() == 3; + if (IsNewStructor) + SrcElements.erase( + std::remove_if(SrcElements.begin(), SrcElements.end(), + [this](Constant *E) { + auto *Key = dyn_cast( + E->getAggregateElement(2)->stripPointerCasts()); + return DoNotLinkFromSource.count(Key); + }), + SrcElements.end()); + uint64_t NewSize = DstElements.size() + SrcElements.size(); ArrayType *NewType = ArrayType::get(EltTy, NewSize); // Create the new global variable. - GlobalVariable *NG = - new GlobalVariable(*DstGV->getParent(), NewType, SrcGV->isConstant(), - DstGV->getLinkage(), /*init*/nullptr, /*name*/"", DstGV, - DstGV->getThreadLocalMode(), - DstGV->getType()->getAddressSpace()); + GlobalVariable *NG = new GlobalVariable( + *DstM, NewType, SrcGV->isConstant(), SrcGV->getLinkage(), + /*init*/ nullptr, /*name*/ "", DstGV, SrcGV->getThreadLocalMode(), + SrcGV->getType()->getAddressSpace()); // Propagate alignment, visibility and section info. - copyGVAttributes(NG, DstGV); - - AppendingVarInfo AVI; - AVI.NewGV = NG; - AVI.DstInit = DstGV->getInitializer(); - AVI.SrcInit = SrcGV->getInitializer(); - AppendingVars.push_back(AVI); + copyGVAttributes(NG, SrcGV); // Replace any uses of the two global variables with uses of the new // global. ValueMap[SrcGV] = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType())); - DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType())); - DstGV->eraseFromParent(); + for (auto *V : SrcElements) { + DstElements.push_back( + MapValue(V, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer)); + } + + NG->setInitializer(ConstantArray::get(NewType, DstElements)); - // Track the source variable so we don't try to link it. - DoNotLinkFromSource.insert(SrcGV); + if (DstGV) { + DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType())); + DstGV->eraseFromParent(); + } return false; } @@ -1375,8 +1419,8 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { DoNotLinkFromSource.insert(SGV); return false; } - if (DGV && DGV->hasAppendingLinkage()) - return linkAppendingVarProto(cast(DGV), + if (SGV->hasAppendingLinkage()) + return linkAppendingVarProto(cast_or_null(DGV), cast(SGV)); bool LinkFromSrc = true; @@ -1388,7 +1432,8 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; C = DstM->getOrInsertComdat(SC->getName()); C->setSelectionKind(SK); - ComdatMembers[SC].push_back(SGV); + if (SGV->hasInternalLinkage()) + LinkFromSrc = true; } else if (DGV) { if (shouldLinkFromSource(LinkFromSrc, *DGV, *SGV)) return true; @@ -1408,31 +1453,12 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { if (DGV) HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); - if (!LinkFromSrc && !DGV) - return false; - GlobalValue *NewGV; - if (!LinkFromSrc) { + if (!LinkFromSrc && DGV) { NewGV = DGV; // When linking from source we setVisibility from copyGlobalValueProto. setVisibility(NewGV, SGV, DGV); } else { - // If the GV is to be lazily linked, don't create it just yet. - // The ValueMaterializerTy will deal with creating it if it's used. - if (!DGV && !shouldOverrideFromSrc() && SGV != ImportFunction && - (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() || - SGV->hasAvailableExternallyLinkage())) { - DoNotLinkFromSource.insert(SGV); - return false; - } - - // When we only want to link in unresolved dependencies, blacklist - // the symbol unless unless DestM has a matching declaration (DGV). - if (shouldLinkOnlyNeeded() && !(DGV && DGV->isDeclaration())) { - DoNotLinkFromSource.insert(SGV); - return false; - } - NewGV = copyGlobalValueProto(TypeMap, SGV, DGV); if (isPerformingImport() && !doImportAsDefinition(SGV)) @@ -1442,7 +1468,7 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { NewGV->setUnnamedAddr(HasUnnamedAddr); if (auto *NewGO = dyn_cast(NewGV)) { - if (C) + if (C && LinkFromSrc) NewGO->setComdat(C); if (DGV && DGV->hasCommonLinkage() && SGV->hasCommonLinkage()) @@ -1469,46 +1495,6 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { return false; } -static void getArrayElements(const Constant *C, - SmallVectorImpl &Dest) { - unsigned NumElements = cast(C->getType())->getNumElements(); - - for (unsigned i = 0; i != NumElements; ++i) - Dest.push_back(C->getAggregateElement(i)); -} - -void ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) { - // Merge the initializer. - SmallVector DstElements; - getArrayElements(AVI.DstInit, DstElements); - - SmallVector SrcElements; - getArrayElements(AVI.SrcInit, SrcElements); - - ArrayType *NewType = cast(AVI.NewGV->getType()->getElementType()); - - StringRef Name = AVI.NewGV->getName(); - bool IsNewStructor = - (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") && - cast(NewType->getElementType())->getNumElements() == 3; - - for (auto *V : SrcElements) { - if (IsNewStructor) { - Constant *Key = V->getAggregateElement(2); - if (DoNotLinkFromSource.count(Key)) - continue; - } - DstElements.push_back( - MapValue(V, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer)); - } - if (IsNewStructor) { - NewType = ArrayType::get(NewType->getElementType(), DstElements.size()); - AVI.NewGV->mutateType(PointerType::get(NewType, 0)); - } - - AVI.NewGV->setInitializer(ConstantArray::get(NewType, DstElements)); -} - /// Update the initializers in the Dest module now that all globals that may be /// referenced are in Dest. void ModuleLinker::linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src) { @@ -1599,10 +1585,10 @@ bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) { // are linked in. Otherwise, linkonce and other lazy linked GVs will // not be materialized if they aren't referenced. for (auto *SGV : ComdatMembers[SC]) { - if (ValueMap[SGV]) + auto *DGV = cast_or_null(ValueMap[SGV]); + if (DGV && !DGV->isDeclaration()) continue; - Value *NewV = ValMaterializer.materializeValueFor(SGV); - ValueMap[SGV] = NewV; + MapValue(SGV, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer); } } if (shouldInternalizeLinkedSymbols()) @@ -1814,6 +1800,38 @@ static std::string mergeTriples(const Triple &SrcTriple, const Triple &DstTriple return DstTriple.str(); } +bool ModuleLinker::linkIfNeeded(GlobalValue &GV) { + GlobalValue *DGV = getLinkedToGlobal(&GV); + + if (shouldLinkOnlyNeeded() && !(DGV && DGV->isDeclaration())) + return false; + + if (DGV && !GV.hasLocalLinkage()) { + GlobalValue::VisibilityTypes Visibility = + getMinVisibility(DGV->getVisibility(), GV.getVisibility()); + DGV->setVisibility(Visibility); + GV.setVisibility(Visibility); + } + + if (const Comdat *SC = GV.getComdat()) { + bool LinkFromSrc; + Comdat::SelectionKind SK; + std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; + if (!LinkFromSrc) { + DoNotLinkFromSource.insert(&GV); + return false; + } + } + + if (!DGV && !shouldOverrideFromSrc() && + (GV.hasLocalLinkage() || GV.hasLinkOnceLinkage() || + GV.hasAvailableExternallyLinkage())) { + return false; + } + MapValue(&GV, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer); + return HasError; +} + bool ModuleLinker::run() { assert(DstM && "Null destination module"); assert(SrcM && "Null source module"); @@ -1873,29 +1891,32 @@ bool ModuleLinker::run() { // Upgrade mismatched global arrays. upgradeMismatchedGlobals(); + for (GlobalVariable &GV : SrcM->globals()) + if (const Comdat *SC = GV.getComdat()) + ComdatMembers[SC].push_back(&GV); + + for (Function &SF : *SrcM) + if (const Comdat *SC = SF.getComdat()) + ComdatMembers[SC].push_back(&SF); + + for (GlobalAlias &GA : SrcM->aliases()) + if (const Comdat *SC = GA.getComdat()) + ComdatMembers[SC].push_back(&GA); + // Insert all of the globals in src into the DstM module... without linking // initializers (which could refer to functions not yet mapped over). for (GlobalVariable &GV : SrcM->globals()) - if (linkGlobalValueProto(&GV)) + if (linkIfNeeded(GV)) return true; - // Link the functions together between the two modules, without doing function - // bodies... this just adds external function prototypes to the DstM - // function... We do this so that when we begin processing function bodies, - // all of the global values that may be referenced are available in our - // ValueMap. - for (Function &F :*SrcM) - if (linkGlobalValueProto(&F)) + for (Function &SF : *SrcM) + if (linkIfNeeded(SF)) return true; - // If there were any aliases, link them now. for (GlobalAlias &GA : SrcM->aliases()) - if (linkGlobalValueProto(&GA)) + if (linkIfNeeded(GA)) return true; - for (const AppendingVarInfo &AppendingVar : AppendingVars) - linkAppendingVarInit(AppendingVar); - for (const auto &Entry : DstM->getComdatSymbolTable()) { const Comdat &C = Entry.getValue(); if (C.getSelectionKind() == Comdat::Any) @@ -1905,54 +1926,6 @@ bool ModuleLinker::run() { MapValue(GV, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer); } - // Link in the function bodies that are defined in the source module into - // DstM. - for (Function &SF : *SrcM) { - // Skip if no body (function is external). - if (SF.isDeclaration()) - continue; - - // Skip if not linking from source. - if (DoNotLinkFromSource.count(&SF)) - continue; - - if (linkGlobalValueBody(SF)) - return true; - } - - // Resolve all uses of aliases with aliasees. - for (GlobalAlias &Src : SrcM->aliases()) { - if (DoNotLinkFromSource.count(&Src)) - continue; - linkGlobalValueBody(Src); - } - - // Update the initializers in the DstM module now that all globals that may - // be referenced are in DstM. - for (GlobalVariable &Src : SrcM->globals()) { - // Only process initialized GV's or ones not already in dest. - if (!Src.hasInitializer() || DoNotLinkFromSource.count(&Src)) - continue; - linkGlobalValueBody(Src); - } - - // Process vector of lazily linked in functions. - while (!LazilyLinkGlobalValues.empty()) { - GlobalValue *SGV = LazilyLinkGlobalValues.back(); - LazilyLinkGlobalValues.pop_back(); - if (isPerformingImport() && !doImportAsDefinition(SGV)) - continue; - - // Skip declarations that ValueMaterializer may have created in - // case we link in only some of SrcM. - if (shouldLinkOnlyNeeded() && SGV->isDeclaration()) - continue; - - assert(!SGV->isDeclaration() && "users should not pass down decls"); - if (linkGlobalValueBody(*SGV)) - return true; - } - // Note that we are done linking global value bodies. This prevents // metadata linking from creating new references. DoneLinkingBodies = true; @@ -2059,7 +2032,7 @@ bool Linker::IdentifiedStructTypeSet::hasType(StructType *Ty) { return *I == Ty; } -void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { +Linker::Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { this->Composite = M; this->DiagnosticHandler = DiagnosticHandler; @@ -2073,22 +2046,13 @@ void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { } } -Linker::Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { - init(M, DiagnosticHandler); -} - -Linker::Linker(Module *M) { - init(M, [this](const DiagnosticInfo &DI) { - Composite->getContext().diagnose(DI); - }); -} +Linker::Linker(Module *M) + : Linker(M, [this](const DiagnosticInfo &DI) { + Composite->getContext().diagnose(DI); + }) {} -void Linker::deleteModule() { - delete Composite; - Composite = nullptr; -} - -bool Linker::linkInModule(Module *Src, unsigned Flags, FunctionInfoIndex *Index, +bool Linker::linkInModule(Module *Src, unsigned Flags, + const FunctionInfoIndex *Index, Function *FuncToImport) { ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src, DiagnosticHandler, Flags, Index, FuncToImport); @@ -2097,10 +2061,6 @@ bool Linker::linkInModule(Module *Src, unsigned Flags, FunctionInfoIndex *Index, return RetCode; } -void Linker::setModule(Module *Dst) { - init(Dst, DiagnosticHandler); -} - //===----------------------------------------------------------------------===// // LinkModules entrypoint. //===----------------------------------------------------------------------===//