[ELF] Support --defsym=<symbol>=<symbol>.

[ruiu]

Summary

Currently LLD supports --defsym only in the form of
--defsym=<symbol>=<integer>, where the integer is interpreted as the
absolute address of the symbol. This patch extends it to allow other
symbol name to be given as an RHS value. If a RHS value is a symbol
name, a LHS symbol will be defined as an alias for the RHS symbol.

Internally, a LHS symbol is represented as a zero-size defined atom
who has an LayoutAfter reference to an undefined atom, whose name is
the RHS value. Everything else is already implemented -- Resolver
will resolve the undefined symbol, and the layout pass will layout
the two atoms at the same location. Looks like it's working fine.

Note that GNU LD supports --defsym=<symbol>=<symbol>+<addend>. That
feature is out of scope of this patch.

[shankarke]

LGTM.

[atanasyan]

include/lld/ReaderWriter/ELFLinkingContext.h

235 ↗

(On Diff #8447)

I think it is a typo here. The map should be returned be reference not value.

[ruiu]

Closed by commit rL206417 (authored by @ruiu).

lld/trunk/include/lld/ReaderWriter/ELFLinkingContext.h

public:
   /// add to the list of finalizer functions
   void addFiniFunction(StringRef name) { _finiFunctions.push_back(name); }
 
   /// Add an absolute symbol. Used for --defsym.
   void addInitialAbsoluteSymbol(StringRef name, uint64_t addr) {
     _absoluteSymbols[name] = addr;
   }
 
+  void addAlias(StringRef sym, StringRef target) {
+    _aliasSymbols[sym] = target;
+  }
+
   /// Return the list of initializer symbols that are specified in the
   /// linker command line, using the -init option.
   range<const StringRef *> initFunctions() const {
     return _initFunctions;
   }
 
   /// Return the list of finalizer symbols that are specified in the
   /// linker command line, using the -fini option.
public:
   range<const StringRef *> getRpathLinkList() const {
     return _rpathLinkList;
   }
 
   const std::map<std::string, uint64_t> &getAbsoluteSymbols() const {
     return _absoluteSymbols;
   }
 
+  const std::map<std::string, std::string> getAliases() const {
+    return _aliasSymbols;
+  }
+
   /// \brief Helper function to allocate strings.
   StringRef allocateString(StringRef ref) const {
     char *x = _allocator.Allocate<char>(ref.size() + 1);
     memcpy(x, ref.data(), ref.size());
     x[ref.size()] = '\0';
     return x;
   }
 
protected:
   StringRef _dynamicLinkerPath;
   StringRefVector _initFunctions;
   StringRefVector _finiFunctions;
   StringRef _sysrootPath;
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   std::map<std::string, uint64_t> _absoluteSymbols;
+  std::map<std::string, std::string> _aliasSymbols;
 };
 } // end namespace lld
 
 #endif

lld/trunk/lib/Driver/GnuLdDriver.cpp

static error_code getFileMagic(ELFLinkingContext &ctx, StringRef path,
   case llvm::sys::fs::file_magic::unknown:
     return error_code::success();
   default:
     break;
   }
   return make_error_code(ReaderError::unknown_file_format);
 }
 
