[ELF] Handle __init_array{start, end} correctly.

[davide]

Summary

I noticed that lld handles __init_array{start, end} incorrectly.

GNU ld

% objdump -t ./ld | grep init_array
00000000010cc000 l .ctors 0000000000000000 .hidden
init_array_end
00000000010cc000 l .ctors 0000000000000000 .hidden
__init_array_start

lld

% objdump -t ./bin/lld |grep init_array
0000000000000000 g O *ABS* 0000000000000000 init_array_start
0000000000000000 g O *ABS* 0000000000000000 __init_array_end

This patch is an attempt to fix.
If you agree with the approach, I'll change fini_array and preinit_array as well, and add tests.

[davide]

Just for completeness, the careful reader may notice that visibility isn't handled correctly. As long as this is a general problem in lld, I'll tackle it separately later.

[shankarke]

lib/ReaderWriter/ELF/Atoms.h

873

It would be nice to add a class LinkerDefinedAtoms, that you can use for the purpose. It would simplify / remove extraneous code.

Another thing apart from visibility that lld doesnot currently do is the symbols get added for executables all the time, even there is no init_array section.

[davide]

lib/ReaderWriter/ELF/Atoms.h

873

So if I read correctly your proposal is that of renaming InitArrayAtom to LinkerDefinedAtoms and use that also for preinit/fini/bss etc..?
About --gc-section,. I've already did some ground work for it and fixed bugs (see r230614 and r230737) but still lots of atoms get reclaimed when they shouldn't, making lld not functional. This patch is also part of the ground work because the section is important to understand what can or cannot be stripped (see KEEP directive of GNU ld linker script, which is, unfortunately or not) widely used in FreeBSD default linker script and FreeBSD kernel linker script.

[ruiu]

lib/ReaderWriter/ELF/Atoms.h

873

This is not a complicated class so I think it's ok for now. We may want to clean this up, but that needs to be done in a separate patch. First thing we should do is probably removing blank lines from one-line member function definitions so that they look more like simple struct-like field definitions.

lib/ReaderWriter/ELF/Atoms.h

public:
 
   ContentPermissions permissions() const override { return permRW_; }
 
   Alignment alignment() const override { return Alignment(0); }
 
   ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
 };
 
+class InitArrayAtom : public SimpleELFDefinedAtom {
+  StringRef _name;
+  StringRef _section;
+
+public:
+  InitArrayAtom(const File &f, StringRef symName, StringRef secName)
+      : SimpleELFDefinedAtom(f), _name(symName), _section(secName) {}
+
+  StringRef name() const override { return _name; };
+
+  Scope scope() const override { return scopeGlobal; };
+
+  SectionChoice sectionChoice() const override { return sectionCustomRequired; }
+
+  StringRef customSectionName() const override { return _section; }
+
+  ContentType contentType() const override { return typeData; }
+
+  uint64_t size() const override { return 0; }
+
+  ContentPermissions permissions() const override { return permRW_; }
+
+  Alignment alignment() const override { return Alignment(0); }
+
+  ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
+};
+
 class InitFiniAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   InitFiniAtom(const File &f, StringRef secName)
       : SimpleELFDefinedAtom(f), _section(secName) {}
 
   Scope scope() const override { return scopeGlobal; }

lib/ReaderWriter/ELF/ELFFile.h

virtual Atom *addUndefinedAtom(StringRef symbolName) {
     symbol->setBindingAndType(llvm::ELF::STB_GLOBAL, llvm::ELF::STT_NOTYPE);
     symbol->st_other = llvm::ELF::STV_DEFAULT;
     symbol->st_size = 0;
     auto newAtom = this->handleUndefinedSymbol(symbolName, symbol);
     this->_undefinedAtoms._atoms.push_back(*newAtom);
     return *newAtom;
   }
 
-  // cannot add atoms to C Runtime file
-  virtual void addAtom(const Atom &) {
-    llvm_unreachable("cannot add atoms to Runtime files");
+  /// \brief add default atom
+  virtual void addAtom(const Atom &atom) {
+    if (auto *defAtom = dyn_cast<DefinedAtom>(&atom)) {
+      this->_definedAtoms._atoms.push_back(defAtom);
+    } else {
+      llvm_unreachable("can't add this atom");
+    }
   }
+  llvm::BumpPtrAllocator _alloc;
 };
 
 template <class ELFT>
 ErrorOr<std::unique_ptr<ELFFile<ELFT>>>
 ELFFile<ELFT>::create(std::unique_ptr<MemoryBuffer> mb,
                       ELFLinkingContext &ctx) {
   std::unique_ptr<ELFFile<ELFT>> file(new ELFFile<ELFT>(std::move(mb), ctx));
   return std::move(file);

lib/ReaderWriter/ELF/ExecutableWriter.h

void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
 }
 
 /// \brief Add absolute symbols by default. These are linker added
 /// absolute symbols
 template<class ELFT>
 void ExecutableWriter<ELFT>::addDefaultAtoms() {
   _runtimeFile->addUndefinedAtom(this->_context.entrySymbolName());
+  _runtimeFile->addAtom(*new (_runtimeFile->_alloc)
+    InitArrayAtom(*_runtimeFile, "__init_array_start", ".init_array"));
+  _runtimeFile->addAtom(*new (_runtimeFile->_alloc)
+    InitArrayAtom(*_runtimeFile, "__init_array_end", ".init_array"));
+
+  // XXX: These aren't absolute atoms and need to be fixed.
   _runtimeFile->addAbsoluteAtom("__bss_start");
   _runtimeFile->addAbsoluteAtom("__bss_end");
   _runtimeFile->addAbsoluteAtom("_end");
   _runtimeFile->addAbsoluteAtom("end");
   _runtimeFile->addAbsoluteAtom("__preinit_array_start");
   _runtimeFile->addAbsoluteAtom("__preinit_array_end");
-  _runtimeFile->addAbsoluteAtom("__init_array_start");
-  _runtimeFile->addAbsoluteAtom("__init_array_end");
   if (this->_context.isRelaOutputFormat()) {
     _runtimeFile->addAbsoluteAtom("__rela_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rela_iplt_end");
   } else {
     _runtimeFile->addAbsoluteAtom("__rel_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rel_iplt_end");
   }
   _runtimeFile->addAbsoluteAtom("__fini_array_start");
if (section) {
       (*e)->_virtualAddr = section->virtualAddr() + section->memSize();
     } else {
       (*s)->_virtualAddr = 0;
       (*e)->_virtualAddr = 0;
     }
   };
 
   startEnd("preinit_array", ".preinit_array");
-  startEnd("init_array", ".init_array");
   if (this->_context.isRelaOutputFormat())
     startEnd("rela_iplt", ".rela.plt");
   else
     startEnd("rel_iplt", ".rel.plt");
   startEnd("fini_array", ".fini_array");
 
   assert(!(bssStartAtomIter == this->_layout.absoluteAtoms().end() ||
            bssEndAtomIter == this->_layout.absoluteAtoms().end() ||