[lld] Recommit for implementing --ctors-in-init-array

[ChuanqiXu]

Summary

This patch is mainly based on D45508. The main differences between this patch and D45508 are:

1. This patch simply renames the .ctors section and changes its type, instead of creating a new section. I did so since I find that the newly created section wouldn't be relocated since the relocation information is lost.
2. This patch reverse the contents of .ctors after relocation as the original author mentioned.

Test-Plan: check-lld

[MaskRay]

I don't think we need this gold specific option. We can use D91187.

If you don't want to write a full linker script, my linker script proposal solving such problems in a generic way: https://sourceware.org/bugzilla/show_bug.cgi?id=26404
(it may need new folks chiming in)

BTW: why do you still use the deprecated .ctors/.dtors?
The customers I need to serve use .ctors But I've been careful and try not adding this option in the upstream as it is not really useful to others.

[ChuanqiXu]

In D98409#2619879, @MaskRay wrote:

BTW: why do you still use the deprecated .ctors/.dtors?

Since me want to use split-stack, which is a feature dependent on libgcc.a. And the corresponding initialization section in libgcc.a uses .ctors. Here is the codes moreStack. They uses assembly directly. But lld don't combine .ctors into .init_array, which would cause segmentation fault due to uninitialized code.

In D98409#2619879, @MaskRay wrote:

I don't think we need this gold specific option. We can use D91187.

If you don't want to write a full linker script, my linker script proposal solving such problems in a generic way: https://sourceware.org/bugzilla/show_bug.cgi?id=26404
(it may need new folks chiming in)

I tried to use the linker scripts dumped from ld to solve my problems. But it seems like we can't do that directly. I am not very clear about the reason. I would give it a try to use the linker scripts you give.

The customers I need to serve use .ctors But I've been careful and try not adding this option in the upstream as it is not really useful to others.

We are trying to develop a basic library using split stack. And there would be other projects dependent on this library. So if we want to use linker scripts to solve this problem, maybe we need to add linker scripts to every projects uses this library. I am worrying if it is not so convenient.

[MaskRay]

In D98409#2621116, @ChuanqiXu wrote:

In D98409#2619879, @MaskRay wrote:

BTW: why do you still use the deprecated .ctors/.dtors?

Since me want to use split-stack, which is a feature dependent on libgcc.a. And the corresponding initialization section in libgcc.a uses .ctors. Here is the codes moreStack.

You can contribute a patch conditionally using .init_array if the target prefers SHT_INIT_ARRAY. They will assuredly accept such a patch.

They uses assembly directly. But lld don't combine .ctors into .init_array, which would cause segmentation fault due to uninitialized code.

Can you elaborate a bit why you use split-stack? As I understand it, gccgo and GoLLVM need split stack support. LLVM itself provides support for ARM and x86-64 (used by clang -fsplit-stack). As the article says, contiguous stack is the new technology, so I wonder whether you still want to invest in split stack.

In D98409#2619879, @MaskRay wrote:

I don't think we need this gold specific option. We can use D91187.

If you don't want to write a full linker script, my linker script proposal solving such problems in a generic way: https://sourceware.org/bugzilla/show_bug.cgi?id=26404
(it may need new folks chiming in)

I tried to use the linker scripts dumped from ld to solve my problems. But it seems like we can't do that directly. I am not very clear about the reason. I would give it a try to use the linker scripts you give.

The linker script fragment is the solution. We should not need the large chunk of code adding more legacy .ctors work.

You can chime in on https://sourceware.org/bugzilla/show_bug.cgi?id=26404 so that the work can be prioritized. With that generic solution, we can address various ad-hoc requests.

The customers I need to serve use .ctors But I've been careful and try not adding this option in the upstream as it is not really useful to others.

We are trying to develop a basic library using split stack. And there would be other projects dependent on this library. So if we want to use linker scripts to solve this problem, maybe we need to add linker scripts to every projects uses this library. I am worrying if it is not so convenient.

[ChuanqiXu]

In D98409#2621136, @MaskRay wrote:

You can contribute a patch conditionally using .init_array if the target prefers SHT_INIT_ARRAY. They will assuredly accept such a patch.

Thanks, I would give it a try.

Can you elaborate a bit why you use split-stack? As I understand it, gccgo and GoLLVM need split stack support. LLVM itself provides support for ARM and x86-64 (used by clang -fsplit-stack). As the article says, contiguous stack is the new technology, so I wonder whether you still want to invest in split stack.

We use stackful coroutines extensively and we met some stack overflow problems. If we change the default stack size directly, it may waste many spaces. So we want to know whether split stack would solve our problems. At least, the statistics is really tempting.

In D98409#2619879, @MaskRay wrote:

The linker script fragment is the solution. We should not need the large chunk of code adding more legacy .ctors work.

You can chime in on https://sourceware.org/bugzilla/show_bug.cgi?id=26404 so that the work can be prioritized. With that generic solution, we can address various ad-hoc requests.

Thanks for suggestion!

lld/ELF/Config.h

struct Configuration {
   bool armJ1J2BranchEncoding = false;
   bool asNeeded = false;
   bool bsymbolic;
   bool bsymbolicFunctions;
   bool callGraphProfileSort;
   bool checkSections;
   bool compressDebugSections;
   bool cref;
+  bool CtorsInInitArray;
   std::vector<std::pair<llvm::GlobPattern, uint64_t>> deadRelocInNonAlloc;
   bool defineCommon;
   bool demangle = true;
   bool dependentLibraries;
   bool disableVerify;
   bool ehFrameHdr;
   bool emitLLVM;
   bool emitRelocs;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->auxiliaryList = args::getStrings(args, OPT_auxiliary);
   config->bsymbolic = args.hasArg(OPT_Bsymbolic);
   config->bsymbolicFunctions = args.hasArg(OPT_Bsymbolic_functions);
   config->checkSections =
       args.hasFlag(OPT_check_sections, OPT_no_check_sections, true);
   config->chroot = args.getLastArgValue(OPT_chroot);
   config->compressDebugSections = getCompressDebugSections(args);
   config->cref = args.hasFlag(OPT_cref, OPT_no_cref, false);
+  config->CtorsInInitArray =
+    args.hasFlag(OPT_ctors_in_init_array, OPT_no_ctors_in_init_array, true);
   config->defineCommon = args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !args.hasArg(OPT_relocatable));
   config->optimizeBBJumps =
       args.hasFlag(OPT_optimize_bb_jumps, OPT_no_optimize_bb_jumps, false);
   config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   config->dependencyFile = args.getLastArgValue(OPT_dependency_file);
   config->dependentLibraries = args.hasFlag(OPT_dependent_libraries, OPT_no_dependent_libraries, true);
   config->disableVerify = args.hasArg(OPT_disable_verify);
   config->discard = getDiscard(args);
   config->dwoDir = args.getLastArgValue(OPT_plugin_opt_dwo_dir_eq);
   config->dynamicLinker = getDynamicLinker(args);
   config->ehFrameHdr =
       args.hasFlag(OPT_eh_frame_hdr, OPT_no_eh_frame_hdr, false);
   config->emitLLVM = args.hasArg(OPT_plugin_opt_emit_llvm, false);
   config->emitRelocs = args.hasArg(OPT_emit_relocs);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   config->enableNewDtags =
       args.hasFlag(OPT_enable_new_dtags, OPT_disable_new_dtags, true);
   config->entry = args.getLastArgValue(OPT_entry);
 
   errorHandler().errorHandlingScript =
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // into synthetic sections. Do that now so that they aren't assigned to
   // output sections in the usual way.
   if (!config->relocatable)
     combineEhSections();
 
   {
     llvm::TimeTraceScope timeScope("Assign sections");
 
+    // Convert .[cd]tors to .{init,fini}_array if needed.
+    if (config->CtorsInInitArray)
+      createInitFiniSections<ELFT>();
+
     // Create output sections described by SECTIONS commands.
     script->processSectionCommands();
 
     // Linker scripts control how input sections are assigned to output
     // sections. Input sections that were not handled by scripts are called
     // "orphans", and they are assigned to output sections by the default rule.
     // Process that.
     script->addOrphanSections();

lld/ELF/InputSection.h

 
 inline bool isDebugSection(const InputSectionBase &sec) {
   return (sec.flags & llvm::ELF::SHF_ALLOC) == 0 &&
          (sec.name.startswith(".debug") || sec.name.startswith(".zdebug"));
 }
 
 // The list of all input sections.
 extern std::vector<InputSectionBase *> inputSections;
+extern llvm::DenseSet<InputSectionBase *> ctorsInInitArraySection;
 
 // The set of TOC entries (.toc + addend) for which we should not apply
 // toc-indirect to toc-relative relaxation. const Symbol * refers to the
 // STT_SECTION symbol associated to the .toc input section.
 extern llvm::DenseSet<std::pair<const Symbol *, uint64_t>> ppc64noTocRelax;
 
 } // namespace elf
 
 std::string toString(const elf::InputSectionBase *);
 } // namespace lld
 
 #endif

