[ELF2] Add -init and -fini switches

[ikudrin]

Summary

Add DT_INIT and DT_FINI entries to the dynamic table section if corresponding symbols are defined, "_init" and "_fini" respectively.
Symbol names can be overridden by using -init and -fini command line switches.

[ruiu]

What happens if the symbol given by -fini is in an archive? Does linker have to resolve the symbol by extracting and parsing the object file from the archive?

ELF/OutputSections.cpp

221–232 ↗

(On Diff #36364)

Lambda doesn't seem to help improve readability here. This would be better.

if (Symbol *S = Symtab.getSymbols().lookup(Config->Init)))
  InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
if (Symbol *S = Symtab.getSymbols().lookup(Config->Fini)))
  FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);

if (InitSym)
  ++NumEntries; // DT_FINI
if (FiniSym)
  ++NumEntries; // DT_INIT

ELF/OutputSections.h

334–335 ↗

(On Diff #36364)

InitSymbolBody -> InitSym
Likewise Fini.

334–335 ↗

(On Diff #36364)

These symbols type should be Defined<ELFT>, no? They can't be Undefined<ELFT> which is a subclass of ELFSymbolBody<ELFT>

[ikudrin]

In D13385#258775, @ruiu wrote:

What happens if the symbol given by -fini is in an archive? Does linker have to resolve the symbol by extracting and parsing the object file from the archive?

I investigated this case with ld. These switches don't force the linker to resolve these symbols. Moreover, there is even no warning if the symbols stay unresolved.

[ikudrin]

ELF/OutputSections.h

334–335 ↗

(On Diff #36364)

These symbols type should be Defined<ELFT>, no? They can't be Undefined<ELFT> which is a subclass of ELFSymbolBody<ELFT>

It sounds strange, but:

$ cat > x.s
.globl _start,_init,_fini;
_start:
^C
$ llvm-mc -filetype=obj -triple=x86_64-pc-linux -o x.o x.s
$ ld -shared -o x.out x.o
$ llvm-readobj -dynamic-table -symbols x.out

File: x.out
Format: ELF64-x86-64
Arch: x86_64
AddressSize: 64bit
LoadName: 
Symbols [
  ...
  Symbol {
    Name: _init (32)
    Value: 0x0
    Size: 0
    Binding: Global (0x1)
    Type: None (0x0)
    Other: 0
    Section: Undefined (0x0)
  }
  ...
  Symbol {
    Name: _fini (57)
    Value: 0x0
    Size: 0
    Binding: Global (0x1)
    Type: None (0x0)
    Other: 0
    Section: Undefined (0x0)
  }
  ...
]
DynamicSection [ (8 entries)
  Tag                Type                 Name/Value
  0x000000000000000C INIT                 0x0
  0x000000000000000D FINI                 0x0
  0x0000000000000004 HASH                 0xE8
  0x0000000000000005 STRTAB               0x1C0
  0x0000000000000006 SYMTAB               0x118
  0x000000000000000A STRSZ                37 (bytes)
  0x000000000000000B SYMENT               24 (bytes)
  0x0000000000000000 NULL                 0x0
]

[ruiu]

Thank you for the investigation. LGTM

lld/trunk/ELF/OutputSections.cpp

232

Remove this blank line.

lld/trunk/ELF/Config.h

 #include <vector>
 
 namespace lld {
 namespace elf2 {
 
 struct Configuration {
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
+  llvm::StringRef Fini = "_fini";
+  llvm::StringRef Init = "_init";
   llvm::StringRef OutputFile = "a.out";
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> InputSearchPaths;
   bool AllowMultipleDefinition;
   bool DiscardAll;
   bool DiscardLocals;

lld/trunk/ELF/Driver.cpp

if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
 
   for (auto *Arg : Args.filtered(OPT_L))
     Config->InputSearchPaths.push_back(Arg->getValue());
 
   if (auto *Arg = Args.getLastArg(OPT_entry))
     Config->Entry = Arg->getValue();
 
+  if (auto *Arg = Args.getLastArg(OPT_fini))
+    Config->Fini = Arg->getValue();
+
+  if (auto *Arg = Args.getLastArg(OPT_init))
+    Config->Init = Arg->getValue();
+
   if (auto *Arg = Args.getLastArg(OPT_soname))
     Config->SoName = Arg->getValue();
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);

lld/trunk/ELF/Options.td

def dynamic_linker : Separate<["--", "-"], "dynamic-linker">,
   HelpText<"Which dynamic linker to use">;
 
 def entry : Separate<["--", "-"], "entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def export_dynamic : Flag<["--", "-"], "export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
+def fini : Separate<["-"], "fini">, MetaVarName<"<symbol>">,
+  HelpText<"Specify a finalizer function">;
+
+def init : Separate<["-"], "init">, MetaVarName<"<symdol>">,
+  HelpText<"Specify an initializer function">;
+
 def l : Joined<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def no_allow_shlib_undefined : Flag<["--"], "no-allow-shlib-undefined">;
 
 def no_whole_archive : Flag<["--"], "no-whole-archive">,
   HelpText<"Restores the default behavior of loading archive members">;
 

 def alias_Bdynamic_dy: Flag<["-"], "dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: Flag<["-"], "dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: Flag<["-"], "non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: Flag<["-"], "static">, Alias<Bstatic>;
 def alias_L__library_path : Joined<["--"], "library-path=">, Alias<L>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
 def alias_entry_e : Separate<["-"], "e">, Alias<entry>;
+def alias_fini_fini : Joined<["-"], "fini=">, Alias<fini>;
+def alias_init_init : Joined<["-"], "init=">, Alias<init>;
 def alias_l__library : Joined<["--"], "library=">, Alias<l>;
 def alias_rpath_rpath : Joined<["-"], "rpath=">, Alias<rpath>;
 def alias_soname_h : Separate<["-"], "h">, Alias<soname>;
 def alias_soname_soname : Separate<["-"], "soname">, Alias<soname>;
 def alias_undefined_u : Separate<["-"], "u">, Alias<undefined>;
 
 // Options listed below are silently ignored now.
 def O3 : Flag<["-"], "O3">;

lld/trunk/ELF/OutputSections.h

class DynamicSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef typename Base::HeaderT HeaderT;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
 
 public:
   DynamicSection(SymbolTable &SymTab, HashTableSection<ELFT> &HashSec,
-                 RelocationSection<ELFT> &RelaDynSec);
+                 RelocationSection<ELFT> &RelaDynSec,
+                 const OutputSection<ELFT> &BssSec);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
 
   OutputSection<ELFT> *PreInitArraySec = nullptr;
   OutputSection<ELFT> *InitArraySec = nullptr;
   OutputSection<ELFT> *FiniArraySec = nullptr;
 
 private:
   HashTableSection<ELFT> &HashSec;
   SymbolTableSection<ELFT> &DynSymSec;
   StringTableSection<ELFT::Is64Bits> &DynStrSec;
   RelocationSection<ELFT> &RelaDynSec;
+  const OutputSection<ELFT> &BssSec;
   SymbolTable &SymTab;
+  const ELFSymbolBody<ELFT> *InitSym = nullptr;
+  const ELFSymbolBody<ELFT> *FiniSym = nullptr;
 };
 }
 }
 #endif

lld/trunk/ELF/OutputSections.cpp

template <class ELFT> void HashTableSection<ELFT>::addSymbol(SymbolBody *S) {
   DynSymSec.addSymbol(Name);
   Hashes.push_back(hash(Name));
   S->setDynamicSymbolTableIndex(Hashes.size());
 }
 
 template <class ELFT>
 DynamicSection<ELFT>::DynamicSection(SymbolTable &SymTab,
                                      HashTableSection<ELFT> &HashSec,
-                                     RelocationSection<ELFT> &RelaDynSec)
+                                     RelocationSection<ELFT> &RelaDynSec,
+                                     const OutputSection<ELFT> &BssSec)
     : OutputSectionBase<ELFT::Is64Bits>(".dynamic", llvm::ELF::SHT_DYNAMIC,
                                         llvm::ELF::SHF_ALLOC |
                                             llvm::ELF::SHF_WRITE),
       HashSec(HashSec), DynSymSec(HashSec.getDynSymSec()),
       DynStrSec(DynSymSec.getStrTabSec()), RelaDynSec(RelaDynSec),
