llvm-link: Add -override flag to prefer duplicate symbols from one module.

[luqmana]

Summary

This adds an -override flag to llvm-link which lets you specify further .bc's which should take precedent in case you hit duplicate symbols.

The intended use case is for example you have a large module from which you extract a single function. You then modify this functions (perhaps by hand or running it through opt) and then want to merge it back into the original module. If you simply tried to pass both to llvm-link now you'd get an error about duplicate symbols.

[luqmana]

Not sure who owns llvm-link but you seem to have touched it last.

[luqmana]

Ping?

[atrick]

I think this is the simplest way to accomplish what we need. LGTM.

I'm open to any bike shedding of the --override option name.

include/llvm/Linker/Linker.h

public:
   Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler);
   Linker(Module *M);
   ~Linker();
 
   Module *getModule() const { return Composite; }
   void deleteModule();
 
   /// \brief Link \p Src into the composite. The source is destroyed.
+  /// Passing OverrideSymbols as true will have symbols from Src
+  /// shadow those in the Dest.
   /// Returns true on error.
-  bool linkInModule(Module *Src);
+  bool linkInModule(Module *Src, bool OverrideSymbols = false);
 
   /// \brief Set the composite to the passed-in module.
   void setModule(Module *Dst);
 
   static bool LinkModules(Module *Dest, Module *Src,
                           DiagnosticHandlerFunction DiagnosticHandler);
 
   static bool LinkModules(Module *Dest, Module *Src);

lib/Linker/LinkModules.cpp

class ModuleLinker {
   // Vector of GlobalValues to lazily link in.
   std::vector<GlobalValue *> LazilyLinkGlobalValues;
 
   /// Functions that have replaced other functions.
   SmallPtrSet<const Function *, 16> OverridingFunctions;
 
   DiagnosticHandlerFunction DiagnosticHandler;
 
+  /// For symbol clashes, prefer those from Src.
+  bool OverrideFromSrc;
+
 public:
   ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM,
-               DiagnosticHandlerFunction DiagnosticHandler)
+               DiagnosticHandlerFunction DiagnosticHandler,
+               bool Override = false)
       : DstM(dstM), SrcM(srcM), TypeMap(Set),
         ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues),
-        DiagnosticHandler(DiagnosticHandler) {}
+        DiagnosticHandler(DiagnosticHandler),
+        OverrideFromSrc(Override) {}
 
   bool run();
 
 private:
   bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest,
                             const GlobalValue &Src);
 
   /// Helper method for setting a message and returning an error code.
if (Dest.isWeakForLinker()) {
     LinkFromSrc = true;
     return false;
   }
 
   assert(!Src.hasExternalWeakLinkage());
   assert(!Dest.hasExternalWeakLinkage());
   assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
          "Unexpected linkage type!");
+
+  if (OverrideFromSrc) {
+    LinkFromSrc = true;
+    return false;
+  }
+
   return emitError("Linking globals named '" + Src.getName() +
                    "': symbol multiply defined!");
 }
 
 /// Loop over all of the linked values to compute type mappings.  For example,
 /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct
 /// types 'Foo' but one got renamed when the module was loaded into the same
 /// LLVMContext.

 Linker::~Linker() {
 }
 
 void Linker::deleteModule() {
   delete Composite;
   Composite = nullptr;
 }
 
-bool Linker::linkInModule(Module *Src) {
+bool Linker::linkInModule(Module *Src, bool OverrideSymbols) {
   ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src,
-                         DiagnosticHandler);
+                         DiagnosticHandler, OverrideSymbols);
   bool RetCode = TheLinker.run();
   Composite->dropTriviallyDeadConstantArrays();
   return RetCode;
 }
 
 void Linker::setModule(Module *Dst) {
   init(Dst, DiagnosticHandler);
 }

test/tools/llvm-link/Inputs/foo.ll

+define i32 @foo(i32 %i) {
+entry:
+  ret i32 4
+}

test/tools/llvm-link/hello.ll

+; RUN: llvm-link %s -override %p/Inputs/foo.ll -S | FileCheck %s
+
+
+; CHECK-LABEL: define i32 @foo
+; CHECK-NEXT: entry:
+; CHECK-NEXT: ret i32 4
+define i32 @foo(i32 %i) {
+entry:
+  %add = add nsw i32 %i, %i
+  ret i32 %add
+}
+
+; Function Attrs: nounwind ssp uwtable
+define i32 @main(i32 %argc, i8** %argv) {
+entry:
+  %a = call i32 @foo(i32 2)
+  ret i32 %a
+}

test/tools/llvm-link/lit.local.cfg

+config.suffixes = ['.ll']

tools/llvm-link/llvm-link.cpp

 #include "llvm/Support/ToolOutputFile.h"
 #include <memory>
 using namespace llvm;
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::OneOrMore,
                cl::desc("<input bitcode files>"));
 
+static cl::list<std::string>
+OverridingInputs("override", cl::ZeroOrMore, cl::value_desc("filename"),
+                 cl::desc("input bitcode file which can "
+                          "override previously defined symbol"));
+
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Override output filename"), cl::init("-"),
                cl::value_desc("filename"));
 
 static cl::opt<bool>
 Force("f", cl::desc("Enable binary output on terminals"));
 
 static cl::opt<bool>
int main(int argc, char **argv) {
 
   LLVMContext &Context = getGlobalContext();
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
 
   auto Composite = make_unique<Module>("llvm-link", Context);
   Linker L(Composite.get(), diagnosticHandler);
 
-  for (unsigned i = 0; i < InputFilenames.size(); ++i) {
-    std::unique_ptr<Module> M = loadFile(argv[0], InputFilenames[i], Context);
+  auto linkFiles = [&](const cl::list<std::string>& Files, bool Override) {
+    for (auto File : Files) {
+      std::unique_ptr<Module> M = loadFile(argv[0], File, Context);
       if (!M.get()) {
-      errs() << argv[0] << ": error loading file '" <<InputFilenames[i]<< "'\n";
-      return 1;
+        errs() << argv[0] << ": error loading file '" << File << "'\n";
+        exit(1);
       }
 
       if (verifyModule(*M, &errs())) {
-      errs() << argv[0] << ": " << InputFilenames[i]
+        errs() << argv[0] << ": " << File
                << ": error: input module is broken!\n";
-      return 1;
+        exit(1);
       }
 
-    if (Verbose) errs() << "Linking in '" << InputFilenames[i] << "'\n";
+      if (Verbose) errs() << "Linking in '" << File << "'\n";
 
-    if (L.linkInModule(M.get()))
-      return 1;
+      if (L.linkInModule(M.get(), Override))
+        exit(1);
     }
+  };
+
+  linkFiles(InputFilenames, false);
+  linkFiles(OverridingInputs, true);
 
   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';
     return 1;