Covnert .[cd]tors to .{init,fini}_array using synthetic section.

[ruiu]

Summary

This patch defines InitFiniSection synthetic section to convert
.[cd]tors to .{init,fini}_array.

[orivej]

@ruiu I'd appreciate if you continue with this review.

WRT toInitFiniName — section renaming was just a hack, and it is absent from my final patch. Is it really needed here?

[• rafael]

lld/ELF/SyntheticSections.h

130

Do we need a new type?

You can have a standalone function that does the conversion and creates a InputSection directly. Not that different from how .comment is created.

lld/ELF/Writer.cpp

137

We have to check if all systems support .init_array. Ed, can you confirm?

[emaste]

lld/ELF/Writer.cpp

137

FreeBSD support was added in r232831 in March 2012.

NetBSD has support, although I don't know if there are platform-specific differences. I'm not sure about OpenBSD; I see patches were posted last year but I do not know if they were merged in. Perhaps @joerg and @kettenis can add more info?

[grimar]

lld/ELF/Writer.cpp

137

Should we show warning when have .ctors/.dtors ?

[kettenis]

I added support for .init_array and .fini_array to OpenBSD's ld.so almost a year ago. It hasn't been extensively tested on architectures other than arm64, but there is no reason why it shouldn't work on other architectures. We don't really have any ABI concerns.

However, .init_array and .fini_array don't work (yet) for static binaries. I don't think that's a major issue.

[joerg]

Warning for .ctor/.dtor use would IMO be completely bogus. They can easily be translated and they are kind of the LCD for "portable" assembler, i.e. much less problematic to deal with than plain .init/.fini segments.

[ruiu]

• Resurrect an old patch to support .ctors/.dtors to be used with .init/fini.

[joerg]

lld/ELF/SyntheticSections.cpp

124

This comment is bogus, since .init/.fini is a completely different thing.

lld/ELF/Writer.cpp

137

NetBSD uses .init_array only on new archs (arm64) and where mandated by the ABI (arm-eabi).

lld/ELF/OutputSections.h

public:
   bool Noload = false;
 
   template <class ELFT> void finalize();
   template <class ELFT> void writeTo(uint8_t *Buf);
   template <class ELFT> void maybeCompress();
 
   void sort(std::function<int(InputSectionBase *S)> Order);
   void sortInitFini();
-  void sortCtorsDtors();
 
 private:
   // Used for implementation of --compress-debug-sections option.
   std::vector<uint8_t> ZDebugHeader;
   llvm::SmallVector<char, 1> CompressedData;
 
   uint32_t getFiller();
 };

lld/ELF/OutputSections.cpp

template <class ELFT> void OutputSection::finalize() {
   Link = InX::SymTab->getParent()->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase *S = First->getRelocatedSection();
   Info = S->getOutputSection()->SectionIndex;
   Flags |= SHF_INFO_LINK;
 }
 