lld/ELF/InputSection.cpp

 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::elf;
 
 std::vector<InputSectionBase *> elf::inputSections;
+llvm::DenseSet<InputSectionBase *> elf::ctorsInInitArraySection;
 DenseSet<std::pair<const Symbol *, uint64_t>> elf::ppc64noTocRelax;
 
 // Returns a string to construct an error message.
 std::string lld::toString(const InputSectionBase *sec) {
   return (toString(sec->file) + ":(" + sec->name + ")").str();
 }
 
 template <class ELFT>
template <class ELFT> void InputSection::writeTo(uint8_t *buf) {
   if (uncompressedSize >= 0) {
     size_t size = uncompressedSize;
     if (Error e = zlib::uncompress(toStringRef(rawData),
                                    (char *)(buf + outSecOff), size))
       fatal(toString(this) +
             ": uncompress failed: " + llvm::toString(std::move(e)));
     uint8_t *bufEnd = buf + outSecOff + size;
     relocate<ELFT>(buf + outSecOff, bufEnd);
-    return;
-  }
-
+  } else {
     // Copy section contents from source object file to output file
     // and then apply relocations.
     memcpy(buf + outSecOff, data().data(), data().size());
     uint8_t *bufEnd = buf + outSecOff + data().size();
     relocate<ELFT>(buf + outSecOff, bufEnd);
   }
 
