[ThinLTO] Rework llvm-link to use the FunctionImporter

[tejohnson]

Summary

Change llvm-link to use the FunctionImporter handling, instead of
manually invoking the Linker. We still need to load the module
in llvm-link to do the desired testing for invalid import requests
(weak functions), and to get the GUID (in case the function is local).

Also change the drop-debug-info test to use llvm-link so that importing
is forced (in order to test debug info handling) and independent of
import logic changes.

[mehdi_amini]

Great! Thanks :)

tools/llvm-link/llvm-link.cpp

259 ↗

(On Diff #83002)

Add a comment in front of the 1.0, like:
std::make_pair(F->getGUID(), /* (Unused) threshold */ 1.0)

llvm/trunk/test/ThinLTO/X86/drop-debug-info.ll

 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t.bc %p/Inputs/drop-debug-info.bc
 
 ; The imported module has out-of-date debug information, let's make sure we can
 ; drop them without crashing when materializing later.
-; RUN: llvm-lto -thinlto-action=import %t.bc -thinlto-index=%t.index.bc -o - | llvm-dis -o - | FileCheck %s
+; RUN: llvm-link %t.bc -summary-index=%t.index.bc -import=globalfunc:%p/Inputs/drop-debug-info.bc | llvm-dis -o - | FileCheck %s
 ; CHECK: define available_externally void @globalfunc
 ; CHECK-NOT: llvm.dbg.value
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 
 define i32 @main() #0 {
 entry:
   call void (...) @globalfunc()
   ret i32 0
 }
 
-declare void @globalfunc(...)
+declare void @globalfunc(...)
 

llvm/trunk/tools/llvm-link/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BitWriter
   Core
   IRReader
   Linker
   Object
   Support
   TransformUtils
+  IPO
   )
 
 add_llvm_tool(llvm-link
   llvm-link.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/trunk/tools/llvm-link/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Tool
 name = llvm-link
 parent = Tools
-required_libraries = AsmParser BitReader BitWriter IRReader Linker Object TransformUtils
+required_libraries = AsmParser BitReader BitWriter IRReader Linker Object TransformUtils IPO

llvm/trunk/tools/llvm-link/llvm-link.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 
 #include <memory>
 #include <utility>
 using namespace llvm;
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
static void diagnosticHandler(const DiagnosticInfo &DI, void *C) {
   }
 
   DiagnosticPrinterRawOStream DP(errs());
   DI.print(DP);
   errs() << '\n';
 }
 
 /// Import any functions requested via the -import option.
-static bool importFunctions(const char *argv0, LLVMContext &Context,
-                            Linker &L) {
+static bool importFunctions(const char *argv0, Module &DestModule) {
   if (SummaryIndex.empty())
     return true;
   std::unique_ptr<ModuleSummaryIndex> Index =
       ExitOnErr(llvm::getModuleSummaryIndexForFile(SummaryIndex));
 
   // Map of Module -> List of globals to import from the Module
-  std::map<StringRef, DenseSet<const GlobalValue *>> ModuleToGlobalsToImportMap;
-  auto ModuleLoader = [&Context](const char *argv0,
+  FunctionImporter::ImportMapTy ImportList;
+
+  auto ModuleLoader = [&DestModule](const char *argv0,
                                     const std::string &Identifier) {
-    return loadFile(argv0, Identifier, Context, false);
+    return loadFile(argv0, Identifier, DestModule.getContext(), false);
   };
+
   ModuleLazyLoaderCache ModuleLoaderCache(ModuleLoader);
   for (const auto &Import : Imports) {
     // Identify the requested function and its bitcode source file.
     size_t Idx = Import.find(':');
     if (Idx == std::string::npos) {
       errs() << "Import parameter bad format: " << Import << "\n";
       return false;
     }
if (F->hasWeakAnyLinkage()) {
       errs() << "Ignoring import request for weak-any function " << FunctionName
              << " from " << FileName << "\n";
       continue;
     }
 
     if (Verbose)
       errs() << "Importing " << FunctionName << " from " << FileName << "\n";
 
-    auto &Entry = ModuleToGlobalsToImportMap[SrcModule.getModuleIdentifier()];
-    Entry.insert(F);
-
-    ExitOnErr(F->materialize());
-  }
-
-  // Do the actual import of globals now, one Module at a time
-  for (auto &GlobalsToImportPerModule : ModuleToGlobalsToImportMap) {
-    // Get the module for the import
-    auto &GlobalsToImport = GlobalsToImportPerModule.second;
-    std::unique_ptr<Module> SrcModule =
-        ModuleLoaderCache.takeModule(GlobalsToImportPerModule.first);
-    assert(&Context == &SrcModule->getContext() && "Context mismatch");
-
-    // If modules were created with lazy metadata loading, materialize it
-    // now, before linking it (otherwise this will be a noop).
-    ExitOnErr(SrcModule->materializeMetadata());
-    UpgradeDebugInfo(*SrcModule);
-
-    // Linkage Promotion and renaming
-    if (renameModuleForThinLTO(*SrcModule, *Index, &GlobalsToImport))
-      return true;
-
-    // Instruct the linker to not automatically import linkonce defintion.
-    unsigned Flags = Linker::Flags::DontForceLinkLinkonceODR;
-
-    if (L.linkInModule(std::move(SrcModule), Flags, &GlobalsToImport))
-      return false;
+    auto &Entry = ImportList[FileName];
+    Entry.insert(std::make_pair(F->getGUID(), /* (Unused) threshold */ 1.0));
   }
+  auto CachedModuleLoader = [&](StringRef Identifier) {
+    return ModuleLoaderCache.takeModule(Identifier);
+  };
+  FunctionImporter Importer(*Index, CachedModuleLoader);
+  ExitOnErr(Importer.importFunctions(DestModule, ImportList));
 
   return true;
 }
 
 static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
                       const cl::list<std::string> &Files,
                       unsigned Flags) {
   // Filter out flags that don't apply to the first file we load.
if (!linkFiles(argv[0], Context, L, InputFilenames, Flags))
     return 1;
 
   // Next the -override ones.
   if (!linkFiles(argv[0], Context, L, OverridingInputs,
                  Flags | Linker::Flags::OverrideFromSrc))
     return 1;
 
   // Import any functions requested via -import
-  if (!importFunctions(argv[0], Context, L))
+  if (!importFunctions(argv[0], *Composite))
     return 1;
 
   if (DumpAsm) errs() << "Here's the assembly:\n" << *Composite;
 
   std::error_code EC;
   tool_output_file Out(OutputFilename, EC, sys::fs::F_None);
   if (EC) {
     errs() << EC.message() << '\n';