[ELF] Add --allow-multiple-definition option.

[ruiu]

Summary

If --allow-multiple-definition option is given, LLD does not treat duplicate
symbol error as a fatal error. GNU LD supports this option.

[Bigcheese]

lgtm

[shankarke]

You would need to correct error to a warning if allow multiple definition option is used.

[shankarke]

actually infact, there is no warning even shown with gnu, you might want the errors that is displayed to the user when there is a multiple definition.

Testcase with Gnu :-

cat > 1.c << \!
int foo = 10;
!
+ cat

cat > 2.c << \!
int foo = 10;
!
+ cat

gcc -c 1.c 2.c
+ gcc -c 1.c 2.c
ld 1.o 2.o --allow-multiple-definition
+ ld 1.o 2.o --allow-multiple-definition
ld: warning: cannot find entry symbol _start; defaulting to 00000000004000b0

[ruiu]

Thanks. Modified not to print out warning messages if the option is given.

[ruiu]

Closed by commit rL205015 (authored by @ruiu).

include/lld/Core/LinkingContext.h

public:
   // Set the entry symbol name. You may also need to call addDeadStripRoot() for
   // the symbol if your platform supports dead-stripping, so that the symbol
   // will not be removed from the output.
   void setEntrySymbolName(StringRef name) {
     _entrySymbolName = name;
   }
 
   void setDeadStripping(bool enable) { _deadStrip = enable; }
+  void setAllowDuplicates(bool enable) { _allowDuplicates = enable; }
   void setGlobalsAreDeadStripRoots(bool v) { _globalsAreDeadStripRoots = v; }
   void setSearchArchivesToOverrideTentativeDefinitions(bool search) {
     _searchArchivesToOverrideTentativeDefinitions = search;
   }
   void setSearchSharedLibrariesToOverrideTentativeDefinitions(bool search) {
     _searchSharedLibrariesToOverrideTentativeDefinitions = search;
   }
   void setWarnIfCoalesableAtomsHaveDifferentCanBeNull(bool warn) {
     _warnIfCoalesableAtomsHaveDifferentCanBeNull = warn;
   }
   void setWarnIfCoalesableAtomsHaveDifferentLoadName(bool warn) {
     _warnIfCoalesableAtomsHaveDifferentLoadName = warn;
   }
   void setPrintRemainingUndefines(bool print) {
     _printRemainingUndefines = print;
   }
   void setAllowRemainingUndefines(bool allow) {
     _allowRemainingUndefines = allow;
   }
   void setAllowShlibUndefines(bool allow) { _allowShlibUndefines = allow; }
   void setLogInputFiles(bool log) { _logInputFiles = log; }
 
+  // Returns true if multiple definitions should not be treated as a
+  // fatal error.
+  bool getAllowDuplicates() const { return _allowDuplicates; }
+
   void appendLLVMOption(const char *opt) { _llvmOptions.push_back(opt); }
   virtual void setInputGraph(std::unique_ptr<InputGraph> inputGraph) {
     _inputGraph = std::move(inputGraph);
   }
   virtual InputGraph &inputGraph() const { return *_inputGraph; }
 
   /// This method adds undefined symbols specified by the -u option to the to
   /// the list of undefined symbols known to the linker. This option essentially
protected:
 
   /// Method to create a internal file for an undefined symbol
   virtual std::unique_ptr<File> createUndefinedSymbolFile() const;
   std::unique_ptr<File> createUndefinedSymbolFile(StringRef filename) const;
 
   StringRef _outputPath;
   StringRef _entrySymbolName;
   bool _deadStrip;
+  bool _allowDuplicates;
   bool _globalsAreDeadStripRoots;
   bool _searchArchivesToOverrideTentativeDefinitions;
   bool _searchSharedLibrariesToOverrideTentativeDefinitions;
   bool _warnIfCoalesableAtomsHaveDifferentCanBeNull;
   bool _warnIfCoalesableAtomsHaveDifferentLoadName;
   bool _printRemainingUndefines;
   bool _allowRemainingUndefines;
   bool _logInputFiles;