+  // A .[cd]tors section contains function pointers that are executed at
+  // runtime from the last one to the first one. .{init,fini}_array also
+  // contains function pointers, but the order the runtime calls them is the
+  // opposite. So, when we convert a .[cd]tors to .{init,fini}_array, we need
+  // to reverse the contents.
+  if (ctorsInInitArraySection.find(this) != ctorsInInitArraySection.end()) {
+    auto size = data().size();
+    if (config->is64) {
+      MutableArrayRef<uint64_t> data = makeMutableArrayRef<uint64_t>(
+        (uint64_t*)(buf + outSecOff), size/sizeof(uint64_t));
+      std::reverse(data.begin(), data.end());
+    } else {
+      MutableArrayRef<uint32_t> data = makeMutableArrayRef<uint32_t>(
+        (uint32_t*)(buf + outSecOff), size /sizeof(uint32_t));
+      std::reverse(data.begin(), data.end());
+    }
+  }
+}
+
 void InputSection::replace(InputSection *other) {
   alignment = std::max(alignment, other->alignment);
 
   // When a section is replaced with another section that was allocated to
   // another partition, the replacement section (and its associated sections)
   // need to be placed in the main partition so that both partitions will be
   // able to access it.
   if (partition != other->partition) {

lld/ELF/Options.td

 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics (default: auto)">,
   MetaVarName<"[auto,always,never]">;
 
 defm cref: B<"cref",
     "Output cross reference table",
     "Do not output cross reference table">;
 
+defm ctors_in_init_array: B<"ctors-in-init-array",
+    "Merge .ctors/.dtors with .init_array/.fini_array",
+    "Do not merge .ctors/.dtors with .init_array/.fini_array">;
+
 defm define_common: B<"define-common",
     "Assign space to common symbols",
     "Do not assign space to common symbols">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names (default)",
     "Do not demangle symbol names">;
 

 def plugin_opt_eq : J<"plugin-opt=">;
 
 // Options listed below are silently ignored for now for compatibility.
 def: F<"detect-odr-violations">;
 def: Flag<["-"], "g">;
 def: F<"long-plt">;
 def: F<"no-add-needed">;
 def: F<"no-copy-dt-needed-entries">;
-def: F<"no-ctors-in-init-array">;
 def: F<"no-keep-memory">;
 def: F<"no-pipeline-knowledge">;
 def: F<"no-relax">;
 def: F<"no-warn-mismatch">;
 def: Flag<["-"], "p">;
 def: Separate<["--", "-"], "rpath-link">;
 def: J<"rpath-link=">;
 def: F<"secure-plt">;

lld/ELF/OutputSections.h

public:
   void finalize();
   template <class ELFT> void writeTo(uint8_t *buf);
   template <class ELFT> void maybeCompress();
 
   void sort(llvm::function_ref<int(InputSectionBase *s)> order);
   void sortInitFini();
   void sortCtorsDtors();
 
-private:
+public:
   // Used for implementation of --compress-debug-sections option.
   std::vector<uint8_t> zDebugHeader;
   llvm::SmallVector<char, 0> compressedData;
 
   std::array<uint8_t, 4> getFiller();
 };
 
 int getPriority(StringRef s);
+bool isCrtbegin(StringRef s);
+bool isCrtend(StringRef s);
 
 InputSection *getFirstInputSection(const OutputSection *os);
 std::vector<InputSection *> getInputSections(const OutputSection *os);
 
 // All output sections that are handled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 struct Out {

lld/ELF/OutputSections.cpp

 }
 
 // Returns true if S is in one of the many forms the compiler driver may pass
 // crtbegin files.
 //
 // Gcc uses any of crtbegin[<empty>|S|T].o.
 // Clang uses Gcc's plus clang_rt.crtbegin[<empty>|S|T][-<arch>|<empty>].o.
 
-static bool isCrtbegin(StringRef s) {
+bool elf::isCrtbegin(StringRef s) {
   static std::regex re(R"((clang_rt\.)?crtbegin[ST]?(-.*)?\.o)");
   s = sys::path::filename(s);
   return std::regex_match(s.begin(), s.end(), re);
 }
 
-static bool isCrtend(StringRef s) {
+bool elf::isCrtend(StringRef s) {
   static std::regex re(R"((clang_rt\.)?crtend[ST]?(-.*)?\.o)");
   s = sys::path::filename(s);
   return std::regex_match(s.begin(), s.end(), re);
 }
 
 // .ctors and .dtors are sorted by this order:
 //
 // 1. .ctors/.dtors in crtbegin (which contains a sentinel value -1).

lld/ELF/SyntheticSections.h

public:
   void finalizeContents() override;
   void writeTo(uint8_t *buf) override;
 };
 
 InputSection *createInterpSection();
 MergeInputSection *createCommentSection();
 MergeSyntheticSection *createMergeSynthetic(StringRef name, uint32_t type,
                                             uint64_t flags, uint32_t alignment);
+InputSection *createInitFiniSection(InputSection *Sec);
 template <class ELFT> void splitSections();
 
 template <typename ELFT> void writeEhdr(uint8_t *buf, Partition &part);
 template <typename ELFT> void writePhdrs(uint8_t *buf, Partition &part);
 
 Defined *addSyntheticLocal(StringRef name, uint8_t type, uint64_t value,
                            uint64_t size, InputSectionBase &section);
 

lld/ELF/SyntheticSections.cpp

 // With this feature, you can identify LLD-generated binaries easily
 // by "readelf --string-dump .comment <file>".
 // The returned object is a mergeable string section.
 MergeInputSection *elf::createCommentSection() {
   return make<MergeInputSection>(SHF_MERGE | SHF_STRINGS, SHT_PROGBITS, 1,
                                  getVersion(), ".comment");
 }
 
+// Returns an .{init,fini}_array section name for a given .ctors/.dtors
+// section name. For example, it returns ".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) {
+  // .ctors without any priority should have the lowest priority (i.e. the
+  // greatest number) than any .init_array, so priority 65537 is assigned.
+  if (S == ".ctors")
+    return ".init_array.65537";
+  if (S == ".dtors")
+    return ".fini_array.65537";
+
+  assert(S.startswith(".ctors.") || S.startswith(".dtors."));
+  StringRef Prefix = S.startswith(".c") ? ".init_array." : ".fini_array.";
+
+  uint16_t N = 0;
+  if (!to_integer(S.substr(7), N, 10))
+    return S;
+  auto *Outs = make<llvm::SmallString<16>>();
+  return Twine(Prefix + Twine(65535 - N)).toStringRef(*Outs);
+}
+
+// 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 need to handle them by
+// converting them to .init/fini.
+InputSection *elf::createInitFiniSection(InputSection *Sec) {
+  uint32_t Type =
+      Sec->name.startswith(".ctors") ? SHT_INIT_ARRAY : SHT_FINI_ARRAY;
+  Sec->type = Type;
+  Sec->name = toInitFiniName(Sec->name);
+  return Sec;
+}
+
 // .MIPS.abiflags section.
 template <class ELFT>
 MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(Elf_Mips_ABIFlags flags)
     : SyntheticSection(SHF_ALLOC, SHT_MIPS_ABIFLAGS, 8, ".MIPS.abiflags"),
       flags(flags) {
   this->entsize = sizeof(Elf_Mips_ABIFlags);
 }
 

