X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FLinker%2FLinkModules.cpp;h=74ca197ddb3cf38bad3466a7b5bedb7afbf18630;hp=3b84454455e917942111b76c916755f8237ade2f;hb=46c7bcb5d1c405996dbc82cb38cdbc1207626f0a;hpb=e0d3c7ca6d3dc7ac9d7611433eb2e5f552839bf7 diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 3b84454455e..74ca197ddb3 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -365,16 +365,18 @@ class ModuleLinker; /// Creates prototypes for functions that are lazily linked on the fly. This /// speeds up linking for modules with many/ lazily linked functions of which /// few get used. -class ValueMaterializerTy : public ValueMaterializer { +class ValueMaterializerTy final : public ValueMaterializer { TypeMapTy &TypeMap; Module *DstM; std::vector &LazilyLinkGlobalValues; + ModuleLinker *ModLinker; public: ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM, - std::vector &LazilyLinkGlobalValues) + std::vector &LazilyLinkGlobalValues, + ModuleLinker *ModLinker) : ValueMaterializer(), TypeMap(TypeMap), DstM(DstM), - LazilyLinkGlobalValues(LazilyLinkGlobalValues) {} + LazilyLinkGlobalValues(LazilyLinkGlobalValues), ModLinker(ModLinker) {} Value *materializeValueFor(Value *V) override; }; @@ -419,25 +421,60 @@ class ModuleLinker { // Vector of GlobalValues to lazily link in. std::vector LazilyLinkGlobalValues; - /// Functions that have replaced other functions. - SmallPtrSet OverridingFunctions; - DiagnosticHandlerFunction DiagnosticHandler; /// For symbol clashes, prefer those from Src. - bool OverrideFromSrc; + unsigned Flags; + + /// Function index passed into ModuleLinker for using in function + /// importing/exporting handling. + FunctionInfoIndex *ImportIndex; + + /// Function to import from source module, all other functions are + /// imported as declarations instead of definitions. + Function *ImportFunction; + + /// Set to true if the given FunctionInfoIndex contains any functions + /// from this source module, in which case we must conservatively assume + /// that any of its functions may be imported into another module + /// as part of a different backend compilation process. + bool HasExportedFunctions; public: ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM, - DiagnosticHandlerFunction DiagnosticHandler, - bool OverrideFromSrc) + DiagnosticHandlerFunction DiagnosticHandler, unsigned Flags, + FunctionInfoIndex *Index = nullptr, + Function *FuncToImport = nullptr) : DstM(dstM), SrcM(srcM), TypeMap(Set), - ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues), - DiagnosticHandler(DiagnosticHandler), OverrideFromSrc(OverrideFromSrc) { + ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues, this), + DiagnosticHandler(DiagnosticHandler), Flags(Flags), ImportIndex(Index), + ImportFunction(FuncToImport), HasExportedFunctions(false) { + assert((ImportIndex || !ImportFunction) && + "Expect a FunctionInfoIndex when importing"); + // If we have a FunctionInfoIndex but no function to import, + // then this is the primary module being compiled in a ThinLTO + // backend compilation, and we need to see if it has functions that + // may be exported to another backend compilation. + if (ImportIndex && !ImportFunction) + HasExportedFunctions = ImportIndex->hasExportedFunctions(SrcM); } bool run(); + bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; } + bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; } + bool shouldInternalizeLinkedSymbols() { + return Flags & Linker::InternalizeLinkedSymbols; + } + + /// Handles cloning of a global values from the source module into + /// the destination module, including setting the attributes and visibility. + GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, const GlobalValue *SGV, + const GlobalValue *DGV = nullptr); + + /// Check if we should promote the given local value to global scope. + bool doPromoteLocalToGlobal(const GlobalValue *SGV); + private: bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest, const GlobalValue &Src); @@ -504,8 +541,43 @@ private: void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src); bool linkGlobalValueBody(GlobalValue &Src); + /// Functions that take care of cloning a specific global value type + /// into the destination module. + GlobalVariable *copyGlobalVariableProto(TypeMapTy &TypeMap, + const GlobalVariable *SGVar); + Function *copyFunctionProto(TypeMapTy &TypeMap, const Function *SF); + GlobalValue *copyGlobalAliasProto(TypeMapTy &TypeMap, const GlobalAlias *SGA); + + /// Helper methods to check if we are importing from or potentially + /// exporting from the current source module. + bool isPerformingImport() { return ImportFunction != nullptr; } + bool isModuleExporting() { return HasExportedFunctions; } + + /// If we are importing from the source module, checks if we should + /// import SGV as a definition, otherwise import as a declaration. + bool doImportAsDefinition(const GlobalValue *SGV); + + /// Get the name for SGV that should be used in the linked destination + /// module. Specifically, this handles the case where we need to rename + /// a local that is being promoted to global scope. + std::string getName(const GlobalValue *SGV); + + /// Get the new linkage for SGV that should be used in the linked destination + /// module. Specifically, for ThinLTO importing or exporting it may need + /// to be adjusted. + GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV); + + /// Copies the necessary global value attributes and name from the source + /// to the newly cloned global value. + void copyGVAttributes(GlobalValue *NewGV, const GlobalValue *SrcGV); + + /// Updates the visibility for the new global cloned from the source + /// and, if applicable, linked with an existing destination global. + /// Handles visibility change required for promoted locals. + void setVisibility(GlobalValue *NewGV, const GlobalValue *SGV, + const GlobalValue *DGV = nullptr); + void linkNamedMDNodes(); - void stripReplacedSubprograms(); }; } @@ -515,6 +587,9 @@ private: static void forceRenaming(GlobalValue *GV, StringRef Name) { // If the global doesn't force its name or if it already has the right name, // there is nothing for us to do. + // Note that any required local to global promotion should already be done, + // so promoted locals will not skip this handling as their linkage is no + // longer local. if (GV->hasLocalLinkage() || GV->getName() == Name) return; @@ -532,9 +607,23 @@ static void forceRenaming(GlobalValue *GV, StringRef Name) { /// copy additional attributes (those not needed to construct a GlobalValue) /// from the SrcGV to the DestGV. -static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) { - DestGV->copyAttributesFrom(SrcGV); - forceRenaming(DestGV, SrcGV->getName()); +void ModuleLinker::copyGVAttributes(GlobalValue *NewGV, + const GlobalValue *SrcGV) { + auto *GA = dyn_cast(SrcGV); + // Check for the special case of converting an alias (definition) to a + // non-alias (declaration). This can happen when we are importing and + // encounter a weak_any alias (weak_any defs may not be imported, see + // comments in ModuleLinker::getLinkage) or an alias whose base object is + // 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()))); + NewGV->copyAttributesFrom(GA->getBaseObject()); + } else + NewGV->copyAttributesFrom(SrcGV); + forceRenaming(NewGV, getName(SrcGV)); } static bool isLessConstraining(GlobalValue::VisibilityTypes a, @@ -550,17 +639,169 @@ static bool isLessConstraining(GlobalValue::VisibilityTypes a, return false; } +bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) { + if (!isPerformingImport()) + return false; + // 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()) + return true; + // Only import the function requested for importing. + auto *SF = dyn_cast(SGV); + if (SF && SF == ImportFunction) + return true; + // Otherwise no. + return false; +} + +bool ModuleLinker::doPromoteLocalToGlobal(const GlobalValue *SGV) { + assert(SGV->hasLocalLinkage()); + // Both the imported references and the original local variable must + // be promoted. + if (!isPerformingImport() && !isModuleExporting()) + return false; + + // Local const variables never need to be promoted unless they are address + // taken. The imported uses can simply use the clone created in this module. + // For now we are conservative in determining which variables are not + // address taken by checking the unnamed addr flag. To be more aggressive, + // the address taken information must be checked earlier during parsing + // of the module and recorded in the function index for use when importing + // from that module. + auto *GVar = dyn_cast(SGV); + if (GVar && GVar->isConstant() && GVar->hasUnnamedAddr()) + return false; + + // Eventually we only need to promote functions in the exporting module that + // are referenced by a potentially exported function (i.e. one that is in the + // function index). + return true; +} + +std::string ModuleLinker::getName(const GlobalValue *SGV) { + // For locals that must be promoted to global scope, ensure that + // the promoted name uniquely identifies the copy in the original module, + // using the ID assigned during combined index creation. When importing, + // we rename all locals (not just those that are promoted) in order to + // avoid naming conflicts between locals imported from different modules. + if (SGV->hasLocalLinkage() && + (doPromoteLocalToGlobal(SGV) || isPerformingImport())) + return FunctionInfoIndex::getGlobalNameForLocal( + SGV->getName(), + ImportIndex->getModuleId(SGV->getParent()->getModuleIdentifier())); + return SGV->getName(); +} + +GlobalValue::LinkageTypes ModuleLinker::getLinkage(const GlobalValue *SGV) { + // Any local variable that is referenced by an exported function needs + // to be promoted to global scope. Since we don't currently know which + // functions reference which local variables/functions, we must treat + // all as potentially exported if this module is exporting anything. + if (isModuleExporting()) { + if (SGV->hasLocalLinkage() && doPromoteLocalToGlobal(SGV)) + return GlobalValue::ExternalLinkage; + return SGV->getLinkage(); + } + + // Otherwise, if we aren't importing, no linkage change is needed. + if (!isPerformingImport()) + return SGV->getLinkage(); + + switch (SGV->getLinkage()) { + case GlobalValue::ExternalLinkage: + // External defnitions are converted to available_externally + // 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)) + return GlobalValue::AvailableExternallyLinkage; + // An imported external declaration stays external. + return SGV->getLinkage(); + + case GlobalValue::AvailableExternallyLinkage: + // An imported available_externally definition converts + // to external if imported as a declaration. + if (!doImportAsDefinition(SGV)) + return GlobalValue::ExternalLinkage; + // An imported available_externally declaration stays that way. + return SGV->getLinkage(); + + case GlobalValue::LinkOnceAnyLinkage: + case GlobalValue::LinkOnceODRLinkage: + // These both stay the same when importing the definition. + // The ThinLTO pass will eventually force-import their definitions. + return SGV->getLinkage(); + + case GlobalValue::WeakAnyLinkage: + // Can't import weak_any definitions correctly, or we might change the + // program semantics, since the linker will pick the first weak_any + // definition and importing would change the order they are seen by the + // linker. The module linking caller needs to enforce this. + assert(!doImportAsDefinition(SGV)); + // If imported as a declaration, it becomes external_weak. + return GlobalValue::ExternalWeakLinkage; + + case GlobalValue::WeakODRLinkage: + // For weak_odr linkage, there is a guarantee that all copies will be + // 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)) + return GlobalValue::AvailableExternallyLinkage; + else + return GlobalValue::ExternalLinkage; + + case GlobalValue::AppendingLinkage: + // It would be incorrect to import an appending linkage variable, + // since it would cause global constructors/destructors to be + // executed multiple times. This should have already been handled + // by linkGlobalValueProto. + assert(false && "Cannot import appending linkage variable"); + + case GlobalValue::InternalLinkage: + case GlobalValue::PrivateLinkage: + // 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)) + return GlobalValue::AvailableExternallyLinkage; + else + return GlobalValue::ExternalLinkage; + } + // A non-promoted imported local definition stays local. + // The ThinLTO pass will eventually force-import their definitions. + return SGV->getLinkage(); + + case GlobalValue::ExternalWeakLinkage: + // External weak doesn't apply to definitions, must be a declaration. + assert(!doImportAsDefinition(SGV)); + // Linkage stays external_weak. + return SGV->getLinkage(); + + case GlobalValue::CommonLinkage: + // Linkage stays common on definitions. + // The ThinLTO pass will eventually force-import their definitions. + return SGV->getLinkage(); + } + + llvm_unreachable("unknown linkage type"); +} + /// Loop through the global variables in the src module and merge them into the /// dest module. -static GlobalVariable *copyGlobalVariableProto(TypeMapTy &TypeMap, Module &DstM, - const GlobalVariable *SGVar) { +GlobalVariable * +ModuleLinker::copyGlobalVariableProto(TypeMapTy &TypeMap, + const GlobalVariable *SGVar) { // No linking to be performed or linking from the source: simply create an // identical version of the symbol over in the dest module... the // initializer will be filled in later by LinkGlobalInits. GlobalVariable *NewDGV = new GlobalVariable( - DstM, TypeMap.get(SGVar->getType()->getElementType()), - SGVar->isConstant(), SGVar->getLinkage(), /*init*/ nullptr, - SGVar->getName(), /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(), + *DstM, TypeMap.get(SGVar->getType()->getElementType()), + SGVar->isConstant(), getLinkage(SGVar), /*init*/ nullptr, getName(SGVar), + /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(), SGVar->getType()->getAddressSpace()); return NewDGV; @@ -568,33 +809,77 @@ static GlobalVariable *copyGlobalVariableProto(TypeMapTy &TypeMap, Module &DstM, /// Link the function in the source module into the destination module if /// needed, setting up mapping information. -static Function *copyFunctionProto(TypeMapTy &TypeMap, Module &DstM, - const Function *SF) { +Function *ModuleLinker::copyFunctionProto(TypeMapTy &TypeMap, + const Function *SF) { // If there is no linkage to be performed or we are linking from the source, // bring SF over. - return Function::Create(TypeMap.get(SF->getFunctionType()), SF->getLinkage(), - SF->getName(), &DstM); + return Function::Create(TypeMap.get(SF->getFunctionType()), getLinkage(SF), + getName(SF), DstM); } /// Set up prototypes for any aliases that come over from the source module. -static GlobalAlias *copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM, - const GlobalAlias *SGA) { +GlobalValue *ModuleLinker::copyGlobalAliasProto(TypeMapTy &TypeMap, + const GlobalAlias *SGA) { + // If we are importing and encounter a weak_any alias, or an alias to + // an object being imported as a declaration, we must import the alias + // 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()))) { + // Need to convert to declaration. All aliases must be definitions. + const GlobalValue *GVal = SGA->getBaseObject(); + GlobalValue *NewGV; + if (auto *GVar = dyn_cast(GVal)) + NewGV = copyGlobalVariableProto(TypeMap, GVar); + else { + auto *F = dyn_cast(GVal); + assert(F); + NewGV = copyFunctionProto(TypeMap, F); + } + // Set the linkage to External or ExternalWeak (see comments in + // ModuleLinker::getLinkage for why WeakAny is converted to ExternalWeak). + if (SGA->hasWeakAnyLinkage()) + 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, // bring over SGA. - auto *PTy = cast(TypeMap.get(SGA->getType())); - return GlobalAlias::create(PTy, SGA->getLinkage(), SGA->getName(), &DstM); + auto *Ty = TypeMap.get(SGA->getValueType()); + return GlobalAlias::create(Ty, SGA->getType()->getPointerAddressSpace(), + getLinkage(SGA), getName(SGA), DstM); +} + +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; + // 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)) + Visibility = GlobalValue::HiddenVisibility; + NewGV->setVisibility(Visibility); } -static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM, - const GlobalValue *SGV) { +GlobalValue *ModuleLinker::copyGlobalValueProto(TypeMapTy &TypeMap, + const GlobalValue *SGV, + const GlobalValue *DGV) { GlobalValue *NewGV; if (auto *SGVar = dyn_cast(SGV)) - NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar); + NewGV = copyGlobalVariableProto(TypeMap, SGVar); else if (auto *SF = dyn_cast(SGV)) - NewGV = copyFunctionProto(TypeMap, DstM, SF); + NewGV = copyFunctionProto(TypeMap, SF); else - NewGV = copyGlobalAliasProto(TypeMap, DstM, cast(SGV)); + NewGV = copyGlobalAliasProto(TypeMap, cast(SGV)); copyGVAttributes(NewGV, SGV); + setVisibility(NewGV, SGV, DGV); return NewGV; } @@ -603,7 +888,7 @@ Value *ValueMaterializerTy::materializeValueFor(Value *V) { if (!SGV) return nullptr; - GlobalValue *DGV = copyGlobalValueProto(TypeMap, *DstM, SGV); + GlobalValue *DGV = ModLinker->copyGlobalValueProto(TypeMap, SGV); if (Comdat *SC = SGV->getComdat()) { if (auto *DGO = dyn_cast(DGV)) { @@ -730,13 +1015,16 @@ bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest, const GlobalValue &Src) { // Should we unconditionally use the Src? - if (OverrideFromSrc) { + if (shouldOverrideFromSrc()) { LinkFromSrc = true; return false; } // We always have to add Src if it has appending linkage. if (Src.hasAppendingLinkage()) { + // Caller should have already determined that we can't link from source + // when importing (see comments in linkGlobalValueProto). + assert(!isPerformingImport()); LinkFromSrc = true; return false; } @@ -744,6 +1032,28 @@ bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc, bool SrcIsDeclaration = Src.isDeclarationForLinker(); bool DestIsDeclaration = Dest.isDeclarationForLinker(); + if (isPerformingImport()) { + if (isa(&Src)) { + // For functions, LinkFromSrc iff this is the function requested + // for importing. For variables, decide below normally. + LinkFromSrc = (&Src == ImportFunction); + return false; + } + + // Check if this is an alias with an already existing definition + // in Dest, which must have come from a prior importing pass from + // the same Src module. Unlike imported function and variable + // definitions, which are imported as available_externally and are + // not definitions for the linker, that is not a valid linkage for + // imported aliases which must be definitions. Simply use the existing + // Dest copy. + if (isa(&Src) && !DestIsDeclaration) { + assert(isa(&Dest)); + LinkFromSrc = false; + return false; + } + } + if (SrcIsDeclaration) { // If Src is external or if both Src & Dest are external.. Just link the // external globals, we aren't adding anything. @@ -1035,13 +1345,21 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { GlobalValue *DGV = getLinkedToGlobal(SGV); // Handle the ultra special appending linkage case first. + assert(!DGV || SGV->hasAppendingLinkage() == DGV->hasAppendingLinkage()); + if (SGV->hasAppendingLinkage() && isPerformingImport()) { + // Don't want to append to global_ctors list, for example, when we + // are importing for ThinLTO, otherwise the global ctors and dtors + // get executed multiple times for local variables (the latter causing + // double frees). + DoNotLinkFromSource.insert(SGV); + return false; + } if (DGV && DGV->hasAppendingLinkage()) return linkAppendingVarProto(cast(DGV), cast(SGV)); bool LinkFromSrc = true; Comdat *C = nullptr; - GlobalValue::VisibilityTypes Visibility = SGV->getVisibility(); bool HasUnnamedAddr = SGV->hasUnnamedAddr(); if (const Comdat *SC = SGV->getComdat()) { @@ -1065,12 +1383,8 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { ConstantExpr::getBitCast(DGV, TypeMap.get(SGV->getType())); } - if (DGV) { - Visibility = isLessConstraining(Visibility, DGV->getVisibility()) - ? DGV->getVisibility() - : Visibility; + if (DGV) HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); - } if (!LinkFromSrc && !DGV) return false; @@ -1078,25 +1392,29 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { GlobalValue *NewGV; if (!LinkFromSrc) { 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 && !OverrideFromSrc && + if (!DGV && !shouldOverrideFromSrc() && SGV != ImportFunction && (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() || SGV->hasAvailableExternallyLinkage())) { DoNotLinkFromSource.insert(SGV); return false; } - NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV); + // 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; + } - if (DGV && isa(DGV)) - if (auto *NewF = dyn_cast(NewGV)) - OverridingFunctions.insert(NewF); + NewGV = copyGlobalValueProto(TypeMap, SGV, DGV); } NewGV->setUnnamedAddr(HasUnnamedAddr); - NewGV->setVisibility(Visibility); if (auto *NewGO = dyn_cast(NewGV)) { if (C) @@ -1207,7 +1525,7 @@ bool ModuleLinker::linkFunctionBody(Function &Dst, Function &Src) { DI->setName(Arg.getName()); // Copy the name over. // Add a mapping to our mapping. - ValueMap[&Arg] = DI; + ValueMap[&Arg] = &*DI; ++DI; } @@ -1249,6 +1567,9 @@ void ModuleLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) { bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) { Value *Dst = ValueMap[&Src]; assert(Dst); + if (shouldInternalizeLinkedSymbols()) + if (auto *DGV = dyn_cast(Dst)) + DGV->setLinkage(GlobalValue::InternalLinkage); if (auto *F = dyn_cast(&Src)) return linkFunctionBody(cast(*Dst), *F); if (auto *GVar = dyn_cast(&Src)) { @@ -1274,41 +1595,6 @@ void ModuleLinker::linkNamedMDNodes() { } } -/// Drop DISubprograms that have been superseded. -/// -/// FIXME: this creates an asymmetric result: we strip functions from losing -/// subprograms in DstM, but leave losing subprograms in SrcM. -/// TODO: Remove this logic once the backend can correctly determine canonical -/// subprograms. -void ModuleLinker::stripReplacedSubprograms() { - // Avoid quadratic runtime by returning early when there's nothing to do. - if (OverridingFunctions.empty()) - return; - - // Move the functions now, so the set gets cleared even on early returns. - auto Functions = std::move(OverridingFunctions); - OverridingFunctions.clear(); - - // Drop functions from subprograms if they've been overridden by the new - // compile unit. - NamedMDNode *CompileUnits = DstM->getNamedMetadata("llvm.dbg.cu"); - if (!CompileUnits) - return; - for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) { - auto *CU = cast(CompileUnits->getOperand(I)); - assert(CU && "Expected valid compile unit"); - - for (DISubprogram *SP : CU->getSubprograms()) { - if (!SP || !SP->getFunction() || !Functions.count(SP->getFunction())) - continue; - - // Prevent DebugInfoFinder from tagging this as the canonical subprogram, - // since the canonical one is in the incoming module. - SP->replaceFunction(nullptr); - } - } -} - /// Merge the linker flags in Src into the Dest module. bool ModuleLinker::linkModuleFlagsMetadata() { // If the source module has no module flags, we are done. @@ -1580,13 +1866,6 @@ bool ModuleLinker::run() { MapValue(GV, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer); } - // Strip replaced subprograms before mapping any metadata -- so that we're - // not changing metadata from the source module (note that - // linkGlobalValueBody() eventually calls RemapInstruction() and therefore - // MapMetadata()) -- but after linking global value protocols -- so that - // OverridingFunctions has been built. - stripReplacedSubprograms(); - // Link in the function bodies that are defined in the source module into // DstM. for (Function &SF : *SrcM) { @@ -1598,6 +1877,10 @@ 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; } @@ -1609,15 +1892,6 @@ bool ModuleLinker::run() { linkGlobalValueBody(Src); } - // Remap all of the named MDNodes in Src into the DstM module. We do this - // after linking GlobalValues so that MDNodes that reference GlobalValues - // are properly remapped. - linkNamedMDNodes(); - - // Merge the module flags into the DstM module. - if (linkModuleFlagsMetadata()) - return true; - // Update the initializers in the DstM module now that all globals that may // be referenced are in DstM. for (GlobalVariable &Src : SrcM->globals()) { @@ -1631,12 +1905,28 @@ bool ModuleLinker::run() { 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; } + // Remap all of the named MDNodes in Src into the DstM module. We do this + // after linking GlobalValues so that MDNodes that reference GlobalValues + // are properly remapped. + linkNamedMDNodes(); + + // Merge the module flags into the DstM module. + if (linkModuleFlagsMetadata()) + return true; + return false; } @@ -1759,9 +2049,10 @@ void Linker::deleteModule() { Composite = nullptr; } -bool Linker::linkInModule(Module *Src, bool OverrideSymbols) { +bool Linker::linkInModule(Module *Src, unsigned Flags, FunctionInfoIndex *Index, + Function *FuncToImport) { ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src, - DiagnosticHandler, OverrideSymbols); + DiagnosticHandler, Flags, Index, FuncToImport); bool RetCode = TheLinker.run(); Composite->dropTriviallyDeadConstantArrays(); return RetCode; @@ -1781,14 +2072,15 @@ void Linker::setModule(Module *Dst) { /// Upon failure, the Dest module could be in a modified state, and shouldn't be /// relied on to be consistent. bool Linker::LinkModules(Module *Dest, Module *Src, - DiagnosticHandlerFunction DiagnosticHandler) { + DiagnosticHandlerFunction DiagnosticHandler, + unsigned Flags) { Linker L(Dest, DiagnosticHandler); - return L.linkInModule(Src); + return L.linkInModule(Src, Flags); } -bool Linker::LinkModules(Module *Dest, Module *Src) { +bool Linker::LinkModules(Module *Dest, Module *Src, unsigned Flags) { Linker L(Dest); - return L.linkInModule(Src); + return L.linkInModule(Src, Flags); } //===----------------------------------------------------------------------===//