lib/Core/LinkingContext.cpp

 #include "lld/ReaderWriter/Writer.h"
 #include "lld/ReaderWriter/Simple.h"
 
 #include "llvm/ADT/Triple.h"
 
 namespace lld {
 
 LinkingContext::LinkingContext()
-    : _deadStrip(false), _globalsAreDeadStripRoots(false),
+    : _deadStrip(false), _allowDuplicates(false),
+      _globalsAreDeadStripRoots(false),
       _searchArchivesToOverrideTentativeDefinitions(false),
       _searchSharedLibrariesToOverrideTentativeDefinitions(false),
       _warnIfCoalesableAtomsHaveDifferentCanBeNull(false),
       _warnIfCoalesableAtomsHaveDifferentLoadName(false),
       _printRemainingUndefines(true), _allowRemainingUndefines(false),
       _logInputFiles(false), _allowShlibUndefines(false),
       _outputFileType(OutputFileType::Default), _currentInputElement(nullptr),
       _nextOrdinal(0) {}

lib/Core/SymbolTable.cpp

case MCR_Error:
                    << existing->name()
                    << ":"
                    << existing->file().path()
                    << " and "
                    << newAtom.name()
                    << ":"
                    << newAtom.file().path()
                    << "\n";
+      if (!_context.getAllowDuplicates())
         llvm::report_fatal_error("duplicate symbol error");
+      useNew = false;
       break;
     }
     break;
   case NCR_DupUndef: {
     const UndefinedAtom* existingUndef = dyn_cast<UndefinedAtom>(existing);
     const UndefinedAtom* newUndef = dyn_cast<UndefinedAtom>(&newAtom);
     assert(existingUndef != nullptr);
     assert(newUndef != nullptr);

lib/Driver/GnuLdDriver.cpp

for (auto inputArg : *parsedArgs) {
     case OPT_allow_shlib_undefs:
       ctx->setAllowShlibUndefines(true);
       break;
 
     case OPT_use_shlib_undefs:
       ctx->setUseShlibUndefines(true);
       break;
 
+    case OPT_allow_multiple_definition:
+      ctx->setAllowDuplicates(true);
+      break;
+
     case OPT_dynamic_linker:
       ctx->setInterpreter(inputArg->getValue());
       break;
 
     case OPT_u:
       ctx->addInitialUndefinedSymbol(inputArg->getValue());
       break;
 

lib/Driver/GnuLdOptions.td

def no_allow_shlib_undefs : Flag<["--"], "no-allow-shlib-undefined">,
      Group<grp_resolveropt>;
 def allow_shlib_undefs : Flag<["--"], "allow-shlib-undefined">,
      HelpText<"Allow undefined symbols from dynamic"
              " library when creating executables">,
      Group<grp_resolveropt>;
 def use_shlib_undefs: Flag<["--"], "use-shlib-undefines">,
     HelpText<"Resolve undefined symbols from dynamic libraries">,
     Group<grp_resolveropt>;
+def allow_multiple_definition: Flag<["--"], "allow-multiple-definition">,
+    HelpText<"Allow multiple definitions">,
+    Group<grp_resolveropt>;
 
 //===----------------------------------------------------------------------===//
 /// Custom Options
 //===----------------------------------------------------------------------===//
 def grp_customopts : OptionGroup<"opts">,
      HelpText<"CUSTOM OPTIONS">;
 def z : Separate<["-"], "z">,
      HelpText<"Linker Option extensions">,

test/elf/allowduplicates.objtxt

+# RUN: lld -flavor gnu -target x86_64 --allow-multiple-definition -r %s \
+# RUN:     --output-filetype=yaml | FileCheck %s
+#
+# RUN: not lld -flavor gnu -target x86_64 -r %s --output-filetype=yaml 2>&1 \
+# RUN:   | FileCheck -check-prefix=ERROR %s
+
+---
+defined-atoms:
+  - name:            .text
+    alignment:       2^4
+    section-choice:  custom-required
+    section-name:    .text
+  - name:            main
+    scope:           global
+    content:         [ B8, 00, 00, 00, 00, C7, 44, 24, FC, 00, 00, 00,
+                       00, C3 ]
+    alignment:       2^4
+    section-choice:  custom-required
+    section-name:    .text
+---
+defined-atoms:
+  - name:            .text
+    alignment:       2^4
+    section-choice:  custom-required
+    section-name:    .text
+  - name:            main
+    scope:           global
+    content:         [ B8, 00, 00, 00, 00, C7, 44, 24, FC, 00, 00, 00,
+                       00, C3 ]
+    alignment:       2^4
+    section-choice:  custom-required
+    section-name:    .text
+---
+
+# CHECK: defined-atoms:
+# CHECK:   - name:            .text
+# CHECK:     alignment:       2^4
+# CHECK:     section-choice:  custom-required
+# CHECK:     section-name:    .text
+# CHECK:   - name:            main
+# CHECK:     scope:           global
+# CHECK:     content:         [ B8, 00, 00, 00, 00, C7, 44, 24, FC, 00, 00, 00,
+# CHECK:                        00, C3 ]
+# CHECK:     alignment:       2^4
+# CHECK:     section-choice:  custom-required
+# CHECK:     section-name:    .text
+
+# ERROR: duplicate symbol error