-// Parses an argument of --defsym. A given string must be in the form
-// of <symbol>=<number>. Note that we don't support symbol-relative
-// aliases yet.
-static bool parseDefsymOption(StringRef opt, StringRef &sym, uint64_t &addr) {
+// Parses an argument of --defsym=<sym>=<number>
+static bool parseDefsymAsAbsolute(StringRef opt, StringRef &sym,
+                                  uint64_t &addr) {
   size_t equalPos = opt.find('=');
   if (equalPos == 0 || equalPos == StringRef::npos)
     return false;
   sym = opt.substr(0, equalPos);
   if (opt.substr(equalPos + 1).getAsInteger(0, addr))
     return false;
   return true;
 }
 
+// Parses an argument of --defsym=<sym>=<sym>
+static bool parseDefsymAsAlias(StringRef opt, StringRef &sym,
+                               StringRef &target) {
+  size_t equalPos = opt.find('=');
+  if (equalPos == 0 || equalPos == StringRef::npos)
+    return false;
+  sym = opt.substr(0, equalPos);
+  target = opt.substr(equalPos + 1);
+  return !target.empty();
+}
+
 llvm::ErrorOr<StringRef> ELFFileNode::getPath(const LinkingContext &) const {
   if (!_attributes._isDashlPrefix)
     return _path;
   return _elfLinkingContext.searchLibrary(_path);
 }
 
 std::string ELFFileNode::errStr(error_code errc) {
   if (errc == llvm::errc::no_such_file_or_directory) {
case OPT_as_needed:
       attributes.setAsNeeded(true);
       break;
 
     case OPT_no_as_needed:
       attributes.setAsNeeded(false);
       break;
 
     case OPT_defsym: {
-      StringRef sym;
+      StringRef sym, target;
       uint64_t addr;
-      if (!parseDefsymOption(inputArg->getValue(), sym, addr)) {
+      if (parseDefsymAsAbsolute(inputArg->getValue(), sym, addr)) {
+        ctx->addInitialAbsoluteSymbol(sym, addr);
+      } else if (parseDefsymAsAlias(inputArg->getValue(), sym, target)) {
+        ctx->addAlias(sym, target);
+      } else {
         diagnostics << "invalid --defsym: " << inputArg->getValue() << "\n";
         return false;
       }
-      ctx->addInitialAbsoluteSymbol(sym, addr);
       break;
     }
 
     case OPT_start_group: {
       std::unique_ptr<Group> group(new Group());
       groupStack.push(group.get());
       inputGraph->addInputElement(std::move(group));
       break;

lld/trunk/lib/ReaderWriter/ELF/ELFLinkingContext.cpp

public:
   Scope scope() const override { return scopeGlobal; }
 
 private:
   const File &_file;
   StringRef _name;
   uint64_t _value;
 };
 
+// An AliasAtom is a zero-size atom representing an alias for other atom. It has
+// a LayoutAfter reference to the target atom, so that this atom and the target
+// atom will be layed out at the same location in the final result. Initially
+// the target atom is an undefined atom. Resolver will replace it with a defined
+// one.
+//
+// It does not have attributes itself. Most member function calls are forwarded
+// to the target atom.
+class AliasAtom : public SimpleDefinedAtom {
+public:
+  AliasAtom(const File &file, StringRef name)
+      : SimpleDefinedAtom(file), _target(nullptr), _name(name) {}
+
+  StringRef name() const override { return _name; }
+  uint64_t size() const override { return 0; }
+  ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
+
+  Scope scope() const override {
+    getTarget();
+    return _target ? _target->scope() : scopeLinkageUnit;
+  }
+
+  Merge merge() const override {
+    getTarget();
+    return _target ? _target->merge() : mergeNo;
+  }
+
+  ContentType contentType() const override {
+    getTarget();
+    return _target ? _target->contentType() : typeUnknown;
+  }
+
+  Interposable interposable() const override {
+    getTarget();
+    return _target ? _target->interposable() : interposeNo;
+  }
+
+  SectionChoice sectionChoice() const override {
+    getTarget();
+    return _target ? _target->sectionChoice() : sectionBasedOnContent;
+  }
+
+  StringRef customSectionName() const override {
+    getTarget();
+    return _target ? _target->customSectionName() : StringRef("");
+  }
+
+private:
+  void getTarget() const {
+    if (_target)
+      return;
+    for (const Reference *r : *this) {
+      if (r->kindNamespace() == lld::Reference::KindNamespace::all &&
+          r->kindValue() == lld::Reference::kindLayoutAfter) {
+        _target = dyn_cast<DefinedAtom>(r->target());
+        return;
+      }
+    }
+  }
+
+  mutable const DefinedAtom *_target;
+  StringRef _name;
+};
+
 class CommandLineUndefinedAtom : public SimpleUndefinedAtom {
 public:
   CommandLineUndefinedAtom(const File &f, StringRef name)
       : SimpleUndefinedAtom(f, name) {}
 
   CanBeNull canBeNull() const override {
     return CanBeNull::canBeNullAtBuildtime;
   }
void ELFLinkingContext::createInternalFiles(
     std::vector<std::unique_ptr<File>> &files) const {
   std::unique_ptr<SimpleFile> file(
       new SimpleFile("<internal file for --defsym>"));
   for (auto &i : getAbsoluteSymbols()) {
     StringRef sym = i.first;
     uint64_t val = i.second;
     file->addAtom(*(new (_allocator) CommandLineAbsoluteAtom(*file, sym, val)));
   }
+  for (auto &i : getAliases()) {
+    StringRef from = i.first;
+    StringRef to = i.second;
+    SimpleDefinedAtom *fromAtom = new (_allocator) AliasAtom(*file, from);
+    UndefinedAtom *toAtom = new (_allocator) SimpleUndefinedAtom(*file, to);
+    fromAtom->addReference(Reference::KindNamespace::all,
+                           Reference::KindArch::all, Reference::kindLayoutAfter,
+                           0, toAtom, 0);
+    file->addAtom(*fromAtom);
+    file->addAtom(*toAtom);
+  }
   files.push_back(std::move(file));
   LinkingContext::createInternalFiles(files);
 }
 
 std::unique_ptr<File> ELFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
       new SimpleFile("command line option -u"));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) CommandLineUndefinedAtom(
         *undefinedSymFile, undefSymStr)));
   return std::move(undefinedSymFile);
 }
 
 } // end namespace lld

