summaryrefslogtreecommitdiffstats
path: root/llvm/lib
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib')
-rw-r--r--llvm/lib/Bitcode/Reader/BitcodeReader.cpp4
-rw-r--r--llvm/lib/Linker/LinkModules.cpp393
-rw-r--r--llvm/lib/Object/FunctionIndexObjectFile.cpp9
-rw-r--r--llvm/lib/Transforms/IPO/ElimAvailExtern.cpp39
4 files changed, 44 insertions, 401 deletions
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 4b8b554b252..1a63e08f667 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -5813,12 +5813,12 @@ llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer, LLVMContext &Context,
ErrorOr<std::unique_ptr<FunctionInfoIndex>>
llvm::getFunctionInfoIndex(MemoryBufferRef Buffer, LLVMContext &Context,
DiagnosticHandlerFunction DiagnosticHandler,
- const Module *ExportingModule, bool IsLazy) {
+ bool IsLazy) {
std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
FunctionIndexBitcodeReader R(Buf.get(), Context, DiagnosticHandler, IsLazy);
std::unique_ptr<FunctionInfoIndex> Index =
- llvm::make_unique<FunctionInfoIndex>(ExportingModule);
+ llvm::make_unique<FunctionInfoIndex>();
auto cleanupOnError = [&](std::error_code EC) {
R.releaseBuffer(); // Never take ownership on error.
diff --git a/llvm/lib/Linker/LinkModules.cpp b/llvm/lib/Linker/LinkModules.cpp
index b7aab9e9644..94b12aae1f0 100644
--- a/llvm/lib/Linker/LinkModules.cpp
+++ b/llvm/lib/Linker/LinkModules.cpp
@@ -369,14 +369,12 @@ 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)
+ std::vector<GlobalValue *> &LazilyLinkGlobalValues)
: ValueMaterializer(), TypeMap(TypeMap), DstM(DstM),
- LazilyLinkGlobalValues(LazilyLinkGlobalValues), ModLinker(ModLinker) {}
+ LazilyLinkGlobalValues(LazilyLinkGlobalValues) {}
Value *materializeValueFor(Value *V) override;
};
@@ -429,38 +427,12 @@ class ModuleLinker {
/// For symbol clashes, prefer those from Src.
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, unsigned Flags,
- FunctionInfoIndex *Index = nullptr,
- Function *FuncToImport = nullptr)
+ DiagnosticHandlerFunction DiagnosticHandler, unsigned Flags)
: DstM(dstM), SrcM(srcM), TypeMap(Set),
- 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);
- }
+ ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
+ DiagnosticHandler(DiagnosticHandler), Flags(Flags) {}
bool run();
@@ -470,14 +442,6 @@ public:
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);
@@ -544,42 +508,6 @@ 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();
};
@@ -591,9 +519,6 @@ 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;
@@ -611,23 +536,9 @@ static void forceRenaming(GlobalValue *GV, StringRef Name) {
/// copy additional attributes (those not needed to construct a GlobalValue)
/// from the SrcGV to the DestGV.
-void ModuleLinker::copyGVAttributes(GlobalValue *NewGV,
- const GlobalValue *SrcGV) {
- auto *GA = dyn_cast<GlobalAlias>(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<GlobalAlias>(NewGV)) {
- assert(isPerformingImport() &&
- (GA->hasWeakAnyLinkage() ||
- !doImportAsDefinition(GA->getBaseObject())));
- NewGV->copyAttributesFrom(GA->getBaseObject());
- } else
- NewGV->copyAttributesFrom(SrcGV);
- forceRenaming(NewGV, getName(SrcGV));
+static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) {
+ DestGV->copyAttributesFrom(SrcGV);
+ forceRenaming(DestGV, SrcGV->getName());
}
static bool isLessConstraining(GlobalValue::VisibilityTypes a,
@@ -643,169 +554,17 @@ 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<GlobalVariable>(SGV) && !SGV->isDeclaration())
- return true;
- // Only import the function requested for importing.
- auto *SF = dyn_cast<Function>(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<GlobalVariable>(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.
-GlobalVariable *
-ModuleLinker::copyGlobalVariableProto(TypeMapTy &TypeMap,
- const GlobalVariable *SGVar) {
+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(), getLinkage(SGVar), /*init*/ nullptr, getName(SGVar),
- /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(),
+ DstM, TypeMap.get(SGVar->getType()->getElementType()),
+ SGVar->isConstant(), SGVar->getLinkage(), /*init*/ nullptr,
+ SGVar->getName(), /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(),
SGVar->getType()->getAddressSpace());
return NewDGV;
@@ -813,75 +572,34 @@ ModuleLinker::copyGlobalVariableProto(TypeMapTy &TypeMap,
/// Link the function in the source module into the destination module if
/// needed, setting up mapping information.
-Function *ModuleLinker::copyFunctionProto(TypeMapTy &TypeMap,
- const Function *SF) {
+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()), getLinkage(SF),
- getName(SF), DstM);
+ 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::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<GlobalVariable>(GVal))
- NewGV = copyGlobalVariableProto(TypeMap, GVar);
- else {
- auto *F = dyn_cast<Function>(GVal);
- assert(F);
- NewGV = copyFunctionProto(TypeMap, F);
- }
- // Set the linkage to ExternalWeak, see also comments in
- // ModuleLinker::getLinkage.
- if (SGA->hasWeakAnyLinkage())
- NewGV->setLinkage(GlobalValue::ExternalWeakLinkage);
- // Don't attempt to link body, needs to be a declaration.
- DoNotLinkFromSource.insert(SGA);
- return NewGV;
- }
+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 *Ty = TypeMap.get(SGA->getValueType());
return GlobalAlias::create(Ty, SGA->getType()->getPointerAddressSpace(),
- getLinkage(SGA), getName(SGA), DstM);
+ SGA->getLinkage(), SGA->getName(), &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);
-}
-
-GlobalValue *ModuleLinker::copyGlobalValueProto(TypeMapTy &TypeMap,
- const GlobalValue *SGV,
- const GlobalValue *DGV) {
+static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM,
+ const GlobalValue *SGV) {
GlobalValue *NewGV;
if (auto *SGVar = dyn_cast<GlobalVariable>(SGV))
- NewGV = copyGlobalVariableProto(TypeMap, SGVar);
+ NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar);
else if (auto *SF = dyn_cast<Function>(SGV))
- NewGV = copyFunctionProto(TypeMap, SF);
+ NewGV = copyFunctionProto(TypeMap, DstM, SF);
else
- NewGV = copyGlobalAliasProto(TypeMap, cast<GlobalAlias>(SGV));
+ NewGV = copyGlobalAliasProto(TypeMap, DstM, cast<GlobalAlias>(SGV));
copyGVAttributes(NewGV, SGV);
- setVisibility(NewGV, SGV, DGV);
return NewGV;
}
@@ -890,7 +608,7 @@ Value *ValueMaterializerTy::materializeValueFor(Value *V) {
if (!SGV)
return nullptr;
- GlobalValue *DGV = ModLinker->copyGlobalValueProto(TypeMap, SGV);
+ GlobalValue *DGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
if (Comdat *SC = SGV->getComdat()) {
if (auto *DGO = dyn_cast<GlobalObject>(DGV)) {
@@ -1024,9 +742,6 @@ bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
// 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;
}
@@ -1034,28 +749,6 @@ bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
bool SrcIsDeclaration = Src.isDeclarationForLinker();
bool DestIsDeclaration = Dest.isDeclarationForLinker();
- if (isPerformingImport()) {
- if (isa<Function>(&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<GlobalAlias>(&Src) && !DestIsDeclaration) {
- assert(isa<GlobalAlias>(&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.
@@ -1347,21 +1040,13 @@ 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<GlobalVariable>(DGV),
cast<GlobalVariable>(SGV));
bool LinkFromSrc = true;
Comdat *C = nullptr;
+ GlobalValue::VisibilityTypes Visibility = SGV->getVisibility();
bool HasUnnamedAddr = SGV->hasUnnamedAddr();
if (const Comdat *SC = SGV->getComdat()) {
@@ -1385,8 +1070,12 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
ConstantExpr::getBitCast(DGV, TypeMap.get(SGV->getType()));
}
- if (DGV)
+ if (DGV) {
+ Visibility = isLessConstraining(Visibility, DGV->getVisibility())
+ ? DGV->getVisibility()
+ : Visibility;
HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr();
+ }
if (!LinkFromSrc && !DGV)
return false;
@@ -1394,12 +1083,10 @@ 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 && !shouldOverrideFromSrc() && SGV != ImportFunction &&
+ if (!DGV && !shouldOverrideFromSrc() &&
(SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() ||
SGV->hasAvailableExternallyLinkage())) {
DoNotLinkFromSource.insert(SGV);
@@ -1413,7 +1100,7 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
return false;
}
- NewGV = copyGlobalValueProto(TypeMap, SGV, DGV);
+ NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
if (DGV && isa<Function>(DGV))
if (auto *NewF = dyn_cast<Function>(NewGV))
@@ -1421,6 +1108,7 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
}
NewGV->setUnnamedAddr(HasUnnamedAddr);
+ NewGV->setVisibility(Visibility);
if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
if (C)
@@ -1925,10 +1613,6 @@ 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;
}
@@ -1962,8 +1646,6 @@ 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.
@@ -2097,10 +1779,9 @@ void Linker::deleteModule() {
Composite = nullptr;
}
-bool Linker::linkInModule(Module *Src, unsigned Flags, FunctionInfoIndex *Index,
- Function *FuncToImport) {
+bool Linker::linkInModule(Module *Src, unsigned Flags) {
ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
- DiagnosticHandler, Flags, Index, FuncToImport);
+ DiagnosticHandler, Flags);
bool RetCode = TheLinker.run();
Composite->dropTriviallyDeadConstantArrays();
return RetCode;
diff --git a/llvm/lib/Object/FunctionIndexObjectFile.cpp b/llvm/lib/Object/FunctionIndexObjectFile.cpp
index ee65990c528..b1e8ebc657c 100644
--- a/llvm/lib/Object/FunctionIndexObjectFile.cpp
+++ b/llvm/lib/Object/FunctionIndexObjectFile.cpp
@@ -1,4 +1,5 @@
-//===- FunctionIndexObjectFile.cpp - Function index file implementation ---===//
+//===- FunctionIndexObjectFile.cpp - Function index file implementation
+//----===//
//
// The LLVM Compiler Infrastructure
//
@@ -85,15 +86,15 @@ bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
// function summary/index.
ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
- const Module *ExportingModule, bool IsLazy) {
+ bool IsLazy) {
std::unique_ptr<FunctionInfoIndex> Index;
ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
if (!BCOrErr)
return BCOrErr.getError();
- ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = getFunctionInfoIndex(
- BCOrErr.get(), Context, nullptr, ExportingModule, IsLazy);
+ ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr =
+ getFunctionInfoIndex(BCOrErr.get(), Context, nullptr, IsLazy);
if (std::error_code EC = IOrErr.getError())
return EC;
diff --git a/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp b/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
index 0e138cbbc7a..e13c00a92e4 100644
--- a/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
+++ b/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
@@ -49,46 +49,9 @@ ModulePass *llvm::createEliminateAvailableExternallyPass() {
return new EliminateAvailableExternally();
}
-static void convertAliasToDeclaration(GlobalAlias &GA, Module &M) {
- GlobalValue *GVal = GA.getBaseObject();
- GlobalValue *NewGV;
- if (auto *GVar = dyn_cast<GlobalVariable>(GVal)) {
- GlobalVariable *NewGVar = new GlobalVariable(
- M, GVar->getType()->getElementType(), GVar->isConstant(),
- GVar->getLinkage(), /*init*/ nullptr, GA.getName(), GVar,
- GVar->getThreadLocalMode(), GVar->getType()->getAddressSpace());
- NewGV = NewGVar;
- NewGV->copyAttributesFrom(GVar);
- } else {
- auto *F = dyn_cast<Function>(GVal);
- assert(F);
- Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),
- GA.getName(), &M);
- NewGV = NewF;
- NewGV->copyAttributesFrom(F);
- }
- GA.replaceAllUsesWith(ConstantExpr::getBitCast(NewGV, GA.getType()));
- GA.eraseFromParent();
-}
-
bool EliminateAvailableExternally::runOnModule(Module &M) {
bool Changed = false;
- // Convert any aliases that alias with an available externally
- // value (which will be turned into declarations later on in this routine)
- // into declarations themselves. All aliases must be definitions, and
- // must alias with a definition. So this involves creating a declaration
- // equivalent to the alias's base object.
- for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); I != E;) {
- // Increment the iterator first since we may delete the current alias.
- GlobalAlias &GA = *(I++);
- GlobalValue *GVal = GA.getBaseObject();
- if (!GVal->hasAvailableExternallyLinkage())
- continue;
- convertAliasToDeclaration(GA, M);
- Changed = true;
- }
-
// Drop initializers of available externally global variables.
for (GlobalVariable &GV : M.globals()) {
if (!GV.hasAvailableExternallyLinkage())
@@ -102,7 +65,6 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
GV.removeDeadConstantUsers();
GV.setLinkage(GlobalValue::ExternalLinkage);
NumVariables++;
- Changed = true;
}
// Drop the bodies of available externally functions.
@@ -114,7 +76,6 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
F.deleteBody();
F.removeDeadConstantUsers();
NumFunctions++;
- Changed = true;
}
return Changed;
OpenPOWER on IntegriCloud