ThinLTO: Move the ODR resolution to be based purely on the summary.

[mehdi_amini]

Summary

This is a requirement for the cache handling in D18494

[mehdi_amini]

Minor cleanup

[tejohnson]

Just took a quick initial scan, one typo issue throughout: s/ResolvedORD/ResolvedODR/.

Also, what is the main gist of this change? The old code is refactored but it isn't immediately obvious to me what is different about the end state.

lib/LTO/ThinLTOCodeGenerator.cpp

171

typo: ResolvedORD ->ResolvedODR

[mehdi_amini]

(I'm not sure what you're asking about let me know if this does not answer)

Previously we loaded the IR in memory and iterated through the Module:

• looking at linkage on the GlovalValue, deciding if we need to change it.
• changing it immediately

Now the first phase is performed purely on the summary, without loading the IR.

[mehdi_amini]

s/ResolvedORD/ResolvedODR/

[tejohnson]

In D18908#395912, @joker.eph wrote:

(I'm not sure what you're asking about let me know if this does not answer)

Previously we loaded the IR in memory and iterated through the Module:

• looking at linkage on the GlovalValue, deciding if we need to change it.
• changing it immediately

Now the first phase is performed purely on the summary, without loading the IR.

Got it. I looked at the summary but somehow not the title, was in a hurry. =)

include/llvm/Transforms/IPO/FunctionImport.h

63

(GUID -> Summary) ?

73

Looks like this new line is unnecessary (the next line's parameter appears to start at the column after "(", but maybe my eyes are deceiving me.

76

Maybe name this map consistently throughout? How about ModuleToDefinedGVSummaries?

lib/IR/ModuleSummaryIndex.cpp

81

Why? This seems like a regression in functionality from current HEAD

lib/LTO/ThinLTOCodeGenerator.cpp

196

Just a note for future cleanup - this file uses inconsistent function capitalization.

[mehdi_amini]

Address comments.

include/llvm/Transforms/IPO/FunctionImport.h

73

I changed it late and didn't clang-format it

lib/IR/ModuleSummaryIndex.cpp

81

This should be almost "code motion", please look at the changes in FunctionImport.cpp in this patch, the comment comes from there.

lib/LTO/ThinLTOCodeGenerator.cpp

196

OK, will fix in a separate patch

[tejohnson]

lib/IR/ModuleSummaryIndex.cpp

81

I know it came from there, so from the standpoint of ComputeCrossModuleImport this is not a change or regression in functionality.

However, for the ResolveODR code it is. Previously, ResolveODR on the module would walk the globals() and invoke the per-symbol ResolveODR on each. Now, because no global variables are put into the map, ResolveODR will never encounter a global variable and therefore no global variables will end up in the ResolvedODR map. So AFAICT the globals() handling in fixupODR will never actually encounter a global variable that is in this set, and no global variables will ever be fixed up.

Looks like test/ThinLTO/X86/odr_resolution.ll does not contain any global variables, so that's why the change in functionality wasn't detected - can you add one there?

[mehdi_amini]

lib/IR/ModuleSummaryIndex.cpp

81

Oh yes, from the point of view of the ODR it is a change. However I intended it since this is a "compile time optimization" and emitting a global is not expensive. On the other hand reducing the "diff" between two links increases the likeliness to have a cache hit.

[mehdi_amini]

Rebase

[mehdi_amini]

Collect all the symbols defined in the module and not only the functions. This would cause trouble later for caching+internalization otherwise.

[mehdi_amini]

Anything else here?

lib/IR/ModuleSummaryIndex.cpp

81

Switch to full list and not just functions.

[mehdi_amini]

rebase

[tejohnson]

lgtm

[mehdi_amini]

r266519

include/llvm/IR/ModuleSummaryIndex.h

public:
   /// not invoke mergeFrom.
   void removeEmptySummaryEntries();
 
   /// Collect for the given module the list of function it defines
   /// (GUID -> Summary).
   void collectDefinedFunctionsForModule(
       StringRef ModulePath,
       std::map<GlobalValue::GUID, GlobalValueSummary *> &FunctionInfoMap) const;
+
+  /// Collect for each module the list of Summaries it defines (GUID ->
+  /// Summary).
+  void collectDefinedGVSummariesPerModule(
+      StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>> &
+          ModuleToDefinedGVSummaries) const;
 };
 
 } // End llvm namespace
 
 #endif