lld/trunk/test/elf/X86_64/defsym.test

+RUN: lld -flavor gnu -target x86_64 --defsym=_start=fn %p/Inputs/fn.o -o %t
+RUN: llvm-readobj -symbols %t | FileCheck %s
+
+CHECK: Symbol {
+CHECK:   Name: _start (1)
+CHECK:   Value: 0x4001E0
+CHECK:   Size: 0
+CHECK:   Binding: Global (0x1)
+CHECK:   Type: Function (0x2)
+CHECK:   Other: 0
+CHECK:   Section: .text (0x5)
+CHECK: }
+CHECK: Symbol {
+CHECK:   Name: fn (8)
+CHECK:   Value: 0x4001E0
+CHECK:   Size: 6
+CHECK:   Binding: Global (0x1)
+CHECK:   Type: Function (0x2)
+CHECK:   Other: 0
+CHECK:   Section: .text (0x5)
+CHECK: }

lld/trunk/test/elf/defsym.objtxt

 # RUN: lld -flavor gnu -target x86_64 --defsym=foo=0x1234 -r %s \
-# RUN:     --output-filetype=yaml | FileCheck %s
+# RUN:     --output-filetype=yaml | FileCheck -check-prefix=ABS %s
 
-absolute-atoms:
+# RUN: lld -flavor gnu -target x86_64 --defsym=foo=main -r %s \
+# RUN:     --output-filetype=yaml | FileCheck -check-prefix=ALIAS %s
 
-# CHECK: absolute-atoms:
-# CHECK:   - name:            foo
-# CHECK:     scope:           global
-# CHECK:     value:           0x0000000000001234
+defined-atoms:
+  - 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
+
+# ABS: absolute-atoms:
+# ABS:   - name:            foo
+# ABS:     scope:           global
+# ABS:     value:           0x0000000000001234
+
+# ALIAS: defined-atoms:
+# ALIAS:   - name:            foo
+# ALIAS:     scope:           global
+# ALIAS:     section-choice:  custom-required
+# ALIAS:     section-name:    .text
+# ALIAS:     references:
+# ALIAS:       - kind:            layout-after
+# ALIAS:         offset:          0
+# ALIAS:         target:          main

lld/trunk/unittests/DriverTests/GnuLdDriverTest.cpp

 TEST_F(GnuLdParserTest, DefsymHexadecimal) {
   EXPECT_TRUE(parse("ld", "--start-group", "--end-group", "--defsym=sym=0x1000",
                     nullptr));
   auto map = _context->getAbsoluteSymbols();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ((uint64_t)0x1000, map["sym"]);
 }
 
+TEST_F(GnuLdParserTest, DefsymAlias) {
+  EXPECT_TRUE(
+      parse("ld", "--start-group", "--end-group", "--defsym=sym=abc", nullptr));
+  auto map = _context->getAliases();
+  EXPECT_EQ((size_t)1, map.size());
+  EXPECT_EQ("abc", map["sym"]);
+}
+
 TEST_F(GnuLdParserTest, DefsymOctal) {
   EXPECT_TRUE(parse("ld", "--start-group", "--end-group", "--defsym=sym=0777",
                     nullptr));
   auto map = _context->getAbsoluteSymbols();
   EXPECT_EQ((size_t)1, map.size());
   EXPECT_EQ((uint64_t)0777, map["sym"]);
 }
 
-TEST_F(GnuLdParserTest, DefsymFail) {
-  EXPECT_FALSE(
-      parse("ld", "--start-group", "--end-group", "--defsym=sym=abc", nullptr));
-}
-
 TEST_F(GnuLdParserTest, DefsymMisssingSymbol) {
   EXPECT_FALSE(
       parse("ld", "--start-group", "--end-group", "--defsym==0", nullptr));
 }
 
 TEST_F(GnuLdParserTest, DefsymMisssingValue) {
   EXPECT_FALSE(
       parse("ld", "--start-group", "--end-group", "--defsym=sym=", nullptr));
 }