#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/Triple.h"
#include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h"
bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
};
-}
+} // namespace
void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
assert(SpeculativeTypes.empty());
Elements[I] = get(SrcSTy->getElementType(I));
DstSTy->setBody(Elements, SrcSTy->isPacked());
+ DstStructTypesSet.switchToNonOpaque(DstSTy);
}
SrcDefinitionsToResolve.clear();
DstResolvedOpaqueTypes.clear();
class ValueMaterializerTy : public ValueMaterializer {
TypeMapTy &TypeMap;
Module *DstM;
- std::vector<Function *> &LazilyLinkFunctions;
+ std::vector<GlobalValue *> &LazilyLinkGlobalValues;
public:
ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM,
- std::vector<Function *> &LazilyLinkFunctions)
+ std::vector<GlobalValue *> &LazilyLinkGlobalValues)
: ValueMaterializer(), TypeMap(TypeMap), DstM(DstM),
- LazilyLinkFunctions(LazilyLinkFunctions) {}
+ LazilyLinkGlobalValues(LazilyLinkGlobalValues) {}
Value *materializeValueFor(Value *V) override;
};
// Set of items not to link in from source.
SmallPtrSet<const Value *, 16> DoNotLinkFromSource;
- // Vector of functions to lazily link in.
- std::vector<Function *> LazilyLinkFunctions;
+ // Vector of GlobalValues to lazily link in.
+ std::vector<GlobalValue *> LazilyLinkGlobalValues;
+
+ /// Functions that have replaced other functions.
+ SmallPtrSet<const Function *, 16> OverridingFunctions;
+
+ DiagnosticHandlerFunction DiagnosticHandler;
- Linker::DiagnosticHandlerFunction DiagnosticHandler;
+ /// For symbol clashes, prefer those from Src.
+ bool OverrideFromSrc;
public:
ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM,
- Linker::DiagnosticHandlerFunction DiagnosticHandler)
+ DiagnosticHandlerFunction DiagnosticHandler,
+ bool OverrideFromSrc)
: DstM(dstM), SrcM(srcM), TypeMap(Set),
- ValMaterializer(TypeMap, DstM, LazilyLinkFunctions),
- DiagnosticHandler(DiagnosticHandler) {}
+ ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
+ DiagnosticHandler(DiagnosticHandler), OverrideFromSrc(OverrideFromSrc) {
+ }
bool run();
const GlobalVariable *SrcGV);
bool linkGlobalValueProto(GlobalValue *GV);
- GlobalValue *linkGlobalVariableProto(const GlobalVariable *SGVar,
- GlobalValue *DGV, bool LinkFromSrc);
- GlobalValue *linkFunctionProto(const Function *SF, GlobalValue *DGV,
- bool LinkFromSrc);
- GlobalValue *linkGlobalAliasProto(const GlobalAlias *SGA, GlobalValue *DGV,
- bool LinkFromSrc);
-
bool linkModuleFlagsMetadata();
void linkAppendingVarInit(const AppendingVarInfo &AVI);
- void linkGlobalInits();
- void linkFunctionBody(Function *Dst, Function *Src);
- void linkAliasBodies();
+
+ void linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src);
+ bool linkFunctionBody(Function &Dst, Function &Src);
+ void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src);
+ bool linkGlobalValueBody(GlobalValue &Src);
+
void linkNamedMDNodes();
+ void stripReplacedSubprograms();
};
-}
+} // namespace
/// The LLVM SymbolTable class autorenames globals that conflict in the symbol
/// table. This is good for all clients except for us. Go through the trouble
return false;
}
+/// 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) {
+ // 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(),
+ SGVar->getType()->getAddressSpace());
+
+ return NewDGV;
+}
+
+/// 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) {
+ // 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);
+}
+
+/// Set up prototypes for any aliases that come over from the source module.
+static GlobalAlias *copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM,
+ const GlobalAlias *SGA) {
+ // If there is no linkage to be performed or we're linking from the source,
+ // bring over SGA.
+ auto *PTy = cast<PointerType>(TypeMap.get(SGA->getType()));
+ return GlobalAlias::create(PTy, SGA->getLinkage(), SGA->getName(), &DstM);
+}
+
+static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM,
+ const GlobalValue *SGV) {
+ GlobalValue *NewGV;
+ if (auto *SGVar = dyn_cast<GlobalVariable>(SGV))
+ NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar);
+ else if (auto *SF = dyn_cast<Function>(SGV))
+ NewGV = copyFunctionProto(TypeMap, DstM, SF);
+ else
+ NewGV = copyGlobalAliasProto(TypeMap, DstM, cast<GlobalAlias>(SGV));
+ copyGVAttributes(NewGV, SGV);
+ return NewGV;
+}
+
Value *ValueMaterializerTy::materializeValueFor(Value *V) {
- Function *SF = dyn_cast<Function>(V);
- if (!SF)
+ auto *SGV = dyn_cast<GlobalValue>(V);
+ if (!SGV)
return nullptr;
- Function *DF = Function::Create(TypeMap.get(SF->getFunctionType()),
- SF->getLinkage(), SF->getName(), DstM);
- copyGVAttributes(DF, SF);
+ GlobalValue *DGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
- if (Comdat *SC = SF->getComdat()) {
- Comdat *DC = DstM->getOrInsertComdat(SC->getName());
- DF->setComdat(DC);
+ if (Comdat *SC = SGV->getComdat()) {
+ if (auto *DGO = dyn_cast<GlobalObject>(DGV)) {
+ Comdat *DC = DstM->getOrInsertComdat(SC->getName());
+ DGO->setComdat(DC);
+ }
}
- LazilyLinkFunctions.push_back(SF);
- return DF;
+ LazilyLinkGlobalValues.push_back(SGV);
+ return DGV;
}
bool ModuleLinker::getComdatLeader(Module *M, StringRef ComdatName,
getComdatLeader(SrcM, ComdatName, SrcGV))
return true;
- const DataLayout *DstDL = DstM->getDataLayout();
- const DataLayout *SrcDL = SrcM->getDataLayout();
- if (!DstDL || !SrcDL) {
- return emitError(
- "Linking COMDATs named '" + ComdatName +
- "': can't do size dependent selection without DataLayout!");
- }
+ const DataLayout &DstDL = DstM->getDataLayout();
+ const DataLayout &SrcDL = SrcM->getDataLayout();
uint64_t DstSize =
- DstDL->getTypeAllocSize(DstGV->getType()->getPointerElementType());
+ DstDL.getTypeAllocSize(DstGV->getType()->getPointerElementType());
uint64_t SrcSize =
- SrcDL->getTypeAllocSize(SrcGV->getType()->getPointerElementType());
+ SrcDL.getTypeAllocSize(SrcGV->getType()->getPointerElementType());
if (Result == Comdat::SelectionKind::ExactMatch) {
if (SrcGV->getInitializer() != DstGV->getInitializer())
return emitError("Linking COMDATs named '" + ComdatName +
bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
const GlobalValue &Dest,
const GlobalValue &Src) {
+ // Should we unconditionally use the Src?
+ if (OverrideFromSrc) {
+ LinkFromSrc = true;
+ return false;
+ }
+
// We always have to add Src if it has appending linkage.
if (Src.hasAppendingLinkage()) {
LinkFromSrc = true;
return false;
}
- // FIXME: Make datalayout mandatory and just use getDataLayout().
- DataLayout DL(Dest.getParent());
-
+ const DataLayout &DL = Dest.getParent()->getDataLayout();
uint64_t DestSize = DL.getTypeAllocSize(Dest.getType()->getElementType());
uint64_t SrcSize = DL.getTypeAllocSize(Src.getType()->getElementType());
LinkFromSrc = SrcSize > DestSize;
return false;
GlobalValue *NewGV;
- if (auto *SGVar = dyn_cast<GlobalVariable>(SGV))
- NewGV = linkGlobalVariableProto(SGVar, DGV, LinkFromSrc);
- else if (auto *SF = dyn_cast<Function>(SGV))
- NewGV = linkFunctionProto(SF, DGV, LinkFromSrc);
- else
- NewGV = linkGlobalAliasProto(cast<GlobalAlias>(SGV), DGV, LinkFromSrc);
+ if (!LinkFromSrc) {
+ NewGV = 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 &&
+ (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() ||
+ SGV->hasAvailableExternallyLinkage())) {
+ DoNotLinkFromSource.insert(SGV);
+ return false;
+ }
- if (!NewGV)
- return false;
+ NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
- if (NewGV != DGV)
- copyGVAttributes(NewGV, SGV);
+ if (DGV && isa<Function>(DGV))
+ if (auto *NewF = dyn_cast<Function>(NewGV))
+ OverridingFunctions.insert(NewF);
+ }
NewGV->setUnnamedAddr(HasUnnamedAddr);
NewGV->setVisibility(Visibility);
NewGO->setAlignment(std::max(DGV->getAlignment(), SGV->getAlignment()));
}
+ if (auto *NewGVar = dyn_cast<GlobalVariable>(NewGV)) {
+ auto *DGVar = dyn_cast_or_null<GlobalVariable>(DGV);
+ auto *SGVar = dyn_cast<GlobalVariable>(SGV);
+ if (DGVar && SGVar && DGVar->isDeclaration() && SGVar->isDeclaration() &&
+ (!DGVar->isConstant() || !SGVar->isConstant()))
+ NewGVar->setConstant(false);
+ }
+
// Make sure to remember this mapping.
if (NewGV != DGV) {
if (DGV) {
return false;
}
-/// Loop through the global variables in the src module and merge them into the
-/// dest module.
-GlobalValue *ModuleLinker::linkGlobalVariableProto(const GlobalVariable *SGVar,
- GlobalValue *DGV,
- bool LinkFromSrc) {
- bool ClearConstant = false;
-
- if (DGV) {
- auto *DGVar = dyn_cast<GlobalVariable>(DGV);
- if (!SGVar->isConstant() || (DGVar && !DGVar->isConstant()))
- ClearConstant = true;
- }
-
- if (!LinkFromSrc) {
- if (auto *NewGVar = dyn_cast<GlobalVariable>(DGV)) {
- if (NewGVar->isDeclaration() && ClearConstant)
- NewGVar->setConstant(false);
- }
- return DGV;
- }
-
- // 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(),
- SGVar->getType()->getAddressSpace());
-
- return NewDGV;
-}
-
-/// Link the function in the source module into the destination module if
-/// needed, setting up mapping information.
-GlobalValue *ModuleLinker::linkFunctionProto(const Function *SF,
- GlobalValue *DGV,
- bool LinkFromSrc) {
- if (!LinkFromSrc)
- return DGV;
-
- // If the function is to be lazily linked, don't create it just yet.
- // The ValueMaterializerTy will deal with creating it if it's used.
- if (!DGV && (SF->hasLocalLinkage() || SF->hasLinkOnceLinkage() ||
- SF->hasAvailableExternallyLinkage())) {
- DoNotLinkFromSource.insert(SF);
- return nullptr;
- }
-
- // 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);
-}
-
-/// Set up prototypes for any aliases that come over from the source module.
-GlobalValue *ModuleLinker::linkGlobalAliasProto(const GlobalAlias *SGA,
- GlobalValue *DGV,
- bool LinkFromSrc) {
- if (!LinkFromSrc)
- return DGV;
-
- // If there is no linkage to be performed or we're linking from the source,
- // bring over SGA.
- auto *PTy = cast<PointerType>(TypeMap.get(SGA->getType()));
- return GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
- SGA->getLinkage(), SGA->getName(), DstM);
-}
-
static void getArrayElements(const Constant *C,
SmallVectorImpl<Constant *> &Dest) {
unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements();
/// Update the initializers in the Dest module now that all globals that may be
/// referenced are in Dest.
-void ModuleLinker::linkGlobalInits() {
- // Loop over all of the globals in the src module, mapping them over as we go
- for (Module::const_global_iterator I = SrcM->global_begin(),
- E = SrcM->global_end(); I != E; ++I) {
-
- // Only process initialized GV's or ones not already in dest.
- if (!I->hasInitializer() || DoNotLinkFromSource.count(I)) continue;
-
- // Grab destination global variable.
- GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[I]);
- // Figure out what the initializer looks like in the dest module.
- DGV->setInitializer(MapValue(I->getInitializer(), ValueMap,
- RF_None, &TypeMap, &ValMaterializer));
- }
+void ModuleLinker::linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src) {
+ // Figure out what the initializer looks like in the dest module.
+ Dst.setInitializer(MapValue(Src.getInitializer(), ValueMap, RF_None, &TypeMap,
+ &ValMaterializer));
}
/// Copy the source function over into the dest function and fix up references
/// to values. At this point we know that Dest is an external function, and
/// that Src is not.
-void ModuleLinker::linkFunctionBody(Function *Dst, Function *Src) {
- assert(Src && Dst && Dst->isDeclaration() && !Src->isDeclaration());
+bool ModuleLinker::linkFunctionBody(Function &Dst, Function &Src) {
+ assert(Dst.isDeclaration() && !Src.isDeclaration());
+
+ // Materialize if needed.
+ if (std::error_code EC = Src.materialize())
+ return emitError(EC.message());
+
+ // Link in the prefix data.
+ if (Src.hasPrefixData())
+ Dst.setPrefixData(MapValue(Src.getPrefixData(), ValueMap, RF_None, &TypeMap,
+ &ValMaterializer));
+
+ // Link in the prologue data.
+ if (Src.hasPrologueData())
+ Dst.setPrologueData(MapValue(Src.getPrologueData(), ValueMap, RF_None,
+ &TypeMap, &ValMaterializer));
+
+ // Link in the personality function.
+ if (Src.hasPersonalityFn())
+ Dst.setPersonalityFn(MapValue(Src.getPersonalityFn(), ValueMap, RF_None,
+ &TypeMap, &ValMaterializer));
// Go through and convert function arguments over, remembering the mapping.
- Function::arg_iterator DI = Dst->arg_begin();
- for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
- I != E; ++I, ++DI) {
- DI->setName(I->getName()); // Copy the name over.
+ Function::arg_iterator DI = Dst.arg_begin();
+ for (Argument &Arg : Src.args()) {
+ DI->setName(Arg.getName()); // Copy the name over.
// Add a mapping to our mapping.
- ValueMap[I] = DI;
+ ValueMap[&Arg] = DI;
+ ++DI;
}
+ // Copy over the metadata attachments.
+ SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
+ Src.getAllMetadata(MDs);
+ for (const auto &I : MDs)
+ Dst.setMetadata(I.first, MapMetadata(I.second, ValueMap, RF_None, &TypeMap,
+ &ValMaterializer));
+
// Splice the body of the source function into the dest function.
- Dst->getBasicBlockList().splice(Dst->end(), Src->getBasicBlockList());
+ Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList());
// At this point, all of the instructions and values of the function are now
// copied over. The only problem is that they are still referencing values in
// the Source function as operands. Loop through all of the operands of the
// functions and patch them up to point to the local versions.
- for (Function::iterator BB = Dst->begin(), BE = Dst->end(); BB != BE; ++BB)
- for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
- RemapInstruction(I, ValueMap, RF_IgnoreMissingEntries, &TypeMap,
+ for (BasicBlock &BB : Dst)
+ for (Instruction &I : BB)
+ RemapInstruction(&I, ValueMap, RF_IgnoreMissingEntries, &TypeMap,
&ValMaterializer);
// There is no need to map the arguments anymore.
- for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
- I != E; ++I)
- ValueMap.erase(I);
+ for (Argument &Arg : Src.args())
+ ValueMap.erase(&Arg);
+ Src.dematerialize();
+ return false;
}
-/// Insert all of the aliases in Src into the Dest module.
-void ModuleLinker::linkAliasBodies() {
- for (Module::alias_iterator I = SrcM->alias_begin(), E = SrcM->alias_end();
- I != E; ++I) {
- if (DoNotLinkFromSource.count(I))
- continue;
- if (Constant *Aliasee = I->getAliasee()) {
- GlobalAlias *DA = cast<GlobalAlias>(ValueMap[I]);
- Constant *Val =
- MapValue(Aliasee, ValueMap, RF_None, &TypeMap, &ValMaterializer);
- DA->setAliasee(Val);
- }
+void ModuleLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) {
+ Constant *Aliasee = Src.getAliasee();
+ Constant *Val =
+ MapValue(Aliasee, ValueMap, RF_None, &TypeMap, &ValMaterializer);
+ Dst.setAliasee(Val);
+}
+
+bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) {
+ Value *Dst = ValueMap[&Src];
+ assert(Dst);
+ if (auto *F = dyn_cast<Function>(&Src))
+ return linkFunctionBody(cast<Function>(*Dst), *F);
+ if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) {
+ linkGlobalInit(cast<GlobalVariable>(*Dst), *GVar);
+ return false;
}
+ linkAliasBody(cast<GlobalAlias>(*Dst), cast<GlobalAlias>(Src));
+ return false;
}
/// Insert all of the named MDNodes in Src into the Dest module.
void ModuleLinker::linkNamedMDNodes() {
const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
- for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(),
- E = SrcM->named_metadata_end(); I != E; ++I) {
+ for (const NamedMDNode &NMD : SrcM->named_metadata()) {
// Don't link module flags here. Do them separately.
- if (&*I == SrcModFlags) continue;
- NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName());
+ if (&NMD == SrcModFlags)
+ continue;
+ NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(NMD.getName());
// Add Src elements into Dest node.
- for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
- DestNMD->addOperand(MapValue(I->getOperand(i), ValueMap,
- RF_None, &TypeMap, &ValMaterializer));
+ for (const MDNode *op : NMD.operands())
+ DestNMD->addOperand(
+ MapMetadata(op, ValueMap, RF_None, &TypeMap, &ValMaterializer));
+ }
+}
+
+/// 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<DICompileUnit>(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);
+ }
}
}
}
// First build a map of the existing module flags and requirements.
- DenseMap<MDString*, MDNode*> Flags;
+ DenseMap<MDString *, std::pair<MDNode *, unsigned>> Flags;
SmallSetVector<MDNode*, 16> Requirements;
for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
MDNode *Op = DstModFlags->getOperand(I);
- ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0));
+ ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
MDString *ID = cast<MDString>(Op->getOperand(1));
if (Behavior->getZExtValue() == Module::Require) {
Requirements.insert(cast<MDNode>(Op->getOperand(2)));
} else {
- Flags[ID] = Op;
+ Flags[ID] = std::make_pair(Op, I);
}
}
bool HasErr = false;
for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
MDNode *SrcOp = SrcModFlags->getOperand(I);
- ConstantInt *SrcBehavior = cast<ConstantInt>(SrcOp->getOperand(0));
+ ConstantInt *SrcBehavior =
+ mdconst::extract<ConstantInt>(SrcOp->getOperand(0));
MDString *ID = cast<MDString>(SrcOp->getOperand(1));
- MDNode *DstOp = Flags.lookup(ID);
+ MDNode *DstOp;
+ unsigned DstIndex;
+ std::tie(DstOp, DstIndex) = Flags.lookup(ID);
unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();
// If this is a requirement, add it and continue.
// If there is no existing flag with this ID, just add it.
if (!DstOp) {
- Flags[ID] = SrcOp;
+ Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands());
DstModFlags->addOperand(SrcOp);
continue;
}
// Otherwise, perform a merge.
- ConstantInt *DstBehavior = cast<ConstantInt>(DstOp->getOperand(0));
+ ConstantInt *DstBehavior =
+ mdconst::extract<ConstantInt>(DstOp->getOperand(0));
unsigned DstBehaviorValue = DstBehavior->getZExtValue();
// If either flag has override behavior, handle it first.
continue;
} else if (SrcBehaviorValue == Module::Override) {
// Update the destination flag to that of the source.
- DstOp->replaceOperandWith(0, SrcBehavior);
- DstOp->replaceOperandWith(2, SrcOp->getOperand(2));
+ DstModFlags->setOperand(DstIndex, SrcOp);
+ Flags[ID].first = SrcOp;
continue;
}
continue;
}
+ auto replaceDstValue = [&](MDNode *New) {
+ Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
+ MDNode *Flag = MDNode::get(DstM->getContext(), FlagOps);
+ DstModFlags->setOperand(DstIndex, Flag);
+ Flags[ID].first = Flag;
+ };
+
// Perform the merge for standard behavior types.
switch (SrcBehaviorValue) {
case Module::Require:
case Module::Append: {
MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
- unsigned NumOps = DstValue->getNumOperands() + SrcValue->getNumOperands();
- Value **VP, **Values = VP = new Value*[NumOps];
- for (unsigned i = 0, e = DstValue->getNumOperands(); i != e; ++i, ++VP)
- *VP = DstValue->getOperand(i);
- for (unsigned i = 0, e = SrcValue->getNumOperands(); i != e; ++i, ++VP)
- *VP = SrcValue->getOperand(i);
- DstOp->replaceOperandWith(2, MDNode::get(DstM->getContext(),
- ArrayRef<Value*>(Values,
- NumOps)));
- delete[] Values;
+ SmallVector<Metadata *, 8> MDs;
+ MDs.reserve(DstValue->getNumOperands() + SrcValue->getNumOperands());
+ MDs.append(DstValue->op_begin(), DstValue->op_end());
+ MDs.append(SrcValue->op_begin(), SrcValue->op_end());
+
+ replaceDstValue(MDNode::get(DstM->getContext(), MDs));
break;
}
case Module::AppendUnique: {
- SmallSetVector<Value*, 16> Elts;
+ SmallSetVector<Metadata *, 16> Elts;
MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
- for (unsigned i = 0, e = DstValue->getNumOperands(); i != e; ++i)
- Elts.insert(DstValue->getOperand(i));
- for (unsigned i = 0, e = SrcValue->getNumOperands(); i != e; ++i)
- Elts.insert(SrcValue->getOperand(i));
- DstOp->replaceOperandWith(2, MDNode::get(DstM->getContext(),
- ArrayRef<Value*>(Elts.begin(),
- Elts.end())));
+ Elts.insert(DstValue->op_begin(), DstValue->op_end());
+ Elts.insert(SrcValue->op_begin(), SrcValue->op_end());
+
+ replaceDstValue(MDNode::get(DstM->getContext(),
+ makeArrayRef(Elts.begin(), Elts.end())));
break;
}
}
for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
MDNode *Requirement = Requirements[I];
MDString *Flag = cast<MDString>(Requirement->getOperand(0));
- Value *ReqValue = Requirement->getOperand(1);
+ Metadata *ReqValue = Requirement->getOperand(1);
- MDNode *Op = Flags[Flag];
+ MDNode *Op = Flags[Flag].first;
if (!Op || Op->getOperand(2) != ReqValue) {
HasErr |= emitError("linking module flags '" + Flag->getString() +
"': does not have the required value");
return HasErr;
}
+// This function returns true if the triples match.
+static bool triplesMatch(const Triple &T0, const Triple &T1) {
+ // If vendor is apple, ignore the version number.
+ if (T0.getVendor() == Triple::Apple)
+ return T0.getArch() == T1.getArch() &&
+ T0.getSubArch() == T1.getSubArch() &&
+ T0.getVendor() == T1.getVendor() &&
+ T0.getOS() == T1.getOS();
+
+ return T0 == T1;
+}
+
+// This function returns the merged triple.
+static std::string mergeTriples(const Triple &SrcTriple, const Triple &DstTriple) {
+ // If vendor is apple, pick the triple with the larger version number.
+ if (SrcTriple.getVendor() == Triple::Apple)
+ if (DstTriple.isOSVersionLT(SrcTriple))
+ return SrcTriple.str();
+
+ return DstTriple.str();
+}
+
bool ModuleLinker::run() {
assert(DstM && "Null destination module");
assert(SrcM && "Null source module");
// Inherit the target data from the source module if the destination module
// doesn't have one already.
- if (!DstM->getDataLayout() && SrcM->getDataLayout())
+ if (DstM->getDataLayout().isDefault())
DstM->setDataLayout(SrcM->getDataLayout());
- // Copy the target triple from the source to dest if the dest's is empty.
- if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
- DstM->setTargetTriple(SrcM->getTargetTriple());
-
- if (SrcM->getDataLayout() && DstM->getDataLayout() &&
- *SrcM->getDataLayout() != *DstM->getDataLayout()) {
+ if (SrcM->getDataLayout() != DstM->getDataLayout()) {
emitWarning("Linking two modules of different data layouts: '" +
SrcM->getModuleIdentifier() + "' is '" +
SrcM->getDataLayoutStr() + "' whereas '" +
DstM->getModuleIdentifier() + "' is '" +
DstM->getDataLayoutStr() + "'\n");
}
- if (!SrcM->getTargetTriple().empty() &&
- DstM->getTargetTriple() != SrcM->getTargetTriple()) {
+
+ // Copy the target triple from the source to dest if the dest's is empty.
+ if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
+ DstM->setTargetTriple(SrcM->getTargetTriple());
+
+ Triple SrcTriple(SrcM->getTargetTriple()), DstTriple(DstM->getTargetTriple());
+
+ if (!SrcM->getTargetTriple().empty() && !triplesMatch(SrcTriple, DstTriple))
emitWarning("Linking two modules of different target triples: " +
SrcM->getModuleIdentifier() + "' is '" +
SrcM->getTargetTriple() + "' whereas '" +
DstM->getModuleIdentifier() + "' is '" +
DstM->getTargetTriple() + "'\n");
- }
+
+ DstM->setTargetTriple(mergeTriples(SrcTriple, DstTriple));
// Append the module inline asm string.
if (!SrcM->getModuleInlineAsm().empty()) {
// Insert all of the globals in src into the DstM module... without linking
// initializers (which could refer to functions not yet mapped over).
- for (Module::global_iterator I = SrcM->global_begin(),
- E = SrcM->global_end(); I != E; ++I)
- if (linkGlobalValueProto(I))
+ for (GlobalVariable &GV : SrcM->globals())
+ if (linkGlobalValueProto(&GV))
return true;
// Link the functions together between the two modules, without doing function
// 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 (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I)
- if (linkGlobalValueProto(I))
+ for (Function &F :*SrcM)
+ if (linkGlobalValueProto(&F))
return true;
// If there were any aliases, link them now.
- for (Module::alias_iterator I = SrcM->alias_begin(),
- E = SrcM->alias_end(); I != E; ++I)
- if (linkGlobalValueProto(I))
+ for (GlobalAlias &GA : SrcM->aliases())
+ if (linkGlobalValueProto(&GA))
return true;
- for (unsigned i = 0, e = AppendingVars.size(); i != e; ++i)
- linkAppendingVarInit(AppendingVars[i]);
+ for (const AppendingVarInfo &AppendingVar : AppendingVars)
+ linkAppendingVarInit(AppendingVar);
- // Link in the function bodies that are defined in the source module into
- // DstM.
- for (Module::iterator SF = SrcM->begin(), E = SrcM->end(); SF != E; ++SF) {
- // Skip if not linking from source.
- if (DoNotLinkFromSource.count(SF)) continue;
-
- Function *DF = cast<Function>(ValueMap[SF]);
-
- // Link in the prefix data.
- if (SF->hasPrefixData())
- DF->setPrefixData(MapValue(
- SF->getPrefixData(), ValueMap, RF_None, &TypeMap, &ValMaterializer));
-
- // Link in the prologue data.
- if (SF->hasPrologueData())
- DF->setPrologueData(MapValue(
- SF->getPrologueData(), ValueMap, RF_None, &TypeMap, &ValMaterializer));
+ for (const auto &Entry : DstM->getComdatSymbolTable()) {
+ const Comdat &C = Entry.getValue();
+ if (C.getSelectionKind() == Comdat::Any)
+ continue;
+ const GlobalValue *GV = SrcM->getNamedValue(C.getName());
+ assert(GV);
+ MapValue(GV, ValueMap, RF_None, &TypeMap, &ValMaterializer);
+ }
- // Materialize if needed.
- if (std::error_code EC = SF->materialize())
- return emitError(EC.message());
+ // 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) {
// Skip if no body (function is external).
- if (SF->isDeclaration())
+ if (SF.isDeclaration())
continue;
- linkFunctionBody(DF, SF);
- SF->Dematerialize();
+ // Skip if not linking from source.
+ if (DoNotLinkFromSource.count(&SF))
+ continue;
+
+ if (linkGlobalValueBody(SF))
+ return true;
}
// Resolve all uses of aliases with aliasees.
- linkAliasBodies();
+ for (GlobalAlias &Src : SrcM->aliases()) {
+ if (DoNotLinkFromSource.count(&Src))
+ continue;
+ 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
// Update the initializers in the DstM module now that all globals that may
// be referenced are in DstM.
- linkGlobalInits();
+ 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.
- bool LinkedInAnyFunctions;
- do {
- LinkedInAnyFunctions = false;
-
- for(std::vector<Function*>::iterator I = LazilyLinkFunctions.begin(),
- E = LazilyLinkFunctions.end(); I != E; ++I) {
- Function *SF = *I;
- if (!SF)
- continue;
-
- Function *DF = cast<Function>(ValueMap[SF]);
- if (SF->hasPrefixData()) {
- // Link in the prefix data.
- DF->setPrefixData(MapValue(SF->getPrefixData(),
- ValueMap,
- RF_None,
- &TypeMap,
- &ValMaterializer));
- }
-
- // Materialize if needed.
- if (std::error_code EC = SF->materialize())
- return emitError(EC.message());
-
- // Skip if no body (function is external).
- if (SF->isDeclaration())
- continue;
-
- // Erase from vector *before* the function body is linked - linkFunctionBody could
- // invalidate I.
- LazilyLinkFunctions.erase(I);
+ while (!LazilyLinkGlobalValues.empty()) {
+ GlobalValue *SGV = LazilyLinkGlobalValues.back();
+ LazilyLinkGlobalValues.pop_back();
- // Link in function body.
- linkFunctionBody(DF, SF);
- SF->Dematerialize();
-
- // Set flag to indicate we may have more functions to lazily link in
- // since we linked in a function.
- LinkedInAnyFunctions = true;
- break;
- }
- } while (LinkedInAnyFunctions);
+ assert(!SGV->isDeclaration() && "users should not pass down decls");
+ if (linkGlobalValueBody(*SGV))
+ return true;
+ }
return false;
}
void Linker::IdentifiedStructTypeSet::addNonOpaque(StructType *Ty) {
assert(!Ty->isOpaque());
- bool &Entry = NonOpaqueStructTypes[Ty];
- Entry = true;
+ NonOpaqueStructTypes.insert(Ty);
+}
+
+void Linker::IdentifiedStructTypeSet::switchToNonOpaque(StructType *Ty) {
+ assert(!Ty->isOpaque());
+ NonOpaqueStructTypes.insert(Ty);
+ bool Removed = OpaqueStructTypes.erase(Ty);
+ (void)Removed;
+ assert(Removed);
}
void Linker::IdentifiedStructTypeSet::addOpaque(StructType *Ty) {
auto I = NonOpaqueStructTypes.find_as(Key);
if (I == NonOpaqueStructTypes.end())
return nullptr;
- return I->first;
+ return *I;
}
bool Linker::IdentifiedStructTypeSet::hasType(StructType *Ty) {
auto I = NonOpaqueStructTypes.find(Ty);
if (I == NonOpaqueStructTypes.end())
return false;
- return I->first == Ty;
+ return *I == Ty;
}
void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) {
Composite = nullptr;
}
-bool Linker::linkInModule(Module *Src) {
+bool Linker::linkInModule(Module *Src, bool OverrideSymbols) {
ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
- DiagnosticHandler);
- return TheLinker.run();
+ DiagnosticHandler, OverrideSymbols);
+ bool RetCode = TheLinker.run();
+ Composite->dropTriviallyDeadConstantArrays();
+ return RetCode;
+}
+
+void Linker::setModule(Module *Dst) {
+ init(Dst, DiagnosticHandler);
}
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
LLVMBool LLVMLinkModules(LLVMModuleRef Dest, LLVMModuleRef Src,
- LLVMLinkerMode Mode, char **OutMessages) {
+ LLVMLinkerMode Unused, char **OutMessages) {
Module *D = unwrap(Dest);
std::string Message;
raw_string_ostream Stream(Message);
LLVMBool Result = Linker::LinkModules(
D, unwrap(Src), [&](const DiagnosticInfo &DI) { DI.print(DP); });
- if (OutMessages && Result)
+ if (OutMessages && Result) {
+ Stream.flush();
*OutMessages = strdup(Message.c_str());
+ }
return Result;
}
projects / oota-llvm.git / blobdiff