/// 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<GlobalValue *> &LazilyLinkGlobalValues;
ModuleLinker *ModLinker;
public:
- ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM,
- std::vector<GlobalValue *> &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 {
/// 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<AppendingVarInfo> AppendingVars;
-
// Set of items not to link in from source.
- SmallPtrSet<const Value *, 16> DoNotLinkFromSource;
-
- // Vector of GlobalValues to lazily link in.
- std::vector<GlobalValue *> LazilyLinkGlobalValues;
+ SmallPtrSet<const GlobalValue *, 16> DoNotLinkFromSource;
DiagnosticHandlerFunction DiagnosticHandler;
/// 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.
/// 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) {
}
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() {
/// 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;
}
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;
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);
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;
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
// global variables with external linkage are transformed to
// available_externally definitions, which are ultimately turned into
// declarations after the EliminateAvailableExternally pass).
- if (dyn_cast<GlobalVariable>(SGV) && !SGV->isDeclaration() &&
+ if (isa<GlobalVariable>(SGV) && !SGV->isDeclaration() &&
!SGV->hasWeakAnyLinkage())
return true;
// Only import the function requested for importing.
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))
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<GlobalValue>(V);
if (!SGV)
return nullptr;
// 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<GlobalObject>(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<Function>(New)) {
+ if (!F->isDeclaration())
+ return;
+ } else if (auto *V = dyn_cast<GlobalVariable>(New)) {
+ if (V->hasInitializer())
+ return;
+ } else {
+ auto *A = cast<GlobalAlias>(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,
upgradeMismatchedGlobalArray("llvm.global_dtors");
}
+static void getArrayElements(const Constant *C,
+ SmallVectorImpl<Constant *> &Dest) {
+ unsigned NumElements = cast<ArrayType>(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<ArrayType>(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<ArrayType>(DstGV->getType()->getElementType());
- ArrayType *DstTy = cast<ArrayType>(DstGV->getType()->getElementType());
- ArrayType *SrcTy =
- cast<ArrayType>(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<Constant *, 16> DstElements;
+ if (DstGV)
+ getArrayElements(DstGV->getInitializer(), DstElements);
+
+ SmallVector<Constant *, 16> SrcElements;
+ getArrayElements(SrcGV->getInitializer(), SrcElements);
+
+ StringRef Name = SrcGV->getName();
+ bool IsNewStructor =
+ (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") &&
+ cast<StructType>(EltTy)->getNumElements() == 3;
+ if (IsNewStructor)
+ SrcElements.erase(
+ std::remove_if(SrcElements.begin(), SrcElements.end(),
+ [this](Constant *E) {
+ auto *Key = dyn_cast<GlobalValue>(
+ 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;
}
DoNotLinkFromSource.insert(SGV);
return false;
}
- if (DGV && DGV->hasAppendingLinkage())
- return linkAppendingVarProto(cast<GlobalVariable>(DGV),
+ if (SGV->hasAppendingLinkage())
+ return linkAppendingVarProto(cast_or_null<GlobalVariable>(DGV),
cast<GlobalVariable>(SGV));
bool LinkFromSrc = true;
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;
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))
NewGV->setUnnamedAddr(HasUnnamedAddr);
if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
- if (C)
+ if (C && LinkFromSrc)
NewGO->setComdat(C);
if (DGV && DGV->hasCommonLinkage() && SGV->hasCommonLinkage())
return false;
}
-static void getArrayElements(const Constant *C,
- SmallVectorImpl<Constant *> &Dest) {
- unsigned NumElements = cast<ArrayType>(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<Constant *, 16> DstElements;
- getArrayElements(AVI.DstInit, DstElements);
-
- SmallVector<Constant *, 16> SrcElements;
- getArrayElements(AVI.SrcInit, SrcElements);
-
- ArrayType *NewType = cast<ArrayType>(AVI.NewGV->getType()->getElementType());
-
- StringRef Name = AVI.NewGV->getName();
- bool IsNewStructor =
- (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") &&
- cast<StructType>(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) {
// 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<GlobalValue>(ValueMap[SGV]);
+ if (DGV && !DGV->isDeclaration())
continue;
- Value *NewV = ValMaterializer.materializeValueFor(SGV);
- ValueMap[SGV] = NewV;
+ MapValue(SGV, ValueMap, RF_MoveDistinctMDs, &TypeMap, &ValMaterializer);
}
}
if (shouldInternalizeLinkedSymbols())
NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(NMD.getName());
// Add Src elements into Dest node.
for (const MDNode *op : NMD.operands())
- DestNMD->addOperand(MapMetadata(op, ValueMap, RF_MoveDistinctMDs,
- &TypeMap, &ValMaterializer));
+ DestNMD->addOperand(MapMetadata(
+ op, ValueMap, RF_MoveDistinctMDs | RF_NullMapMissingGlobalValues,
+ &TypeMap, &ValMaterializer));
}
}
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");
// 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)
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;
return *I == Ty;
}
-void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) {
+Linker::Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler) {
this->Composite = M;
this->DiagnosticHandler = 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);
return RetCode;
}
-void Linker::setModule(Module *Dst) {
- init(Dst, DiagnosticHandler);
-}
-
//===----------------------------------------------------------------------===//
// LinkModules entrypoint.
//===----------------------------------------------------------------------===//
projects / oota-llvm.git / blobdiff