Support for ThinLTO function importing and symbol linking.

Summary:
Support for necessary linkage changes and symbol renaming during
ThinLTO function importing.

Also includes llvm-link support for manually importing functions
and associated llvm-link based tests.

Note that this does not include support for intelligently importing
metadata, which is currently imported duplicate times. That support will
be in the follow-on patch, and currently is ignored by the tests.

Reviewers: dexonsmith, joker.eph, davidxl

Subscribers: tobiasvk, tejohnson, llvm-commits

Differential Revision: http://reviews.llvm.org/D13515

llvm-svn: 251837

4 files changed, 401 insertions, 44 deletions

diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 1a63e08f667..4b8b554b252 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,
-                           bool IsLazy) {
+                           const Module *ExportingModule, 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>();
+      llvm::make_unique<FunctionInfoIndex>(ExportingModule);
 
   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 94b12aae1f0..b7aab9e9644 100644
--- a/llvm/lib/Linker/LinkModules.cpp
+++ b/llvm/lib/Linker/LinkModules.cpp
@@ -369,12 +369,14 @@ 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)
+                      std::vector<GlobalValue *> &LazilyLinkGlobalValues,
+                      ModuleLinker *ModLinker)
       : ValueMaterializer(), TypeMap(TypeMap), DstM(DstM),
-        LazilyLinkGlobalValues(LazilyLinkGlobalValues) {}
+        LazilyLinkGlobalValues(LazilyLinkGlobalValues), ModLinker(ModLinker) {}
 
   Value *materializeValueFor(Value *V) override;
 };
@@ -427,12 +429,38 @@ 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)
+               DiagnosticHandlerFunction DiagnosticHandler, unsigned Flags,
+               FunctionInfoIndex *Index = nullptr,
+               Function *FuncToImport = nullptr)
       : DstM(dstM), SrcM(srcM), TypeMap(Set),
-        ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
-        DiagnosticHandler(DiagnosticHandler), Flags(Flags) {}
+        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();
 
@@ -442,6 +470,14 @@ 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);
@@ -508,6 +544,42 @@ 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();
 };
@@ -519,6 +591,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;
 
@@ -536,9 +611,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<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 bool isLessConstraining(GlobalValue::VisibilityTypes a,
@@ -554,17 +643,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<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.
-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;
@@ -572,34 +813,75 @@ 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<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;
+  }
   // 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(),
-                             SGA->getLinkage(), SGA->getName(), &DstM);
+                             getLinkage(SGA), getName(SGA), DstM);
 }
 
-static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM,
-                                         const GlobalValue *SGV) {
+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) {
   GlobalValue *NewGV;
   if (auto *SGVar = dyn_cast<GlobalVariable>(SGV))
-    NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar);
+    NewGV = copyGlobalVariableProto(TypeMap, SGVar);
   else if (auto *SF = dyn_cast<Function>(SGV))
-    NewGV = copyFunctionProto(TypeMap, DstM, SF);
+    NewGV = copyFunctionProto(TypeMap, SF);
   else
-    NewGV = copyGlobalAliasProto(TypeMap, DstM, cast<GlobalAlias>(SGV));
+    NewGV = copyGlobalAliasProto(TypeMap, cast<GlobalAlias>(SGV));
   copyGVAttributes(NewGV, SGV);
+  setVisibility(NewGV, SGV, DGV);
   return NewGV;
 }
 
@@ -608,7 +890,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<GlobalObject>(DGV)) {
@@ -742,6 +1024,9 @@ 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;
   }
@@ -749,6 +1034,28 @@ 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.
@@ -1040,13 +1347,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<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()) {
@@ -1070,12 +1385,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;
@@ -1083,10 +1394,12 @@ 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() &&
+    if (!DGV && !shouldOverrideFromSrc() && SGV != ImportFunction &&
         (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() ||
          SGV->hasAvailableExternallyLinkage())) {
       DoNotLinkFromSource.insert(SGV);
@@ -1100,7 +1413,7 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
       return false;
     }
 
-    NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV);
+    NewGV = copyGlobalValueProto(TypeMap, SGV, DGV);
 
     if (DGV && isa<Function>(DGV))
       if (auto *NewF = dyn_cast<Function>(NewGV))
@@ -1108,7 +1421,6 @@ bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) {
   }
 
   NewGV->setUnnamedAddr(HasUnnamedAddr);
-  NewGV->setVisibility(Visibility);
 
   if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) {
     if (C)
@@ -1613,6 +1925,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;
   }
@@ -1646,6 +1962,8 @@ 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.
@@ -1779,9 +2097,10 @@ void Linker::deleteModule() {
   Composite = nullptr;
 }
 
-bool Linker::linkInModule(Module *Src, unsigned Flags) {
+bool Linker::linkInModule(Module *Src, unsigned Flags, FunctionInfoIndex *Index,
+                          Function *FuncToImport) {
   ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
-                         DiagnosticHandler, Flags);
+                         DiagnosticHandler, Flags, Index, FuncToImport);
   bool RetCode = TheLinker.run();
   Composite->dropTriviallyDeadConstantArrays();
   return RetCode;
diff --git a/llvm/lib/Object/FunctionIndexObjectFile.cpp b/llvm/lib/Object/FunctionIndexObjectFile.cpp
index b1e8ebc657c..ee65990c528 100644
--- a/llvm/lib/Object/FunctionIndexObjectFile.cpp
+++ b/llvm/lib/Object/FunctionIndexObjectFile.cpp
@@ -1,5 +1,4 @@
-//===- FunctionIndexObjectFile.cpp - Function index file implementation
-//----===//
+//===- FunctionIndexObjectFile.cpp - Function index file implementation ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -86,15 +85,15 @@ bool FunctionIndexObjectFile::hasFunctionSummaryInMemBuffer(
 // function summary/index.
 ErrorOr<std::unique_ptr<FunctionIndexObjectFile>>
 FunctionIndexObjectFile::create(MemoryBufferRef Object, LLVMContext &Context,
-                                bool IsLazy) {
+                                const Module *ExportingModule, 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, IsLazy);
+  ErrorOr<std::unique_ptr<FunctionInfoIndex>> IOrErr = getFunctionInfoIndex(
+      BCOrErr.get(), Context, nullptr, ExportingModule, 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 e13c00a92e4..0e138cbbc7a 100644
--- a/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
+++ b/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
@@ -49,9 +49,46 @@ 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())
@@ -65,6 +102,7 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
     GV.removeDeadConstantUsers();
     GV.setLinkage(GlobalValue::ExternalLinkage);
     NumVariables++;
+    Changed = true;
   }
 
   // Drop the bodies of available externally functions.
@@ -76,6 +114,7 @@ bool EliminateAvailableExternally::runOnModule(Module &M) {
       F.deleteBody();
     F.removeDeadConstantUsers();
     NumFunctions++;
+    Changed = true;
   }
 
   return Changed;