include/llvm/Transforms/IPO/FunctionImport.h

 #include "llvm/IR/GlobalValue.h"
 
 #include <functional>
 #include <map>
 #include <unordered_set>
 
 namespace llvm {
 class LLVMContext;
+class GlobalValueSummary;
 class Module;
 class ModuleSummaryIndex;
 
 /// The function importer is automatically importing function from other modules
 /// based on the provided summary informations.
 class FunctionImporter {
 public:
   /// Set of functions to import from a source module. Each entry is a map
private:
   const ModuleSummaryIndex &Index;
 
   /// Factory function to load a Module for a given identifier
   std::function<std::unique_ptr<Module>(StringRef Identifier)> ModuleLoader;
 };
 
 /// Compute all the imports and exports for every module in the Index.
 ///
+/// \p ModuleToDefinedGVSummaries contains for each Module a map
+/// (GUID -> Summary) for every global defined in the module.
+///
 /// \p ImportLists will be populated with an entry for every Module we are
 /// importing into. This entry is itself a map that can be passed to
 /// FunctionImporter::importFunctions() above (see description there).
 ///
 /// \p ExportLists contains for each Module the set of globals (GUID) that will
 /// be imported by another module, or referenced by such a function. I.e. this
 /// is the set of globals that need to be promoted/renamed appropriately.
 void ComputeCrossModuleImport(
     const ModuleSummaryIndex &Index,
+    const StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>> &
+        ModuleToDefinedGVSummaries,
     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists);
 
 /// Compute all the imports for the given module using the Index.
 ///
 /// \p ImportList will be populated with a map that can be passed to
 /// FunctionImporter::importFunctions() above (see description there).
 void ComputeCrossModuleImportForModule(
     StringRef ModulePath, const ModuleSummaryIndex &Index,
     FunctionImporter::ImportMapTy &ImportList);
 }
 
 #endif // LLVM_FUNCTIONIMPORT_H

lib/IR/ModuleSummaryIndex.cpp

 // (GUID -> Summary).
 void ModuleSummaryIndex::collectDefinedFunctionsForModule(
     StringRef ModulePath,
     std::map<GlobalValue::GUID, GlobalValueSummary *> &FunctionInfoMap) const {
   for (auto &GlobalList : *this) {
     auto GUID = GlobalList.first;
     for (auto &GlobInfo : GlobalList.second) {
       auto *Summary = dyn_cast_or_null<FunctionSummary>(GlobInfo->summary());
       if (!Summary)
         // Ignore global variable, focus on functions
         continue;
       // Ignore summaries from other modules.
       if (Summary->modulePath() != ModulePath)
         continue;
       FunctionInfoMap[GUID] = Summary;
     }
   }
 }
 
+// Collect for each module the list of function it defines (GUID -> Summary).
+void ModuleSummaryIndex::collectDefinedGVSummariesPerModule(
+    StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>> &
+        Module2FunctionInfoMap) const {
+  for (auto &GlobalList : *this) {
+    auto GUID = GlobalList.first;
+    for (auto &GlobInfo : GlobalList.second) {
+      auto *Summary = GlobInfo->summary();
+      Module2FunctionInfoMap[Summary->modulePath()][GUID] = Summary;
+    }
+  }
+}
+
 GlobalValueInfo *
 ModuleSummaryIndex::getGlobalValueInfo(uint64_t ValueGUID,
                                        bool PerModuleIndex) const {
   auto InfoList = findGlobalValueInfoList(ValueGUID);
   assert(InfoList != end() && "GlobalValue not found in index");
   assert((!PerModuleIndex || InfoList->second.size() == 1) &&
          "Expected a single entry per global value in per-module index");
   auto &Info = InfoList->second[0];
   return Info.get();
 }

lib/LTO/ThinLTOCodeGenerator.cpp

 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 
 using namespace llvm;
 
+#define DEBUG_TYPE "thinlto"
+
 namespace llvm {
 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
 extern cl::opt<bool> LTODiscardValueNames;
 }
 
 namespace {
 
 static cl::opt<int> ThreadCount("threads",
if (llvm::any_of(
             auto Linkage = FuncInfo->summary()->linkage();
             return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
                    !GlobalValue::isWeakForLinker(Linkage);
           }))
     return false;
   return true;
 }
 
-static void ResolveODR(GlobalValue &GV, const ModuleSummaryIndex &Index,
-                             StringRef ModulePath) {
-  if (GV.isDeclaration())
-    return;
-
+static GlobalValue::LinkageTypes ResolveODR(const ModuleSummaryIndex &Index,
+                                            StringRef ModuleIdentifier,
+                                            GlobalValue::GUID GUID,
+                                            const GlobalValueSummary &GV) {
   auto HasMultipleCopies =
       [&](const GlobalValueInfoList &GVInfo) { return GVInfo.size() > 1; };
 
-  auto getGVInfo = [&](GlobalValue &GV) -> const GlobalValueInfoList *{
-    auto GUID = Function::getGlobalIdentifier(GV.getName(), GV.getLinkage(),
-                                              ModulePath);
-    auto It = Index.findGlobalValueInfoList(GV.getName());
-    if (It == Index.end())
-      return nullptr;
-    return &It->second;
-  };
-
-  switch (GV.getLinkage()) {
+  auto OriginalLinkage = GV.linkage();
+  switch (OriginalLinkage) {
   case GlobalValue::ExternalLinkage:
   case GlobalValue::AvailableExternallyLinkage:
   case GlobalValue::AppendingLinkage:
   case GlobalValue::InternalLinkage:
   case GlobalValue::PrivateLinkage:
   case GlobalValue::ExternalWeakLinkage:
   case GlobalValue::CommonLinkage:
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::WeakAnyLinkage:
     break;
   case GlobalValue::LinkOnceODRLinkage:
   case GlobalValue::WeakODRLinkage: {
-    auto *GVInfo = getGVInfo(GV);
-    if (!GVInfo)
-      break;
+    auto &GVInfo = Index.findGlobalValueInfoList(GUID)->second;
     // We need to emit only one of these, the first module will keep
     // it, but turned into a weak while the others will drop it.
-    if (!HasMultipleCopies(*GVInfo))
+    if (!HasMultipleCopies(GVInfo))
       break;
-    if (IsFirstDefinitionForLinker(*GVInfo, Index, ModulePath))
-      GV.setLinkage(GlobalValue::WeakODRLinkage);
+    if (IsFirstDefinitionForLinker(GVInfo, Index, ModuleIdentifier))
+      return GlobalValue::WeakODRLinkage;
     else
-      GV.setLinkage(GlobalValue::AvailableExternallyLinkage);
+      return GlobalValue::AvailableExternallyLinkage;
     break;
   }
   }
+  return OriginalLinkage;
 }
 
 /// Resolve LinkOnceODR and WeakODR.
 ///
 /// We'd like to drop these function if they are no longer referenced in the
 /// current module. However there is a chance that another module is still
 /// referencing them because of the import. We make sure we always emit at least
 /// one copy.
-static void ResolveODR(Module &TheModule,
-                             const ModuleSummaryIndex &Index) {
+static void ResolveODR(
+    const ModuleSummaryIndex &Index,
+    const std::map<GlobalValue::GUID, GlobalValueSummary *> &DefinedGlobals,
+    StringRef ModuleIdentifier,
+    DenseMap<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR) {
   if (Index.modulePaths().size() == 1)
     // Nothing to do if we don't have multiple modules
     return;
 
   // We won't optimize the globals that are referenced by an alias for now
   // Ideally we should turn the alias into a global and duplicate the definition
   // when needed.
-  DenseSet<GlobalValue *> GlobalInvolvedWithAlias;
-  for (auto &GA : TheModule.aliases()) {
-    auto *GO = GA.getBaseObject();
-    if (auto *GV = dyn_cast<GlobalValue>(GO))
-      GlobalInvolvedWithAlias.insert(GV);
-  }
+  DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
+  for (auto &GA : DefinedGlobals) {
+    if (auto AS = dyn_cast<AliasSummary>(GA.second))
+      GlobalInvolvedWithAlias.insert(&AS->getAliasee());
+  }
+
+  for (auto &GV : DefinedGlobals) {
+    if (GlobalInvolvedWithAlias.count(GV.second))
+      continue;
+    auto NewLinkage = ResolveODR(Index, ModuleIdentifier, GV.first, *GV.second);
+    if (NewLinkage != GV.second->linkage()) {
+      ResolvedODR[GV.first] = NewLinkage;
+    }
+  }
+
+/// Fixup linkage, see ResolveODR() above.
+void fixupODR(
+    Module &TheModule,
+    const DenseMap<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR) {
   // Process functions and global now
   for (auto &GV : TheModule) {
-    if (!GlobalInvolvedWithAlias.count(&GV))
-      ResolveODR(GV, Index, TheModule.getModuleIdentifier());
+    auto NewLinkage = ResolvedODR.find(GV.getGUID());
+    if (NewLinkage == ResolvedODR.end())
+      continue;
+    DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName() << "` from "
+                 << GV.getLinkage() << " to " << NewLinkage->second << "\n");
+    GV.setLinkage(NewLinkage->second);
   }
   for (auto &GV : TheModule.globals()) {
-    if (!GlobalInvolvedWithAlias.count(&GV))
-      ResolveODR(GV, Index, TheModule.getModuleIdentifier());
+    auto NewLinkage = ResolvedODR.find(GV.getGUID());
+    if (NewLinkage == ResolvedODR.end())
+      continue;
+    DEBUG(dbgs() << "ODR fixing up linkage for `" << GV.getName() << "` from "
+                 << GV.getLinkage() << " to " << NewLinkage->second << "\n");
+    GV.setLinkage(NewLinkage->second);
   }
 }
 
 static StringMap<MemoryBufferRef>
 generateModuleMap(const std::vector<MemoryBufferRef> &Modules) {
   StringMap<MemoryBufferRef> ModuleMap;
   for (auto &ModuleBuffer : Modules) {
     assert(ModuleMap.find(ModuleBuffer.getBufferIdentifier()) ==
if (TM.addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
       report_fatal_error("Failed to setup codegen");
 
     // Run codegen now. resulting binary is in OutputBuffer.
     PM.run(TheModule);
   }
   return make_unique<ObjectMemoryBuffer>(std::move(OutputBuffer));
 }
 
-static std::unique_ptr<MemoryBuffer>
-ProcessThinLTOModule(Module &TheModule, const ModuleSummaryIndex &Index,
-                     StringMap<MemoryBufferRef> &ModuleMap, TargetMachine &TM,
-                     const FunctionImporter::ImportMapTy &ImportList,
-                     ThinLTOCodeGenerator::CachingOptions CacheOptions,
-                     bool DisableCodeGen, StringRef SaveTempsDir,
-                     unsigned count) {
+static std::unique_ptr<MemoryBuffer> ProcessThinLTOModule(
+    Module &TheModule, const ModuleSummaryIndex &Index,
+    DenseMap<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,
+    ThinLTOCodeGenerator::CachingOptions CacheOptions, bool DisableCodeGen,
+    StringRef SaveTempsDir, unsigned count) {
 
   // Save temps: after IPO.
   saveTempBitcode(TheModule, SaveTempsDir, count, ".1.IPO.bc");
 
   // "Benchmark"-like optimization: single-source case
   bool SingleModule = (ModuleMap.size() == 1);
 
   if (!SingleModule) {
     promoteModule(TheModule, Index);
 
     // Resolve the LinkOnce/Weak ODR, trying to turn them into
     // "available_externally" when possible.
     // This is a compile-time optimization.
-    ResolveODR(TheModule, Index);
+    fixupODR(TheModule, ResolvedODR);
 
     // Save temps: after promotion.
     saveTempBitcode(TheModule, SaveTempsDir, count, ".2.promoted.bc");
 
     crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
 
     // Save temps: after cross-module import.
     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
std::unique_ptr<ModuleSummaryIndex> ThinLTOCodeGenerator::linkCombinedIndex() {
   return CombinedIndex;
 }
 
 /**
  * Perform promotion and renaming of exported internal functions.
  */
 void ThinLTOCodeGenerator::promote(Module &TheModule,
                                    ModuleSummaryIndex &Index) {
+  auto ModuleIdentifier = TheModule.getModuleIdentifier();
+  // Collect for each module the list of function it defines (GUID -> Summary).
+  StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
+      ModuleToDefinedGVSummaries;
+  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
 
   // Resolve the LinkOnceODR, trying to turn them into "available_externally"
   // where possible.
-  ResolveODR(TheModule, Index);
+  // This is a compile-time optimization.
+  DenseMap<GlobalValue::GUID, GlobalValue::LinkageTypes> ResolvedODR;
+  ResolveODR(Index, ModuleToDefinedGVSummaries[ModuleIdentifier],
+             ModuleIdentifier, ResolvedODR);
+  fixupODR(TheModule, ResolvedODR);
 
   promoteModule(TheModule, Index);
 }
 
 /**
  * Perform cross-module importing for the module identified by ModuleIdentifier.
  */
 void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
                                              ModuleSummaryIndex &Index) {
   auto ModuleMap = generateModuleMap(Modules);
+  auto ModuleCount = Index.modulePaths().size();
+
+  // Collect for each module the list of function it defines (GUID -> Summary).
+  StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
+      ModuleToDefinedGVSummaries(ModuleCount);
+  Index.collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
 
   // Generate import/export list
-  auto ModuleCount = Index.modulePaths().size();
   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(Index, ImportLists, ExportLists);
+  ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
+                           ExportLists);
   auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
 
   crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
 }
 
 /**
  * Perform post-importing ThinLTO optimizations.
  */
void ThinLTOCodeGenerator::run() {
   // Prepare the resulting object vector
   assert(ProducedBinaries.empty() && "The generator should not be reused");
   ProducedBinaries.resize(Modules.size());
 
   // Prepare the module map.
   auto ModuleMap = generateModuleMap(Modules);
   auto ModuleCount = Modules.size();
 
+  // Collect for each module the list of function it defines (GUID -> Summary).
+  StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
+      ModuleToDefinedGVSummaries(ModuleCount);
+  Index->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
+
   // Collect the import/export lists for all modules from the call-graph in the
   // combined index.
   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
-  ComputeCrossModuleImport(*Index, ImportLists, ExportLists);
+  ComputeCrossModuleImport(*Index, ModuleToDefinedGVSummaries, ImportLists,
+                           ExportLists);
 
   // Parallel optimizer + codegen
   {
     ThreadPool Pool(ThreadCount);
     int count = 0;
     for (auto &ModuleBuffer : Modules) {
       Pool.async([&](int count) {
         LLVMContext Context;
         Context.setDiscardValueNames(LTODiscardValueNames);
+        auto ModuleIdentifier = ModuleBuffer.getBufferIdentifier();
+
+        DenseMap<GlobalValue::GUID, GlobalValue::LinkageTypes> ResolvedODR;
+        ResolveODR(*Index, ModuleToDefinedGVSummaries[ModuleIdentifier],
+                   ModuleIdentifier, ResolvedODR);
 
         // Parse module now
         auto TheModule = loadModuleFromBuffer(ModuleBuffer, Context, false);
 
         // Save temps: original file.
         if (!SaveTempsDir.empty()) {
           saveTempBitcode(*TheModule, SaveTempsDir, count, ".0.original.bc");
         }
 
-        auto &ImportList = ImportLists[TheModule->getModuleIdentifier()];
+        auto &ImportList = ImportLists[ModuleIdentifier];
         ProducedBinaries[count] = ProcessThinLTOModule(
             *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
-            CacheOptions, DisableCodeGen, SaveTempsDir, count);
+            ResolvedODR, CacheOptions, DisableCodeGen, SaveTempsDir, count);
       }, count);
       count++;
     }
   }
 
   // If statistics were requested, print them out now.
   if (llvm::AreStatisticsEnabled())
     llvm::PrintStatistics();
 }

lib/Transforms/IPO/FunctionImport.cpp

 using EdgeInfo = std::pair<const FunctionSummary *, unsigned /* Threshold */>;
 
 /// Compute the list of functions to import for a given caller. Mark these
 /// imported functions and the symbols they reference in their source module as
 /// exported from their source module.
 static void computeImportForFunction(
     const FunctionSummary &Summary, const ModuleSummaryIndex &Index,
     unsigned Threshold,
-    const std::map<GlobalValue::GUID, GlobalValueSummary *> &DefinedFunctions,
+    const std::map<GlobalValue::GUID, GlobalValueSummary *> &DefinedGVSummaries,
     SmallVectorImpl<EdgeInfo> &Worklist,
     FunctionImporter::ImportMapTy &ImportsForModule,
     StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
   for (auto &Edge : Summary.calls()) {
     auto GUID = Edge.first.getGUID();
     DEBUG(dbgs() << " edge -> " << GUID << " Threshold:" << Threshold << "\n");
 
-    if (DefinedFunctions.count(GUID)) {
+    if (DefinedGVSummaries.count(GUID)) {
       DEBUG(dbgs() << "ignored! Target already in destination module.\n");
       continue;
     }
 
     auto *CalleeSummary = selectCallee(GUID, Threshold, Index);
     if (!CalleeSummary) {
       DEBUG(dbgs() << "ignored! No qualifying callee with summary found.\n");
       continue;
for (auto &Edge : Summary.calls()) {
     Worklist.push_back(std::make_pair(ResolvedCalleeSummary, Threshold));
   }
 }
 
 /// Given the list of globals defined in a module, compute the list of imports
 /// as well as the list of "exports", i.e. the list of symbols referenced from
 /// another module (that may require promotion).
 static void ComputeImportForModule(
-    const std::map<GlobalValue::GUID, GlobalValueSummary *> &DefinedFunctions,
+    const std::map<GlobalValue::GUID, GlobalValueSummary *> &DefinedGVSummaries,
     const ModuleSummaryIndex &Index,
     FunctionImporter::ImportMapTy &ImportsForModule,
     StringMap<FunctionImporter::ExportSetTy> *ExportLists = nullptr) {
   // Worklist contains the list of function imported in this module, for which
   // we will analyse the callees and may import further down the callgraph.
   SmallVector<EdgeInfo, 128> Worklist;
 
   // Populate the worklist with the import for the functions in the current
   // module
-  for (auto &FuncInfo : DefinedFunctions) {
-    auto *Summary = FuncInfo.second;
+  for (auto &GVInfo : DefinedGVSummaries) {
+    auto *Summary = GVInfo.second;
     if (auto *AS = dyn_cast<AliasSummary>(Summary))
       Summary = &AS->getAliasee();
-    auto *FuncSummary = cast<FunctionSummary>(Summary);
-    DEBUG(dbgs() << "Initalize import for " << FuncInfo.first << "\n");
+    auto *FuncSummary = dyn_cast<FunctionSummary>(Summary);
+    if (!FuncSummary)
+      // Skip import for global variables
+      continue;
+    DEBUG(dbgs() << "Initalize import for " << GVInfo.first << "\n");
     computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
-                             DefinedFunctions, Worklist, ImportsForModule,
+                             DefinedGVSummaries, Worklist, ImportsForModule,
                              ExportLists);
   }
 
   while (!Worklist.empty()) {
     auto FuncInfo = Worklist.pop_back_val();
     auto *Summary = FuncInfo.first;
     auto Threshold = FuncInfo.second;
 
     // Process the newly imported functions and add callees to the worklist.
     // Adjust the threshold
     Threshold = Threshold * ImportInstrFactor;
 
-    computeImportForFunction(*Summary, Index, Threshold, DefinedFunctions,
+    computeImportForFunction(*Summary, Index, Threshold, DefinedGVSummaries,
                              Worklist, ImportsForModule, ExportLists);
   }
 }
 
 } // anonymous namespace
 
 /// Compute all the import and export for every module using the Index.
 void llvm::ComputeCrossModuleImport(
     const ModuleSummaryIndex &Index,
+    const StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>> &
+        ModuleToDefinedGVSummaries,
     StringMap<FunctionImporter::ImportMapTy> &ImportLists,
     StringMap<FunctionImporter::ExportSetTy> &ExportLists) {
-  auto ModuleCount = Index.modulePaths().size();
-
-  // Collect for each module the list of function it defines.
-  // GUID -> Summary
-  StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
-      Module2FunctionInfoMap(ModuleCount);
-
-  for (auto &GlobalList : Index) {
-    auto GUID = GlobalList.first;
-    for (auto &GlobInfo : GlobalList.second) {
-      auto *Summary = GlobInfo->summary();
-      if (isa<GlobalVarSummary>(Summary))
-        /// Ignore global variable, focus on functions
-        continue;
-      if (auto *AS = dyn_cast<AliasSummary>(Summary))
-        if (isa<GlobalVarSummary>(&AS->getAliasee()))
-          /// Ignore alias to global variable, focus on functions
-          continue;
-      DEBUG(dbgs() << "Adding definition: Module '" << Summary->modulePath()
-                   << "' defines '" << GUID << "'\n");
-      Module2FunctionInfoMap[Summary->modulePath()][GUID] = Summary;
-    }
-  }
-
   // For each module that has function defined, compute the import/export lists.
-  for (auto &DefinedFunctions : Module2FunctionInfoMap) {
-    auto &ImportsForModule = ImportLists[DefinedFunctions.first()];
-    DEBUG(dbgs() << "Computing import for Module '" << DefinedFunctions.first()
-                 << "'\n");
-    ComputeImportForModule(DefinedFunctions.second, Index, ImportsForModule,
+  for (auto &DefinedGVSummaries : ModuleToDefinedGVSummaries) {
+    auto &ImportsForModule = ImportLists[DefinedGVSummaries.first()];
+    DEBUG(dbgs() << "Computing import for Module '"
+                 << DefinedGVSummaries.first() << "'\n");
+    ComputeImportForModule(DefinedGVSummaries.second, Index, ImportsForModule,
                            &ExportLists);
   }
 
 #ifndef NDEBUG
   DEBUG(dbgs() << "Import/Export lists for " << ImportLists.size()
                << " modules:\n");
   for (auto &ModuleImports : ImportLists) {
     auto ModName = ModuleImports.first();