-      SymTab(SymTab) {
+      BssSec(BssSec), SymTab(SymTab) {
   typename Base::HeaderT &Header = this->Header;
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
   Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (this->Header.sh_size)
     return; // Already finalized.
if (FiniArraySec)
     NumEntries += 2;
 
   const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
       SymTab.getSharedFiles();
   for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
     DynStrSec.add(File->getSoName());
   NumEntries += SharedFiles.size();
 
+  if (Symbol *S = SymTab.getSymbols().lookup(Config->Init))
+    InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
+  if (Symbol *S = SymTab.getSymbols().lookup(Config->Fini))
+    FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
+
+  if (InitSym)
+    ++NumEntries; // DT_INIT
+  if (FiniSym)
+    ++NumEntries; // DT_FINI
+
   ++NumEntries; // DT_NULL
 
   Header.sh_size = NumEntries * Header.sh_entsize;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
 
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   WriteArray(DT_INIT_ARRAY, DT_INIT_ARRAYSZ, InitArraySec);
   WriteArray(DT_FINI_ARRAY, DT_FINI_ARRAYSZ, FiniArraySec);
 
   const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
       SymTab.getSharedFiles();
   for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
     WriteVal(DT_NEEDED, DynStrSec.getFileOff(File->getSoName()));
 
+  if (InitSym)
+    WritePtr(DT_INIT, getSymVA(*InitSym, BssSec));
+  if (FiniSym)
+    WritePtr(DT_FINI, getSymVA(*FiniSym, BssSec));
+
   WriteVal(DT_NULL, 0);
 }
 
 template <class ELFT>
 OutputSection<ELFT>::OutputSection(const PltSection<ELFT> &PltSec,
                                    const GotSection<ELFT> &GotSec,
                                    const OutputSection<ELFT> &BssSec,
                                    StringRef Name, uint32_t sh_type,

lld/trunk/ELF/Writer.cpp

public:
   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
   Writer(SymbolTable *T)
       : SymTabSec(*T, StrTabSec, BssSec), DynSymSec(*T, DynStrSec, BssSec),
         RelaDynSec(DynSymSec, GotSec, T->shouldUseRela()), PltSec(GotSec),
-        HashSec(DynSymSec), DynamicSec(*T, HashSec, RelaDynSec),
+        HashSec(DynSymSec), DynamicSec(*T, HashSec, RelaDynSec, BssSec),
         BssSec(PltSec, GotSec, BssSec, ".bss", SHT_NOBITS,
                SHF_ALLOC | SHF_WRITE) {}
   void run();
 
 private:
   void createSections();
   template <bool isRela>
   void scanRelocs(const InputSection<ELFT> &C,

lld/trunk/test/elf2/init-fini.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+// Should use "_init" and "_fini" by default when fills dynamic table
+// RUN: lld -flavor gnu2 -shared %t -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck --check-prefix=BYDEF %s
+// BYDEF: INIT 0x11010
+// BYDEF: FINI 0x11020
+
+// -init and -fini override symbols to use
+// RUN: lld -flavor gnu2 -shared %t -o %t2 -init _foo -fini _bar
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck --check-prefix=OVR %s
+// OVR: INIT 0x11030
+// OVR: FINI 0x11040
+
+// Check aliases as well
+// RUN: lld -flavor gnu2 -shared %t -o %t2 -init=_foo -fini=_bar
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck --check-prefix=OVR %s
+
+// Should add a dynamic table entry even if a given symbol stay undefined
+// RUN: lld -flavor gnu2 -shared %t -o %t2 -init=_undef -fini=_undef
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck --check-prefix=UNDEF %s
+// UNDEF: INIT 0x0
+// UNDEF: FINI 0x0
+
+// Should not add new entries to the symbol table
+// and should not require given symbols to be resolved
+// RUN: lld -flavor gnu2 -shared %t -o %t2 -init=_unknown -fini=_unknown
+// RUN: llvm-readobj -symbols -dynamic-table %t2 | FileCheck --check-prefix=NOENTRY %s
+// NOENTRY: Symbols [
+// NOENTRY-NOT: Name: _unknown
+// NOENTRY: ]
+// NOENTRY: DynamicSection [
+// NOENTRY-NOT: INIT
+// NOENTRY-NOT: FINI
+// NOENTRY: ]
+
+.global _start,_init,_fini,_foo,_bar,_undef;
+_start:
+_init = 0x11010
+_fini = 0x11020
+_foo  = 0x11030
+_bar  = 0x11040