[ELF] Make -init/-fini options compatible with the gnu linker

[atanasyan]

Summary

The LLD linker searches initializer and finalizer function names and emits DT_INIT/DT_FINI dynamic table tags to point to these symbols. The -init/-fini command line options override initializer ("_init") and finalizer ("_fini") function names used by default.

Now the -init/-fini options do not affect .init_array/.fini_array sections. The corresponding code has been removed.

[ruiu]

LGTM, nice. Please wait for a while to wait for other reviewers.

[• shankar.easwaran]

What's the right behaviour for static linking ?

[atanasyan]

In D6578#6, @shankar.easwaran wrote:

What's the right behaviour for static linking ?

These options do not affect static linking. Please correct me if I make a mistake. Here is a quote from the ld manpage:

-init=name
When creating an ELF executable or shared object, call NAME when the executable or shared object is loaded,
by setting DT_INIT to the address of the function. By default, the linker uses _init as the function to call.

As far as I remember (that was five years ago or so) SunOS linker had -z initarray=<symbol> command line option. This option adds symbol to the .initarray section. We can do something like that if necessary.

[• shankar.easwaran]

$ ld.gold --help|grep ctors

--ctors-in-init-array       Use DT_INIT_ARRAY for all constructors (default)
--no-ctors-in-init-array    Handle constructors as directed by compiler.

If this is the case I recommend using old code so that ctors and init/fini are placed in init array sections or fini array sections.

[atanasyan]

In D6578#9, @shankar.easwaran wrote:

$ ld.gold --help|grep ctors

--ctors-in-init-array       Use DT_INIT_ARRAY for all constructors (default)
--no-ctors-in-init-array    Handle constructors as directed by compiler.

If this is the case I recommend using old code so that ctors and init/fini are placed in init array sections or fini array sections.

The old code puts to the .init_array/.fini_array sections only the symbols specified by the -init/-fini command line options. It does nothing with incoming .ctors and .init sections. I can keep xxxInitAtom / xxxFiniAtom classes but they will be a really dead code. Sure we can/need to implement --ctors-in-init-array default semantics. But I think it is a separate task.

[shankarke]

We should not keep dead code. Lets remove it.

I am not so sure only about the static linking case and whats the user expectation when init/fini option is used with static linking ?

Joerg/Will ?

[joerg]

include/lld/ReaderWriter/ELFLinkingContext.h

220

While here, please move this to the corresponding set function.

224

Same.

test/elf/initfini-options.test

8

Personally, I'd prefer to have a separate file for each of the cases.

[joerg]

I don't think we should do anything special for static linking. It's up to the CRT code to handle .init_array / .fini_array in that case. I don't know if crt1.o on Linux does it, but they discourage static linking anyway.

Always using .init_array breaks platforms using traditional SysV .init. It should only be enabled for Linux and ARM EABI (IIRC). You can't convert .init to .init_array.

[atanasyan]

Closed by commit rL223917 (authored by @atanasyan).

include/lld/ReaderWriter/ELFLinkingContext.h

public:
   /// the file under sysroot directory. If \p fileName is a relative path
   /// and is not in the current directory, search the file through library
   /// search directories.
   ErrorOr<StringRef> searchFile(StringRef fileName, bool isSysRooted) const;
 
   /// Get the entry symbol name
   StringRef entrySymbolName() const override;
 
-  /// add to the list of initializer functions
-  void addInitFunction(StringRef name) { _initFunctions.push_back(name); }
+  /// Set new initializer function
+  void setInitFunction(StringRef name) { _initFunction = name; }
 
-  /// add to the list of finalizer functions
-  void addFiniFunction(StringRef name) { _finiFunctions.push_back(name); }
+  /// Set new finalizer function
+  void setFiniFunction(StringRef name) { _finiFunction = name; }
 
   /// Add an absolute symbol. Used for --defsym.
   void addInitialAbsoluteSymbol(StringRef name, uint64_t addr) {
     _absoluteSymbols[name] = addr;
   }
 
