ComdatsChosen;
bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
bool &LinkFromSrc);
+ // Keep track of the global value members of each comdat in source.
+ DenseMap<const Comdat *, std::vector<GlobalValue *>> ComdatMembers;
/// Given a global in the source module, return the global in the
/// destination module that is being linked to, if any.
// being imported as a declaration. In that case copy the attributes from the
// base object.
if (GA && !dyn_cast<GlobalAlias>(NewGV)) {
- assert(isPerformingImport() &&
- (GA->hasWeakAnyLinkage() ||
- !doImportAsDefinition(GA->getBaseObject())));
+ assert(isPerformingImport() && !doImportAsDefinition(GA));
NewGV->copyAttributesFrom(GA->getBaseObject());
} else
NewGV->copyAttributesFrom(SrcGV);
bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) {
if (!isPerformingImport())
return false;
- // Always import GlobalVariable definitions. The linkage changes
+ auto *GA = dyn_cast<GlobalAlias>(SGV);
+ if (GA) {
+ if (GA->hasWeakAnyLinkage())
+ return false;
+ return doImportAsDefinition(GA->getBaseObject());
+ }
+ // Always import GlobalVariable definitions, except for the special
+ // case of WeakAny which are imported as ExternalWeak declarations
+ // (see comments in ModuleLinker::getLinkage). 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<GlobalVariable>(SGV) && !SGV->isDeclaration())
+ // available_externally definitions, which are ultimately turned into
+ // declarations after the EliminateAvailableExternally pass).
+ if (dyn_cast<GlobalVariable>(SGV) && !SGV->isDeclaration() &&
+ !SGV->hasWeakAnyLinkage())
return true;
// Only import the function requested for importing.
auto *SF = dyn_cast<Function>(SGV);
// definitions upon import, so that they are available for inlining
// and/or optimization, but are turned into declarations later
// during the EliminateAvailableExternally pass.
- if (doImportAsDefinition(SGV))
+ if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
return GlobalValue::AvailableExternallyLinkage;
// An imported external declaration stays external.
return SGV->getLinkage();
// equivalent, so the issue described above for weak_any does not exist,
// and the definition can be imported. It can be treated similarly
// to an imported externally visible global value.
- if (doImportAsDefinition(SGV))
+ if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
return GlobalValue::AvailableExternallyLinkage;
else
return GlobalValue::ExternalLinkage;
// 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");
+ llvm_unreachable("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))
+ if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
return GlobalValue::AvailableExternallyLinkage;
else
return GlobalValue::ExternalLinkage;
// as a declaration as well, which involves converting it to a non-alias.
// See comments in ModuleLinker::getLinkage for why we cannot import
// weak_any defintions.
- if (isPerformingImport() && (SGA->hasWeakAnyLinkage() ||
- !doImportAsDefinition(SGA->getBaseObject()))) {
+ if (isPerformingImport() && !doImportAsDefinition(SGA)) {
// Need to convert to declaration. All aliases must be definitions.
const GlobalValue *GVal = SGA->getBaseObject();
GlobalValue *NewGV;
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,
std::tie(SK, LinkFromSrc) = ComdatsChosen[SC];
C = DstM->getOrInsertComdat(SC->getName());
C->setSelectionKind(SK);
+ ComdatMembers[SC].push_back(SGV);
} else if (DGV) {
if (shouldLinkFromSource(LinkFromSrc, *DGV, *SGV))
return true;
}
NewGV = copyGlobalValueProto(TypeMap, SGV, DGV);
+
+ if (isPerformingImport() && !doImportAsDefinition(SGV))
+ DoNotLinkFromSource.insert(SGV);
}
NewGV->setUnnamedAddr(HasUnnamedAddr);
bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) {
Value *Dst = ValueMap[&Src];
assert(Dst);
+ if (const Comdat *SC = Src.getComdat()) {
+ // To ensure that we don't generate an incomplete comdat group,
+ // we must materialize and map in any other members that are not
+ // yet materialized in Dst, which also ensures their definitions
+ // 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])
+ continue;
+ Value *NewV = ValMaterializer.materializeValueFor(SGV);
+ ValueMap[SGV] = NewV;
+ }
+ }
if (shouldInternalizeLinkedSymbols())
if (auto *DGV = dyn_cast<GlobalValue>(Dst))
DGV->setLinkage(GlobalValue::InternalLinkage);
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));
}
}
if (DoNotLinkFromSource.count(&SF))
continue;
- // When importing, only materialize the function requested for import.
- if (isPerformingImport() && &SF != ImportFunction)
- continue;
-
if (linkGlobalValueBody(SF))
return true;
}