-// Returns true if S matches /Filename.?\.o$/.
-static bool isCrtBeginEnd(StringRef S, StringRef Filename) {
-  if (!S.endswith(".o"))
-    return false;
-  S = S.drop_back(2);
-  if (S.endswith(Filename))
-    return true;
-  return !S.empty() && S.drop_back().endswith(Filename);
-}
-
-static bool isCrtbegin(StringRef S) { return isCrtBeginEnd(S, "crtbegin"); }
-static bool isCrtend(StringRef S) { return isCrtBeginEnd(S, "crtend"); }
-
-// .ctors and .dtors are sorted by this priority from highest to lowest.
-//
-//  1. The section was contained in crtbegin (crtbegin contains
-//     some sentinel value in its .ctors and .dtors so that the runtime
-//     can find the beginning of the sections.)
-//
-//  2. The section has an optional priority value in the form of ".ctors.N"
-//     or ".dtors.N" where N is a number. Unlike .{init,fini}_array,
-//     they are compared as string rather than number.
-//
-//  3. The section is just ".ctors" or ".dtors".
-//
-//  4. The section was contained in crtend, which contains an end marker.
-//
-// In an ideal world, we don't need this function because .init_array and
-// .ctors are duplicate features (and .init_array is newer.) However, there
-// are too many real-world use cases of .ctors, so we had no choice to
-// support that with this rather ad-hoc semantics.
-static bool compCtors(const InputSection *A, const InputSection *B) {
-  bool BeginA = isCrtbegin(A->File->getName());
-  bool BeginB = isCrtbegin(B->File->getName());
-  if (BeginA != BeginB)
-    return BeginA;
-  bool EndA = isCrtend(A->File->getName());
-  bool EndB = isCrtend(B->File->getName());
-  if (EndA != EndB)
-    return EndB;
-  StringRef X = A->Name;
-  StringRef Y = B->Name;
-  assert(X.startswith(".ctors") || X.startswith(".dtors"));
-  assert(Y.startswith(".ctors") || Y.startswith(".dtors"));
-  X = X.substr(6);
-  Y = Y.substr(6);
-  if (X.empty() && Y.empty())
-    return false;
-  return X < Y;
-}
-
-// Sorts input sections by the special rules for .ctors and .dtors.
-// Unfortunately, the rules are different from the one for .{init,fini}_array.
-// Read the comment above.
-void OutputSection::sortCtorsDtors() {
-  assert(SectionCommands.size() == 1);
-  auto *ISD = cast<InputSectionDescription>(SectionCommands[0]);
-  std::stable_sort(ISD->Sections.begin(), ISD->Sections.end(), compCtors);
-}
-
 // If an input string is in the form of "foo.N" where N is a number,
 // return N. Otherwise, returns 65536, which is one greater than the
 // lowest priority.
 int elf::getPriority(StringRef S) {
   size_t Pos = S.rfind('.');
   if (Pos == StringRef::npos)
     return 65536;
   int V;

lld/ELF/SyntheticSections.h

public:
   bool HasGotOffRel = false;
 
 protected:
   size_t NumEntries = 0;
   uint32_t TlsIndexOff = -1;
   uint64_t Size = 0;
 };
 
 // .note.gnu.build-id section.
 class BuildIdSection : public SyntheticSection {
   // First 16 bytes are a header.
   static const unsigned HeaderSize = 16;
 
 public:
   BuildIdSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return HeaderSize + HashSize; }
public:
   InputSection *getTargetInputSection() const;
 
 private:
   std::vector<const Thunk *> Thunks;
   size_t Size = 0;
 };
 
 template <class ELFT> void createCommonSections();
+InputSection *createInitFiniSection(InputSection *Sec);
 InputSection *createInterpSection();
 template <class ELFT> MergeInputSection *createCommentSection();
 void decompressSections();
 void mergeSections();
 
 SymbolBody *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
                               uint64_t Size, InputSectionBase *Section);
 

lld/ELF/SyntheticSections.cpp

for (Symbol *S : Symtab->getSymbols()) {
     // Replace all DefinedCommon symbols with DefinedRegular symbols so that we
     // don't have to care about DefinedCommon symbols beyond this point.
     replaceBody<DefinedRegular>(S, Sym->getFile(), Sym->getName(),
                                 static_cast<bool>(Sym->isLocal()), Sym->StOther,
                                 Sym->Type, 0, Sym->getSize<ELFT>(), Section);
   }
 }
 
+template <class T> static void reverseCopy(uint8_t *To, ArrayRef<T> From) {
+  T *Buf = (T *)To;
+  for (const T &Data : llvm::reverse(From))
+    *Buf++ = Data;
+}
+
+// Returns an .{init,fini}_array section name for a given .ctors/.dtors
+// section name. For example, it return ".init_array" for ".ctor" and
+// ".init_array.10000" for ".ctors.55535".
+//
+// Section names may include priorities, e.g. .ctors.30 or .init_array.101.
+// .ctors.65535 is the highest priority while .init_array.0 is the highest.
+// So we need to translate the number.
+static StringRef toInitFiniName(StringRef S) {
+  if (S == ".ctors")
+    return ".init_array";
+  if (S == ".dtors")
+    return ".fini_array";
+
+  if (S.startswith(".ctors.")) {
+    int N = 0;
+    to_integer(S.substr(7), N, 10);
+    return Saver.save(".init_array." + Twine(65535 - N));
+  }
+
+  if (S.startswith(".dtors.")) {
+    int N = 0;
+    to_integer(S.substr(7), N, 10);
+    return Saver.save(".fini_array." + Twine(65535 - N));
+  }
+
+  llvm_unreachable("unexpected section name");
+}
+
+// Create an .{init,fini}_array section from a given .ctors/.dtors section.
+//
+// Both types of sections are to call constructors or destructors of
+// global objects. .{init,fini}_array are newer, and in most systems,
+// they are used exclusively. However, there are still old object files
+// out there that contain .ctors/.dtors, so we want to handle them by
+// converting them to .init/fini.
+InputSection *elf::createInitFiniSection(InputSection *Sec) {
+  auto *Contents = make<std::vector<uint8_t>>(Sec->Data.size());
+  if (Config->Is64)
+    reverseCopy(Contents->data(), Sec->getDataAs<uint64_t>());
+  else
+    reverseCopy(Contents->data(), Sec->getDataAs<uint32_t>());
+
+  uint32_t Type =
+      Sec->Name.startswith(".ctors") ? SHT_INIT_ARRAY : SHT_FINI_ARRAY;
+
+  auto *Ret = make<InputSection>(SHF_ALLOC, Type, Config->Wordsize, *Contents,
+                                 toInitFiniName(Sec->Name));
+  Ret->Live = true;
+  return Ret;
+}
+
 // Returns an LLD version string.
 static ArrayRef<uint8_t> getVersion() {
   // Check LLD_VERSION first for ease of testing.
   // You can get consitent output by using the environment variable.
   // This is only for testing.
   StringRef S = getenv("LLD_VERSION");
   if (S.empty())
     S = Saver.save(Twine("Linker: ") + getLLDVersion());

lld/ELF/Writer.cpp

llvm::erase_if(Phdrs, [&](const PhdrEntry *P) {
     if (!P->FirstSec)
       return true;
     uint64_t Size = P->LastSec->Addr + P->LastSec->Size - P->FirstSec->Addr;
     return Size == 0;
   });
 }
 
 template <class ELFT> static void combineEhFrameSections() {
   for (InputSectionBase *&S : InputSections) {
     EhInputSection *ES = dyn_cast<EhInputSection>(S);
     if (!ES || !ES->Live)
       continue;
 
     In<ELFT>::EhFrame->addSection(ES);
     S = nullptr;
   }
 
   std::vector<InputSectionBase *> &V = InputSections;
   V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
 }
 
+static void createInitFiniSections() {
+  for (size_t I = 0; I < InputSections.size(); ++I)
+    if (InputSection *Sec = dyn_cast<InputSection>(InputSections[I]))
+      if (Sec->Live)
+        if (Sec->Name == ".ctors" || Sec->Name.startswith(".ctors.") ||
+            Sec->Name == ".dtors" || Sec->Name.startswith(".dtors."))
+          InputSections[I] = createInitFiniSection(Sec);
+}
+
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   // Create linker-synthesized sections such as .got or .plt.
   // Such sections are of type input section.
   createSyntheticSections();
 
   if (!Config->Relocatable)
     combineEhFrameSections<ELFT>();
 
+  // Convert .ctors/.dtors sections to .{init,fini}_array sections, if exists.
+  createInitFiniSections();
+
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
   // Create output sections.
   if (Script->HasSectionsCommand) {
     // If linker script contains SECTIONS commands, let it create sections.
     Script->processSectionCommands();

 
 // Sort input sections by section name suffixes for
 // __attribute__((init_priority(N))).
 static void sortInitFini(OutputSection *Cmd) {
   if (Cmd)
     Cmd->sortInitFini();
 }
 
-// Sort input sections by the special rule for .ctors and .dtors.
-static void sortCtorsDtors(OutputSection *Cmd) {
-  if (Cmd)
-    Cmd->sortCtorsDtors();
-}
-
 // Sort input sections using the list provided by --symbol-ordering-file.
 static void sortBySymbolsOrder() {
   if (Config->SymbolOrderingFile.empty())
     return;
 
   // Sort sections by priority.
   DenseMap<SectionBase *, int> SectionOrder = buildSectionOrder();
   for (BaseCommand *Base : Script->SectionCommands)
template <class ELFT> void Writer<ELFT>::createSections() {
 
   Script->SectionCommands.insert(Script->SectionCommands.begin(), Vec.begin(),
                                  Vec.end());
 
   Script->fabricateDefaultCommands();
   sortBySymbolsOrder();
   sortInitFini(findSection(".init_array"));
   sortInitFini(findSection(".fini_array"));
-  sortCtorsDtors(findSection(".ctors"));
-  sortCtorsDtors(findSection(".dtors"));
 }
 
 // This function generates assignments for predefined symbols (e.g. _end or
 // _etext) and inserts them into the commands sequence to be processed at the
 // appropriate time. This ensures that the value is going to be correct by the
 // time any references to these symbols are processed and is equivalent to
 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {

lld/test/ELF/ctors_dtors_priority.s

.section .dtors.100, "aw", @progbits
   .quad 0x12
 .section .dtors.005, "aw", @progbits
   .quad 0x13
 .section .dtors, "aw", @progbits
   .quad 0x14
 .section .dtors, "aw", @progbits
   .quad 0x15
 
-// CHECK:      Contents of section .ctors:
-// CHECK-NEXT: 202000 a1000000 00000000 01000000 00000000
-// CHECK-NEXT: 202010 04000000 00000000 05000000 00000000
-// CHECK-NEXT: 202020 b1000000 00000000 03000000 00000000
-// CHECK-NEXT: 202030 02000000 00000000 c1000000 00000000
-
-// CHECK:      Contents of section .dtors:
-// CHECK-NEXT: 202040 a2000000 00000000 11000000 00000000
-// CHECK-NEXT: 202050 14000000 00000000 15000000 00000000
-// CHECK-NEXT: 202060 b2000000 00000000 13000000 00000000
-// CHECK-NEXT: 202070 12000000 00000000 c2000000 00000000
+// CHECK:      Contents of section .init_array:
+// CHECK-NEXT: 200120 02000000 00000000 03000000 00000000
+// CHECK-NEXT: 200130 05000000 00000000 04000000 00000000
+// CHECK-NEXT: 200140 01000000 00000000 b1000000 00000000
+// CHECK-NEXT: 200150 c1000000 00000000 a1000000 00000000
+// CHECK-NEXT: Contents of section .fini_array:
+// CHECK-NEXT: 200160 12000000 00000000 13000000 00000000
+// CHECK-NEXT: 200170 15000000 00000000 14000000 00000000
+// CHECK-NEXT: 200180 11000000 00000000 b2000000 00000000
+// CHECK-NEXT: 200190 c2000000 00000000 a2000000 00000000

lld/test/ELF/gc-sections.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %t2
 # RUN: llvm-readobj -sections -symbols %t2 | FileCheck -check-prefix=NOGC %s
 # RUN: ld.lld --gc-sections %t -o %t2
 # RUN: llvm-readobj -sections -symbols %t2 | FileCheck -check-prefix=GC1 %s
 # RUN: ld.lld --export-dynamic --gc-sections %t -o %t2
 # RUN: llvm-readobj -sections -symbols %t2 | FileCheck -check-prefix=GC2 %s
 
 # NOGC: Name: .eh_frame
 # NOGC: Name: .text
 # NOGC: Name: .init
 # NOGC: Name: .fini
-# NOGC: Name: .ctors
-# NOGC: Name: .dtors
 # NOGC: Name: .debug_pubtypes
 # NOGC: Name: .comment
 # NOGC: Name: a
 # NOGC: Name: b
 # NOGC: Name: c
 # NOGC: Name: x
 # NOGC: Name: y
 # NOGC: Name: d
 
 # GC1:     Name: .eh_frame
 # GC1:     Name: .text
 # GC1:     Name: .init
 # GC1:     Name: .fini
-# GC1:     Name: .ctors
-# GC1:     Name: .dtors
 # GC1:     Name: .debug_pubtypes
 # GC1:     Name: .comment
 # GC1:     Name: a
 # GC1:     Name: b
 # GC1:     Name: c
 # GC1-NOT: Name: x
 # GC1-NOT: Name: y
 # GC1-NOT: Name: d
 
 # GC2:     Name: .eh_frame
 # GC2:     Name: .text
 # GC2:     Name: .init
 # GC2:     Name: .fini
-# GC2:     Name: .ctors
-# GC2:     Name: .dtors
 # GC2:     Name: .debug_pubtypes
 # GC2:     Name: .comment
 # GC2:     Name: a
 # GC2:     Name: b
 # GC2:     Name: c
 # GC2-NOT: Name: x
 # GC2-NOT: Name: y
 # GC2:     Name: d