-  /// 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.
-  range<const StringRef *> finiFunctions() const { return _finiFunctions; }
+  /// Return an initializer function name, either default "_init" or
+  /// configured by the -init command line option.
+  StringRef initFunction() const { return _initFunction; }
+
+  /// Return a finalizer function name , either default "_fini" or
+  /// configured by the -fini command line option.
+  StringRef finiFunction() const { return _finiFunction; }
 
   void setSharedObjectName(StringRef soname) {
     _soname = soname;
   }
 
   StringRef sharedObjectName() const { return _soname; }
 
   StringRef getSysroot() const { return _sysrootPath; }
protected:
   bool _demangle;
   bool _alignSegments;
   llvm::Optional<uint64_t> _maxPageSize;
 
   OutputMagic _outputMagic;
   StringRefVector _inputSearchPaths;
   std::unique_ptr<Writer> _writer;
   StringRef _dynamicLinkerPath;
-  StringRefVector _initFunctions;
-  StringRefVector _finiFunctions;
+  StringRef _initFunction;
+  StringRef _finiFunction;
   StringRef _sysrootPath;
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   std::map<std::string, uint64_t> _absoluteSymbols;
   llvm::StringSet<> _dynamicallyExportedSymbols;
 };
 } // end namespace lld
 
 #endif

lib/Driver/GnuLdDriver.cpp

case OPT_dynamic_linker:
       ctx->setInterpreter(inputArg->getValue());
       break;
 
     case OPT_u:
       ctx->addInitialUndefinedSymbol(inputArg->getValue());
       break;
 
     case OPT_init:
-      ctx->addInitFunction(inputArg->getValue());
+      ctx->setInitFunction(inputArg->getValue());
       break;
 
     case OPT_fini:
-      ctx->addFiniFunction(inputArg->getValue());
+      ctx->setFiniFunction(inputArg->getValue());
       break;
 
     case OPT_output_filetype:
       ctx->setOutputFileType(inputArg->getValue());
       break;
 
     case OPT_no_whole_archive:
       attributes.setWholeArchive(false);

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.h

bool isRelativeReloc(const Reference &r) const override {
     switch (r.kindValue()) {
     case llvm::ELF::R_AARCH64_IRELATIVE:
     case llvm::ELF::R_AARCH64_RELATIVE:
       return true;
     default:
       return false;
     }
   }
-
-  /// \brief Create Internal files for Init/Fini
-  void createInternalFiles(std::vector<std::unique_ptr<File>> &) const override;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64LinkingContext.h"
 #include "AArch64RelocationPass.h"
-#include "Atoms.h"
-#include "lld/Core/File.h"
-#include "lld/Core/Instrumentation.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringSwitch.h"
 
 using namespace lld;
-using namespace lld::elf;
-
-using llvm::makeArrayRef;
-
-namespace {
-using namespace llvm::ELF;
-
-const uint8_t AArch64InitFiniAtomContent[8] = {0};
-
-// AArch64InitFini Atom
-class AArch64InitAtom : public InitFiniAtom {
-public:
-  AArch64InitAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".init_array") {
-#ifndef NDEBUG
-    _name = "__init_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return makeArrayRef(AArch64InitFiniAtomContent);
-  }
-  Alignment alignment() const override { return Alignment(3); }
-};
-
-class AArch64FiniAtom : public InitFiniAtom {
-public:
-  AArch64FiniAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".fini_array") {
-#ifndef NDEBUG
-    _name = "__fini_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return makeArrayRef(AArch64InitFiniAtomContent);
-  }
-
-  Alignment alignment() const override { return Alignment(3); }
-};
-
-class AArch64InitFiniFile : public SimpleFile {
-public:
-  AArch64InitFiniFile(const ELFLinkingContext &context)
-      : SimpleFile("command line option -init/-fini"), _ordinal(0) {}
-
-  void addInitFunction(StringRef name) {
-    Atom *initFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    AArch64InitAtom *initAtom = (new (_allocator) AArch64InitAtom(*this, name));
-    initAtom->addReferenceELF_AArch64(llvm::ELF::R_AARCH64_ABS64, 0,
-                                      initFunctionAtom, 0);
-    initAtom->setOrdinal(_ordinal++);
-    addAtom(*initFunctionAtom);
-    addAtom(*initAtom);
-  }
-
-  void addFiniFunction(StringRef name) {
-    Atom *finiFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    AArch64FiniAtom *finiAtom = (new (_allocator) AArch64FiniAtom(*this, name));
-    finiAtom->addReferenceELF_AArch64(llvm::ELF::R_AARCH64_ABS64, 0,
-                                      finiFunctionAtom, 0);
-    finiAtom->setOrdinal(_ordinal++);
-    addAtom(*finiFunctionAtom);
-    addAtom(*finiAtom);
-  }
-
-private:
-  llvm::BumpPtrAllocator _allocator;
-  uint64_t _ordinal;
-};
-
-} // end anon namespace
 
 void elf::AArch64LinkingContext::addPasses(PassManager &pm) {
   auto pass = createAArch64RelocationPass(*this);
   if (pass)
     pm.add(std::move(pass));
   ELFLinkingContext::addPasses(pm);
 }
-
-void elf::AArch64LinkingContext::createInternalFiles(
-    std::vector<std::unique_ptr<File>> &result) const {
-  ELFLinkingContext::createInternalFiles(result);
-  std::unique_ptr<AArch64InitFiniFile> initFiniFile(
-      new AArch64InitFiniFile(*this));
-  for (auto ai : initFunctions())
-    initFiniFile->addInitFunction(ai);
-  for (auto ai : finiFunctions())
-    initFiniFile->addFiniFunction(ai);
-  result.push_back(std::move(initFiniFile));
-}

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

ELFLinkingContext::ELFLinkingContext(
     llvm::Triple triple, std::unique_ptr<TargetHandlerBase> targetHandler)
     : _outputELFType(elf::ET_EXEC), _triple(triple),
       _targetHandler(std::move(targetHandler)), _baseAddress(0),
       _isStaticExecutable(false), _noInhibitExec(false), _exportDynamic(false),
       _mergeCommonStrings(false), _runLayoutPass(true),
       _useShlibUndefines(true), _dynamicLinkerArg(false),
       _noAllowDynamicLibraries(false), _mergeRODataToTextSegment(true),
       _demangle(true), _alignSegments(true), _outputMagic(OutputMagic::DEFAULT),
-      _sysrootPath("") {}
+      _initFunction("_init"), _finiFunction("_fini"), _sysrootPath("") {}
 
 void ELFLinkingContext::addPasses(PassManager &pm) {
   if (_runLayoutPass)
     pm.add(std::unique_ptr<Pass>(new LayoutPass(registry())));
   pm.add(std::unique_ptr<Pass>(new elf::ArrayOrderPass()));
 }
 
 uint16_t ELFLinkingContext::getOutputMachine() const {

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

if (r.kindNamespace() != Reference::KindNamespace::ELF)
       return false;
     switch (r.kindValue()) {
     case llvm::ELF::R_HEX_RELATIVE:
       return true;
     default:
       return false;
     }
   }
-
-  /// \brief Create Internal files for Init/Fini
-  void createInternalFiles(
-      std::vector<std::unique_ptr<File>> &result) const override;
 };
 
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Atoms.h"
 #include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
-#include "lld/Core/File.h"
-#include "lld/Core/Pass.h"
-#include "lld/Core/PassManager.h"
-#include "lld/Core/Simple.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringSwitch.h"
 
-using namespace lld;
 using namespace lld::elf;
 
-namespace {
-
-const uint8_t hexagonInitFiniAtomContent[4] = { 0 };
-
-// HexagonInitFini Atom
-class HexagonInitAtom : public InitFiniAtom {
-public:
-  HexagonInitAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".init_array") {
-#ifndef NDEBUG
-    _name = "__init_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return ArrayRef<uint8_t>(hexagonInitFiniAtomContent, 4);
-  }
-
-  Alignment alignment() const override { return Alignment(2); }
-};
-
-class HexagonFiniAtom : public InitFiniAtom {
-public:
-  HexagonFiniAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".fini_array") {
-#ifndef NDEBUG
-    _name = "__fini_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return ArrayRef<uint8_t>(hexagonInitFiniAtomContent, 4);
-  }
-  Alignment alignment() const override { return Alignment(2); }
-};
-
-class HexagonInitFiniFile : public SimpleFile {
-public:
-  HexagonInitFiniFile(const ELFLinkingContext &context)
-      : SimpleFile("command line option -init/-fini"), _ordinal(0) {}
-
-  void addInitFunction(StringRef name) {
-    Atom *initFuncAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    HexagonInitAtom *initAtom =
-           (new (_allocator) HexagonInitAtom(*this, name));
-    initAtom->addReferenceELF_Hexagon(llvm::ELF::R_HEX_32, 0, initFuncAtom, 0);
-    initAtom->setOrdinal(_ordinal++);
-    addAtom(*initFuncAtom);
-    addAtom(*initAtom);
-  }
-
-  void addFiniFunction(StringRef name) {
-    Atom *finiFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    HexagonFiniAtom *finiAtom =
-           (new (_allocator) HexagonFiniAtom(*this, name));
-    finiAtom->addReferenceELF_Hexagon(llvm::ELF::R_HEX_32, 0, finiFunctionAtom,
-                                      0);
-    finiAtom->setOrdinal(_ordinal++);
-    addAtom(*finiFunctionAtom);
-    addAtom(*finiAtom);
-  }
-
-private:
-  llvm::BumpPtrAllocator _allocator;
-  uint64_t _ordinal;
-};
-}
-
-void elf::HexagonLinkingContext::createInternalFiles(
-    std::vector<std::unique_ptr<File> > &result) const {
-  ELFLinkingContext::createInternalFiles(result);
-  std::unique_ptr<HexagonInitFiniFile> initFiniFile(
-      new HexagonInitFiniFile(*this));
-  for (auto ai : initFunctions())
-    initFiniFile->addInitFunction(ai);
-  for (auto ai:finiFunctions())
-    initFiniFile->addFiniFunction(ai);
-  result.push_back(std::move(initFiniFile));
-}
-
 HexagonLinkingContext::HexagonLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                     new HexagonTargetHandler(*this))) {}

lib/ReaderWriter/ELF/SectionChunks.h

if (initArray) {
       _dt_init_arraysz = addEntry(dyn);
     }
     if (finiArray) {
       dyn.d_tag = DT_FINI_ARRAY;
       _dt_fini_array = addEntry(dyn);
       dyn.d_tag = DT_FINI_ARRAYSZ;
       _dt_fini_arraysz = addEntry(dyn);
     }
+    if (getInitAtomLayout()) {
+      dyn.d_tag = DT_INIT;
+      _dt_init = addEntry(dyn);
+    }
+    if (getFiniAtomLayout()) {
+      dyn.d_tag = DT_FINI;
+      _dt_fini = addEntry(dyn);
+    }
   }
 
   /// \brief Dynamic table tag for .got.plt section referencing.
   /// Usually but not always targets use DT_PLTGOT for that.
   virtual int64_t getGotPltTag() { return DT_PLTGOT; }
 
   virtual void finalize() {
     StringTable<ELFT> *dynamicStringTable =
if (initArray) {
       _entries[_dt_init_array].d_un.d_val = initArray->virtualAddr();
       _entries[_dt_init_arraysz].d_un.d_val = initArray->memSize();
     }
     auto finiArray = _layout.findOutputSection(".fini_array");
     if (finiArray) {
       _entries[_dt_fini_array].d_un.d_val = finiArray->virtualAddr();
       _entries[_dt_fini_arraysz].d_un.d_val = finiArray->memSize();
     }
+    if (const auto *al = getInitAtomLayout())
+      _entries[_dt_init].d_un.d_val = al->_virtualAddr;
+    if (const auto *al = getFiniAtomLayout())
+      _entries[_dt_fini].d_un.d_val = al->_virtualAddr;
     if (_layout.hasDynamicRelocationTable()) {
       auto relaTbl = _layout.getDynamicRelocationTable();
       _entries[_dt_rela].d_un.d_val = relaTbl->virtualAddr();
       _entries[_dt_relasz].d_un.d_val = relaTbl->memSize();
       _entries[_dt_relaent].d_un.d_val = relaTbl->getEntSize();
     }
     if (_layout.hasPLTRelocationTable()) {
       auto relaTbl = _layout.getPLTRelocationTable();
private:
   std::size_t _dt_pltgot;
   std::size_t _dt_pltrel;
   std::size_t _dt_jmprel;
   std::size_t _dt_init_array;
   std::size_t _dt_init_arraysz;
   std::size_t _dt_fini_array;
   std::size_t _dt_fini_arraysz;
   std::size_t _dt_textrel;
+  std::size_t _dt_init;
+  std::size_t _dt_fini;
   TargetLayout<ELFT> &_layout;
   DynamicSymbolTable<ELFT> *_dynamicSymbolTable;
   HashSection<ELFT> *_hashTable;
+
+  const AtomLayout *getInitAtomLayout() {
+    auto al = _layout.findAtomLayoutByName(this->_context.initFunction());
+    if (al && isa<DefinedAtom>(al->_atom))
+      return al;
+    return nullptr;
+  }
+
+  const AtomLayout *getFiniAtomLayout() {
+    auto al = _layout.findAtomLayoutByName(this->_context.finiFunction());
+    if (al && isa<DefinedAtom>(al->_atom))
+      return al;
+    return nullptr;
+  }
 };
 
 template <class ELFT> class InterpSection : public Section<ELFT> {
 public:
   InterpSection(const ELFLinkingContext &context, StringRef str, int32_t order,
                 StringRef interp)
       : Section<ELFT>(context, str, "Dynamic:Interp"), _interp(interp) {
     this->setOrder(order);

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

bool isRelativeReloc(const Reference &r) const override {
     switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_IRELATIVE:
     case llvm::ELF::R_X86_64_RELATIVE:
       return true;
     default:
       return false;
     }
   }
-
-  /// \brief Create Internal files for Init/Fini
-  void createInternalFiles(std::vector<std::unique_ptr<File>> &) const override;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

 //===- lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp ---------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86_64LinkingContext.h"
-#include "Atoms.h"
 #include "X86_64RelocationPass.h"
-#include "lld/Core/File.h"
-#include "lld/Core/Instrumentation.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringSwitch.h"
 
 using namespace lld;
-using namespace lld::elf;
-
-using llvm::makeArrayRef;
-
-namespace {
-using namespace llvm::ELF;
-
-const uint8_t x86_64InitFiniAtomContent[8] = { 0 };
-
-// X86_64InitFini Atom
-class X86_64InitAtom : public InitFiniAtom {
-public:
-  X86_64InitAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".init_array") {
-#ifndef NDEBUG
-    _name = "__init_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return makeArrayRef(x86_64InitFiniAtomContent);
-  }
-  Alignment alignment() const override { return Alignment(3); }
-};
-
-class X86_64FiniAtom : public InitFiniAtom {
-public:
-  X86_64FiniAtom(const File &f, StringRef function)
-      : InitFiniAtom(f, ".fini_array") {
-#ifndef NDEBUG
-    _name = "__fini_fn_";
-    _name += function;
-#endif
-  }
-  ArrayRef<uint8_t> rawContent() const override {
-    return makeArrayRef(x86_64InitFiniAtomContent);
-  }
-
-  Alignment alignment() const override { return Alignment(3); }
-};
-
-class X86_64InitFiniFile : public SimpleFile {
-public:
-  X86_64InitFiniFile(const ELFLinkingContext &context)
-      : SimpleFile("command line option -init/-fini"), _ordinal(0) {}
-
-  void addInitFunction(StringRef name) {
-    Atom *initFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    X86_64InitAtom *initAtom =
-           (new (_allocator) X86_64InitAtom(*this, name));
-    initAtom->addReferenceELF_x86_64(llvm::ELF::R_X86_64_64, 0,
-                                     initFunctionAtom, 0);
-    initAtom->setOrdinal(_ordinal++);
-    addAtom(*initFunctionAtom);
-    addAtom(*initAtom);
-  }
-
-  void addFiniFunction(StringRef name) {
-    Atom *finiFunctionAtom = new (_allocator) SimpleUndefinedAtom(*this, name);
-    X86_64FiniAtom *finiAtom =
-           (new (_allocator) X86_64FiniAtom(*this, name));
-    finiAtom->addReferenceELF_x86_64(llvm::ELF::R_X86_64_64, 0,
-                                     finiFunctionAtom, 0);
-    finiAtom->setOrdinal(_ordinal++);
-    addAtom(*finiFunctionAtom);
-    addAtom(*finiAtom);
-  }
-
-private:
-  llvm::BumpPtrAllocator _allocator;
-  uint64_t _ordinal;
-};
-
-} // end anon namespace
 
 void elf::X86_64LinkingContext::addPasses(PassManager &pm) {
   auto pass = createX86_64RelocationPass(*this);
   if (pass)
     pm.add(std::move(pass));
   ELFLinkingContext::addPasses(pm);
 }
-
-void elf::X86_64LinkingContext::createInternalFiles(
-    std::vector<std::unique_ptr<File> > &result) const {
-  ELFLinkingContext::createInternalFiles(result);
-  std::unique_ptr<X86_64InitFiniFile> initFiniFile(
-      new X86_64InitFiniFile(*this));
-  for (auto ai : initFunctions())
-    initFiniFile->addInitFunction(ai);
-  for (auto ai:finiFunctions())
-    initFiniFile->addFiniFunction(ai);
-  result.push_back(std::move(initFiniFile));
-}
-

test/elf/AArch64/initfini-alignment.test

-# This tests the functionality that lld is able to create
-# init_array/fini_array sections in the output ELF with the
-# right alignment
-
-RUN: lld -flavor gnu -target aarch64--linux-gnu %p/Inputs/initfini-option.o  \
-RUN: -init init -fini fini --noinhibit-exec -o %t
-RUN: llvm-readobj -s %t | FileCheck %s
-
-CHECK:    Name: .init_array
-CHECK:    AddressAlignment: 8
-CHECK:    Name: .fini_array
-CHECK:    AddressAlignment: 8

test/elf/AArch64/initfini-option.test

-# This tests the functionality that lld is able to create
-# init_array/fini_array sections in the output ELF. This
-# corresponds to the the .init_array/.fini_array sections
-# in the output ELF.
-
-RUN: lld -flavor gnu -target aarch64--linux-gnu %p/Inputs/initfini-option.o  \
-RUN: -init init -fini fini --noinhibit-exec --output-filetype=yaml -static -o %t
-RUN: FileCheck %s < %t
-
-CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-CHECK:    section-name:    .init_array
-CHECK:    references:
-CHECK:      - kind:            R_AARCH64_ABS64
-CHECK:        offset:          0
-CHECK:        target:          init
-CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-CHECK:    section-name:    .fini_array
-CHECK:    references:
-CHECK:      - kind:            R_AARCH64_ABS64
-CHECK:        offset:          0
-CHECK:        target:          fini

test/elf/Hexagon/Inputs/initfini-option.c

-#include <stdio.h>
-
-void init() {
- printf("%s\n", __FUNCTION__);
-}
-
-void fini() {
- printf("%s\n", __FUNCTION__);
-}
-
-int main() {
-}
-

test/elf/Hexagon/initfini-option.test

-# This tests the functionality that lld is able to create
-# init_array/fini_array sections in the output ELF. This
-# corresponds to the the .init_array/.fini_array sections
-# in the output ELF.
-
-RUN: lld -flavor gnu -target hexagon %p/Inputs/initfini-option.o  \
-RUN: -init init -fini fini --noinhibit-exec --output-filetype=yaml -static -o %t
-RUN: FileCheck %s < %t
-
-CHECK:    content:         [ 00, 00, 00, 00 ]
-CHECK:    section-name:    .init_array
-CHECK:    references:
-CHECK:      - kind:            R_HEX_32
-CHECK:        offset:          0
-CHECK:        target:          init
-CHECK:    content:         [ 00, 00, 00, 00 ]
-CHECK:    section-name:    .fini_array
-CHECK:    references:
-CHECK:      - kind:            R_HEX_32
-CHECK:        offset:          0
-CHECK:        target:          fini

test/elf/X86_64/initfini-alignment.test

-# This tests the functionality that lld is able to create
-# init_array/fini_array sections in the output ELF with the
-# right alignment
-
-RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/initfini-option.o  \
-RUN: -init init -fini fini --noinhibit-exec -o %t
-RUN: llvm-readobj -s %t | FileCheck %s
-
-CHECK:    Name: .init_array
-CHECK:    AddressAlignment: 8
-CHECK:    Name: .fini_array
-CHECK:    AddressAlignment: 8

test/elf/X86_64/initfini-option.test

-# This tests the functionality that lld is able to create
-# init_array/fini_array sections in the output ELF. This
-# corresponds to the the .init_array/.fini_array sections
-# in the output ELF.
-
-RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/initfini-option.o  \
-RUN: -init init -fini fini --noinhibit-exec --output-filetype=yaml -o %t
-RUN: FileCheck %s < %t
-
-CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-CHECK:    section-name:    .init_array
-CHECK:    references:
-CHECK:      - kind:            R_X86_64_64
-CHECK:        offset:          0
-CHECK:        target:          init
-CHECK:    content:         [ 00, 00, 00, 00, 00, 00, 00, 00 ]
-CHECK:    section-name:    .fini_array
-CHECK:    references:
-CHECK:      - kind:            R_X86_64_64
-CHECK:        offset:          0
-CHECK:        target:          fini

test/elf/initfini-options.test

+# Check the three following cases related to the DT_INIT/DT_FINI dynamic
+# table tags and -init/-fini command line options handling:
+# a) If there are no -init/-fini options and _init/_fini symbols are undefined
+#    linker does not emit DT_INIT/DT_FINI tags.
+# b) If _init/_fini symbols are defined linker emit DT_INIT/DT_FINI tags
+#    point to these symbols.
+# c) If there are -init/-fini options, they override default function names
+#    and linker uses the corresponding symbol values for the DT_INIT/DT_FINI.
+
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t.no-init.o
+# RUN: lld -flavor gnu -target x86_64 -shared --noinhibit-exec \
+# RUN:     -o %t.no-init.so %t.no-init.o
+# RUN: llvm-readobj -dynamic-table %t.no-init.so \
+# RUN:   | FileCheck -check-prefix=NO-INIT %s
+
+# NO-INIT-NOT: 0x000000000000000C INIT 0x{{[0-9A-F]+}}
+# NO-INIT-NOT: 0x000000000000000D FINI 0x{{[0-9A-F]+}}
+
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t.def-init.o
+# RUN: lld -flavor gnu -target x86_64 -shared -o %t.def-init.so %t.def-init.o
+# RUN: llvm-readobj -symbols -dynamic-table %t.def-init.so \
+# RUN:   | FileCheck -check-prefix=DEF-INIT %s
+
+# DEF-INIT:      Name: _init (8)
+# DEF-INIT-NEXT: Value: 0x4001E4
+# DEF-INIT:      Name: _fini (14)
+# DEF-INIT-NEXT: Value: 0x4001EB
+#
+# DEF-INIT: 0x000000000000000C INIT 0x4001E4
+# DEF-INIT: 0x000000000000000D FINI 0x4001EB
+
+# RUN: yaml2obj -format=elf -docnum 3 %s > %t.custom-init.o
+# RUN: lld -flavor gnu -target x86_64 -shared \
+# RUN:     -init _init -init _start -fini _fini -fini _stop \
+# RUN:     -o %t.custom-init.so %t.custom-init.o
+# RUN: llvm-readobj -symbols -dynamic-table %t.custom-init.so \
+# RUN:   | FileCheck -check-prefix=CUSTOM-INIT %s
+
+# CUSTOM-INIT:      Name: _start (1)
+# CUSTOM-INIT-NEXT: Value: 0x4001FC
+# CUSTOM-INIT:      Name: _stop (8)
+# CUSTOM-INIT-NEXT: Value: 0x400204
+#
+# CUSTOM-INIT: 0x000000000000000C INIT 0x4001FC
+# CUSTOM-INIT: 0x000000000000000D FINI 0x400204
+
+# no-init.o
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  0x04
+    Size:          0x08
+
+Symbols:
+  Global:
+    - Name:        _start
+      Type:        STT_FUNC
+      Section:     .text
+      Size:        0x08
+    - Name:        _init
+    - Name:        _fini
+
+# def-init.o
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  0x04
+    Size:          0x18
+
+Symbols:
+  Global:
+    - Name:        _start
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0x0
+      Size:        0x8
+    - Name:        _init
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0x8
+      Size:        0x8
+    - Name:        _fini
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0xF
+      Size:        0x8
+
+# custom-init.o
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+Sections:
+  - Name:          .text
+    Type:          SHT_PROGBITS
+    Flags:         [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:  0x04
+    Size:          0x20
+
+Symbols:
+  Global:
+    - Name:        _start
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0x0
+      Size:        0x8
+    - Name:        _stop
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0x8
+      Size:        0x8
+    - Name:        _init
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0xF
+      Size:        0x8
+    - Name:        _fini
+      Type:        STT_FUNC
+      Section:     .text
+      Value:       0x18
+      Size:        0x8
+...

unittests/DriverTests/GnuLdDriverTest.cpp

TEST_F(GnuLdParserTest, EntryJoined) {
   EXPECT_EQ("foo", _context->entrySymbolName());
 }
 
 // --init
 
 TEST_F(GnuLdParserTest, Init) {
   EXPECT_TRUE(parse("ld", "--start-group", "--end-group", "-init", "foo",
                     "-init", "bar", nullptr));
-  EXPECT_EQ(2, _context->initFunctions().size());
-  EXPECT_EQ("foo", _context->initFunctions()[0]);
-  EXPECT_EQ("bar", _context->initFunctions()[1]);
+  EXPECT_EQ("bar", _context->initFunction());
 }
 
 TEST_F(GnuLdParserTest, InitJoined) {
   EXPECT_TRUE(parse("ld", "--start-group", "--end-group", "-init=foo",
                     nullptr));
-  EXPECT_EQ(1, _context->initFunctions().size());
-  EXPECT_EQ("foo", _context->initFunctions()[0]);
+  EXPECT_EQ("foo", _context->initFunction());
 }
 
 // --soname
 
 TEST_F(GnuLdParserTest, SOName) {
   EXPECT_TRUE(parse("ld", "--start-group", "--end-group", "--soname=foo",
                     nullptr));
   EXPECT_EQ("foo", _context->sharedObjectName());