lld/ELF/Writer.h

 
 namespace lld {
 namespace elf {
 class InputFile;
 class OutputSection;
 class InputSectionBase;
 void copySectionsIntoPartitions();
 template <class ELFT> void createSyntheticSections();
+template <class ELFT> void createInitFiniSections();
 void combineEhSections();
 template <class ELFT> void writeResult();
 
 // This describes a program header entry.
 // Each contains type, access flags and range of output sections that will be
 // placed in it.
 struct PhdrEntry {
   PhdrEntry(unsigned type, unsigned flags)

lld/ELF/Writer.cpp

if (in.symTab)
     add(in.symTab);
   if (in.symTabShndx)
     add(in.symTabShndx);
   add(in.shStrTab);
   if (in.strTab)
     add(in.strTab);
 }
 
+// Replace .[cd]tors sections with .{init,fini}_array sections.
+template <class ELFT>
+void elf::createInitFiniSections() {
+  for (size_t I = 0; I < inputSections.size(); ++I) {
+    InputSection *Sec = dyn_cast<InputSection>(inputSections[I]);
+    if (!Sec || !Sec->isLive())
+      continue;
+
+    if (Sec->name != ".ctors" && !Sec->name.startswith(".ctors.") &&
+        Sec->name != ".dtors" && !Sec->name.startswith(".dtors.")) {
+      continue;
+    }
+
+    // As a special rule, .[cd]tors sections in crtbeginS.o or crtendS.o
+    // shouldn't be converted because the runtime expect them to be in the
+    // original section. This is ugly, but without this, the resulting
+    // exectuable would crash on startup.
+    if (Sec->name == ".ctors" || Sec->name == ".dtors") {
+      StringRef S = Sec->file->getName();
+      if (isCrtbegin(S) || isCrtend(S)) {
+        continue;
+      }
+    }
+
+    inputSections[I] = createInitFiniSection(Sec);
+    ctorsInInitArraySection.insert(inputSections[I]);
+  }
+}
+
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   copyLocalSymbols();
 
   if (config->copyRelocs)
     addSectionSymbols();
 
   // Now that we have a complete set of output sections. This function
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // sections. Run after in.symTab is finalized as optimizeBasicBlockJumps
   // can relax jump instructions based on symbol offset.
   if (config->optimizeBBJumps)
     optimizeBasicBlockJumps();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
-  for (OutputSection *sec : outputSections)
+  for (OutputSection *sec : outputSections) {
     sec->finalize();
   }
+}
 
 // Ensure data sections are not mixed with executable sections when
 // -execute-only is used. -execute-only is a feature to make pages executable
 // but not readable, and the feature is currently supported only on AArch64.
 template <class ELFT> void Writer<ELFT>::checkExecuteOnly() {
   if (!config->executeOnly)
     return;
 
for (Partition &part : partitions)
     part.buildId->writeBuildId(buildId);
 }
 
 template void elf::createSyntheticSections<ELF32LE>();
 template void elf::createSyntheticSections<ELF32BE>();
 template void elf::createSyntheticSections<ELF64LE>();
 template void elf::createSyntheticSections<ELF64BE>();
 
+template void elf::createInitFiniSections<ELF32LE>();
+template void elf::createInitFiniSections<ELF32BE>();
+template void elf::createInitFiniSections<ELF64LE>();
+template void elf::createInitFiniSections<ELF64BE>();
+
 template void elf::writeResult<ELF32LE>();
 template void elf::writeResult<ELF32BE>();
 template void elf::writeResult<ELF64LE>();
 template void elf::writeResult<ELF64BE>();

lld/test/ELF/ctors-in-init-array.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+
+# RUN: mkdir -p %t.dir
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+# RUN:   %p/Inputs/ctors_dtors_priority1.s -o %t.dir/crtbeginS.o
+
+# RUN: ld.lld %t.o %t.dir/crtbeginS.o -o %t1.exe
+# RUN: llvm-objdump -s %t1.exe | FileCheck %s
+
+# RUN: ld.lld %t.o %t.dir/crtbeginS.o -o %t2.exe --no-ctors-in-init-array
+# RUN: llvm-objdump -s %t2.exe | FileCheck -check-prefix=CTORS %s
+
+.globl _start
+_start:
+  nop
+
+.section .ctors, "aw", @progbits
+  .quad 8
+.section .ctors.100, "aw", @progbits
+  .quad 2
+.section .ctors.005, "aw", @progbits
+  .quad 3
+.section .ctors, "aw", @progbits
+  .quad 7
+.section .ctors, "aw", @progbits
+  .quad 6
+
+.section .init_array.1, "aw", @init_array
+  .quad 1
+.section .init_array.65535, "aw", @init_array
+  .quad 4
+.section .init_array, "aw", @init_array
+  .quad 5
+
+.section .dtors, "aw", @progbits
+  .quad 0x18
+.section .dtors.100, "aw", @progbits
+  .quad 0x12
+.section .dtors.005, "aw", @progbits
+  .quad 0x13
+.section .dtors, "aw", @progbits
+  .quad 0x17
+.section .dtors, "aw", @progbits
+  .quad 0x16
+
+.section .fini_array.1, "aw", @fini_array
+  .quad 0x11
+.section .fini_array.65535, "aw", @fini_array
+  .quad 0x14
+.section .fini_array, "aw", @fini_array
+  .quad 0x15
+
+# CHECK:      Contents of section .init_array:
+# CHECK-NEXT: 202194 01000000 00000000 02000000 00000000
+# CHECK-NEXT: 2021a4 03000000 00000000 04000000 00000000
+# CHECK-NEXT: 2021b4 05000000 00000000 06000000 00000000
+# CHECK-NEXT: 2021c4 07000000 00000000 08000000 00000000
+
+# CHECK:      Contents of section .fini_array:
+# CHECK-NEXT: 2021d4 11000000 00000000 12000000 00000000
+# CHECK-NEXT: 2021e4 13000000 00000000 14000000 00000000
+# CHECK-NEXT: 2021f4 15000000 00000000 16000000 00000000
+# CHECK-NEXT: 202204 17000000 00000000 18000000 00000000
+
+# CHECK:      Contents of section .ctors:
+# CHECK-NEXT: 202214 a1000000 00000000
+
+# CHECK:      Contents of section .dtors:
+# CHECK-NEXT: 20221c a2000000 00000000
+
+# CTORS:      Contents of section .ctors:
+# CTORS-NEXT: 202194 a1000000 00000000 08000000 00000000
+# CTORS-NEXT: 2021a4 07000000 00000000 06000000 00000000
+# CTORS-NEXT: 2021b4 03000000 00000000 02000000 00000000
+
+# CTORS:      Contents of section .init_array:
+# CTORS-NEXT: 2021c4 01000000 00000000 04000000 00000000
+# CTORS-NEXT: 2021d4 05000000 00000000
+
+# CTORS:      Contents of section .dtors:
+# CTORS-NEXT: 2021dc a2000000 00000000 18000000 00000000
+# CTORS-NEXT: 2021ec 17000000 00000000 16000000 00000000
+# CTORS-NEXT: 2021fc 13000000 00000000 12000000 00000000
+
+# CTORS:      Contents of section .fini_array:
+# CTORS-NEXT: 20220c 11000000 00000000 14000000 00000000
+# CTORS-NEXT: 20221c 15000000 00000000
 No newline at end of file

lld/test/ELF/ctors_dtors_priority.s

 // REQUIRES: x86
 
 // Test .ctors* and .dtors* are sorted by priority.
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 // RUN: mkdir -p %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/ctors_dtors_priority1.s -o %t/crtbegin.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/ctors_dtors_priority2.s -o %t2
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/ctors_dtors_priority3.s -o %t/crtend.o
-// RUN: ld.lld %t1 %t2 %t/crtend.o %t/crtbegin.o -o %t.exe
+// RUN: ld.lld --no-ctors-in-init-array %t1 %t2 %t/crtend.o %t/crtbegin.o -o %t.exe
 // RUN: llvm-objdump -s %t.exe | FileCheck %s
 
 // RUN: cp %t/crtbegin.o %t/clang_rt.crtbegin.o
 // RUN: cp %t/crtend.o %t/clang_rt.crtend.o
-// RUN: ld.lld %t1 %t2 %t/clang_rt.crtend.o %t/clang_rt.crtbegin.o -o %t.clang_rt.exe
+// RUN: ld.lld --no-ctors-in-init-array %t1 %t2 %t/clang_rt.crtend.o %t/clang_rt.crtbegin.o -o %t.clang_rt.exe
 // RUN: llvm-objdump -s %t.clang_rt.exe | FileCheck %s
 
 // RUN: cp %t/crtbegin.o %t/clang_rt.crtbegin-x86_64.o
 // RUN: cp %t/crtend.o %t/clang_rt.crtend-x86_64.o
-// RUN: ld.lld %t1 %t2 %t/clang_rt.crtend-x86_64.o %t/clang_rt.crtbegin-x86_64.o -o %t.clang_rt-arch.exe
+// RUN: ld.lld  --no-ctors-in-init-array %t1 %t2 %t/clang_rt.crtend-x86_64.o %t/clang_rt.crtbegin-x86_64.o -o %t.clang_rt-arch.exe
 // RUN: llvm-objdump -s %t.clang_rt-arch.exe | FileCheck %s
 
   
 .globl _start
 _start:
   nop
 
 .section .ctors, "aw", @progbits

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: ld.lld --no-ctors-in-init-array %t -o %t2
 # RUN: llvm-readobj --sections --symbols %t2 | FileCheck -check-prefix=NOGC %s
-# RUN: ld.lld --gc-sections %t -o %t2
+# RUN: ld.lld --no-ctors-in-init-array --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: ld.lld --no-ctors-in-init-array --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: .tdata
 # NOGC: Name: .tbss

lld/test/ELF/linkerscript/sort-init.s

 # REQUIRES: x86
 ## Test SORT_BY_INIT_PRIORITY can be used to convert .ctors into .init_array
 
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %t/asm -o %t.o
-# RUN: ld.lld -T %t/lds %t.o -o %t.out
+# RUN: ld.lld --no-ctors-in-init-array -T %t/lds %t.o -o %t.out
 # RUN: llvm-readelf -x .init_array %t.out | FileCheck %s
 
 # CHECK:      Hex dump of section '.init_array':
 # CHECK-NEXT: 0x00000001 00010203 04050607
 
 #--- asm
 .globl _start
 _start: