[lld-macho] Support synthesizing __TEXT,__init_offsets

[BertalanD]

Summary

This section stores 32-bit TEXT segment offsets of initializer
functions, and is used instead of mod_init_func when chained fixups
are enabled.

Storing the offsets lets us avoid needing to fix up the initializers.

[thakis]

Looks great!

lld/MachO/Driver.cpp

1110

Looks like ld64 also adds the arg to -init (we don't implement this flag yet, but should probably have a FIXME somewhere to add it to initOffsets once we do?)

1440

I wanted to ask if this is enabled by default at some output os version, but it looks like it's on by default if chained fixups are on, which are on by default at some output os version. So D132560 will also enable this, I imagine.

lld/MachO/MarkLive.cpp

280

Should we _not_ enqueue S_MOD_INIT_FUNC_POINTERS here if we're doing this transform, since initOffsets is what produces lifeness in that case?

…oh, I see, we don't even put S_MOD_INIT_FUNC_POINTERS sections into inputSections in that case, so this will never happen.

Should this loop assert(!config->emitInitOffsets || sectionType(isec->getFlags()) != S_MOD_INIT_FUNC_POINTERS) to make that more clear, maybe?

lld/MachO/Writer.cpp

1136

Very nit: I'd appreciate it if you could rename the existing two setup() methods to setUp() in a preparatory commit (just land, no need for review), and then call this new one setUp too. ("setup" is a noun, "to set up" is a verb, and methods are named after verbs.)

lld/test/MachO/init-offsets.s

16

Good test!

llvm/lib/MC/MCSectionMachO.cpp

65

I wanted to say something about this, but apparently it's local style in this file O_o

[BertalanD]

lld/MachO/Writer.cpp

1136

sgtm

llvm/lib/MC/MCSectionMachO.cpp

65

I'm considering adding a separate patch that cleans these up. Apparently it was uglified because some old GCC version didn't like implicitly converting a string literal to StringLiteral. (https://github.com/llvm/llvm-project/commit/a9df9414030f6cbec511a8cef941998a268b9c6e)

I assume we're way past the "apparently GCC still doesn't understand C++11" situation (at least since the required was bumped to C++17).

[BertalanD]

llvm/lib/MC/MCSectionMachO.cpp

65

And the FIXME part should be better described as "this section is synthesized by the linker, so the assembler does not need to know about it". That's a bit long for an inline comment though...

[thakis]

llvm/lib/MC/MCSectionMachO.cpp

65

/* linker-synthesized */ maybe?

[BertalanD]

Addressed review comments.

I'm going to wait with landing this until tomorrow in case someone wants to make some suggestions.

lld/MachO/Driver.cpp

1440

That's correct.

lld/MachO/Config.h

struct Configuration {
   bool printWhyLoad = false;
   bool searchDylibsFirst = false;
   bool saveTemps = false;
   bool adhocCodesign = false;
   bool emitFunctionStarts = false;
   bool emitBitcodeBundle = false;
   bool emitDataInCodeInfo = false;
   bool emitEncryptionInfo = false;
+  bool emitInitOffsets = false;
   bool timeTraceEnabled = false;
   bool dataConst = false;
   bool dedupLiterals = true;
   bool omitDebugInfo = false;
   bool warnDylibInstallName = false;
   bool ignoreOptimizationHints = false;
   bool forceExactCpuSubtypeMatch = false;
   uint32_t headerPad;

lld/MachO/Driver.cpp

for (const Section *section : file->sections) {
       // contrast, EH frames are handled like regular ConcatInputSections.)
       if (section->name == section_names::compactUnwind)
         continue;
       ConcatOutputSection *osec = nullptr;
       for (const Subsection &subsection : section->subsections) {
         if (auto *isec = dyn_cast<ConcatInputSection>(subsection.isec)) {
           if (isec->isCoalescedWeak())
             continue;
+          if (config->emitInitOffsets &&
+              sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS) {
+            in.initOffsets->addInput(isec);
+            continue;
+          }
           isec->outSecOff = inputOrder++;
           if (!osec)
             osec = ConcatOutputSection::getOrCreateForInput(isec);
           isec->parent = osec;
           inputSections.push_back(isec);
         } else if (auto *isec =
                        dyn_cast<CStringInputSection>(subsection.isec)) {
           if (isec->getName() == section_names::objcMethname) {
bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
   config->emitFunctionStarts =
       args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
   config->emitDataInCodeInfo =
       args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
+  config->emitInitOffsets = args.hasArg(OPT_init_offsets);
   config->icfLevel = getICFLevel(args);
   config->dedupLiterals =
       args.hasFlag(OPT_deduplicate_literals, OPT_icf_eq, false) ||
       config->icfLevel != ICFLevel::none;
   config->warnDylibInstallName = args.hasFlag(
       OPT_warn_dylib_install_name, OPT_no_warn_dylib_install_name, false);
   config->ignoreOptimizationHints = args.hasArg(OPT_ignore_optimization_hints);
   config->callGraphProfileSort = args.hasFlag(

lld/MachO/InputSection.h

 constexpr const char ehFrame[] = "__eh_frame";
 constexpr const char gccExceptTab[] = "__gcc_except_tab";
 constexpr const char export_[] = "__export";
 constexpr const char dataInCode[] = "__data_in_code";
 constexpr const char functionStarts[] = "__func_starts";
 constexpr const char got[] = "__got";
 constexpr const char header[] = "__mach_header";
 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
+constexpr const char initOffsets[] = "__init_offsets";
 constexpr const char const_[] = "__const";
 constexpr const char lazySymbolPtr[] = "__la_symbol_ptr";
 constexpr const char lazyBinding[] = "__lazy_binding";
 constexpr const char literals[] = "__literals";
 constexpr const char moduleInitFunc[] = "__mod_init_func";
 constexpr const char moduleTermFunc[] = "__mod_term_func";
 constexpr const char nonLazySymbolPtr[] = "__nl_symbol_ptr";
 constexpr const char objcCatList[] = "__objc_catlist";

lld/MachO/MarkLive.cpp

void markLive() {
   for (ConcatInputSection *isec : inputSections) {
     // Sections marked no_dead_strip
     if (isec->getFlags() & S_ATTR_NO_DEAD_STRIP) {
       marker->enqueue(isec, 0);
       continue;
     }
 
     // mod_init_funcs, mod_term_funcs sections
     if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
         sectionType(isec->getFlags()) == S_MOD_TERM_FUNC_POINTERS) {
+      assert(!config->emitInitOffsets ||
+             sectionType(isec->getFlags()) != S_MOD_INIT_FUNC_POINTERS);
       marker->enqueue(isec, 0);
       continue;
     }
   }
 
+  for (ConcatInputSection *isec : in.initOffsets->inputs())
+    marker->enqueue(isec, 0);
+
   marker->markTransitively();
 }
 
 } // namespace lld::macho

lld/MachO/Options.td

 def ignore_auto_link : Flag<["-"], "ignore_auto_link">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def ignore_optimization_hints : Flag<["-"], "ignore_optimization_hints">,
     HelpText<"Ignore Linker Optimization Hints">,
     Group<grp_undocumented>;
 def init_offsets : Flag<["-"], "init_offsets">,
-    HelpText<"This option is undocumented in ld64">,
-    Flags<[HelpHidden]>,
+    HelpText<"Store __TEXT segment offsets of static initializers">,
     Group<grp_undocumented>;
 def keep_dwarf_unwind : Flag<["-"], "keep_dwarf_unwind">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def no_keep_dwarf_unwind : Flag<["-"], "no_keep_dwarf_unwind">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,

lld/MachO/OutputSegment.cpp

return StringSwitch<int>(seg->name)
       .Default(seg->inputOrder);
 }
 
 static int sectionOrder(OutputSection *osec) {
   StringRef segname = osec->parent->name;
   // Sections are uniquely identified by their segment + section name.
   if (segname == segment_names::text) {
     return StringSwitch<int>(osec->name)
-        .Case(section_names::header, -4)
-        .Case(section_names::text, -3)
-        .Case(section_names::stubs, -2)
-        .Case(section_names::stubHelper, -1)
+        .Case(section_names::header, -5)
+        .Case(section_names::text, -4)
+        .Case(section_names::stubs, -3)
+        .Case(section_names::stubHelper, -2)
+        .Case(section_names::initOffsets, -1)
         .Case(section_names::unwindInfo, std::numeric_limits<int>::max() - 1)
         .Case(section_names::ehFrame, std::numeric_limits<int>::max())
         .Default(osec->inputOrder);
   } else if (segname == segment_names::data ||
              segname == segment_names::dataConst) {
     // For each thread spawned, dyld will initialize its TLVs by copying the
     // address range from the start of the first thread-local data section to
     // the end of the last one. We therefore arrange these sections contiguously

lld/MachO/Symbols.h

T *replaceSymbol(Symbol *s, ArgT &&...arg) {
   bool isUsedInRegularObj = s->isUsedInRegularObj;
   bool used = s->used;
   T *sym = new (s) T(std::forward<ArgT>(arg)...);
   sym->isUsedInRegularObj |= isUsedInRegularObj;
   sym->used |= used;
   return sym;
 }
 
+// Can a symbol's address only be resolved at runtime?
+inline bool needsBinding(const Symbol *sym) {
+  if (isa<DylibSymbol>(sym))
+    return true;
+  if (const auto *defined = dyn_cast<Defined>(sym))
+    return defined->isExternalWeakDef() || defined->interposable;
+  return false;
+}
 } // namespace macho
 
 std::string toString(const macho::Symbol &);
 std::string toMachOString(const llvm::object::Archive::Symbol &);
 
 } // namespace lld
 
 #endif

lld/MachO/SyntheticSections.h

private:
   struct ImageInfo {
     uint8_t swiftVersion = 0;
     bool hasCategoryClassProperties = false;
   } info;
   static ImageInfo parseImageInfo(const InputFile *);
   std::vector<const InputFile *> files; // files with image info
 };
 
+// This section stores 32-bit __TEXT segment offsets of initializer functions.
+//
+// The compiler stores pointers to initializers in __mod_init_func. These need
+// to be fixed up at load time, which takes time and dirties memory. By
+// synthesizing InitOffsetsSection from them, this data can live in the
+// read-only __TEXT segment instead. This section is used by default when
+// chained fixups are enabled.
+//
+// There is no similar counterpart to __mod_term_func, as that section is
+// deprecated, and static destructors are instead handled by registering them
+// via __cxa_atexit from an autogenerated initializer function (see D121736).
+class InitOffsetsSection final : public SyntheticSection {
+public:
+  InitOffsetsSection();
+  bool isNeeded() const override { return !sections.empty(); }
+  uint64_t getSize() const override;
+  void writeTo(uint8_t *buf) const override;
+  void setUp();
+
+  void addInput(ConcatInputSection *isec) { sections.push_back(isec); }
+  const std::vector<ConcatInputSection *> &inputs() const { return sections; }
+
+private:
+  std::vector<ConcatInputSection *> sections;
+};
+
 struct InStruct {
   const uint8_t *bufferStart = nullptr;
   MachHeaderSection *header = nullptr;
   CStringSection *cStringSection = nullptr;
   DeduplicatedCStringSection *objcMethnameSection = nullptr;
   WordLiteralSection *wordLiteralSection = nullptr;
   RebaseSection *rebase = nullptr;
   BindingSection *binding = nullptr;
   WeakBindingSection *weakBinding = nullptr;
   LazyBindingSection *lazyBinding = nullptr;
   ExportSection *exports = nullptr;
   GotSection *got = nullptr;
   TlvPointerSection *tlvPointers = nullptr;
   LazyPointerSection *lazyPointers = nullptr;
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   ObjCStubsSection *objcStubs = nullptr;
   ConcatInputSection *objcSelrefs = nullptr;
   UnwindInfoSection *unwindInfo = nullptr;
   ObjCImageInfoSection *objCImageInfo = nullptr;
   ConcatInputSection *imageLoaderCache = nullptr;
+  InitOffsetsSection *initOffsets = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 void createSyntheticSymbols();
 
 } // namespace lld::macho
 
 #endif

lld/MachO/SyntheticSections.cpp

 }
 
 void ObjCImageInfoSection::writeTo(uint8_t *buf) const {
   uint32_t flags = info.hasCategoryClassProperties ? 0x40 : 0x0;
   flags |= info.swiftVersion << 8;
   write32le(buf + 4, flags);
 }
 
+InitOffsetsSection::InitOffsetsSection()
+    : SyntheticSection(segment_names::text, section_names::initOffsets) {
+  flags = S_INIT_FUNC_OFFSETS;
+}
+
+uint64_t InitOffsetsSection::getSize() const {
+  size_t count = 0;
+  for (const ConcatInputSection *isec : sections)
+    count += isec->relocs.size();
+  return count * sizeof(uint32_t);
+}
+
+void InitOffsetsSection::writeTo(uint8_t *buf) const {
+  uint64_t textVA = 0;
+  for (const OutputSegment *oseg : outputSegments)
+    if (oseg->name == segment_names::text) {
+      textVA = oseg->addr;
+      break;
+    }
+
+  // FIXME: Add function specified by -init when that argument is implemented.
+  for (ConcatInputSection *isec : sections) {
+    for (const Reloc &rel : isec->relocs) {
+      const Symbol *referent = rel.referent.dyn_cast<Symbol *>();
+      assert(referent && "section relocation should have been rejected");
+      uint64_t offset = referent->getVA() - textVA;
+      // FIXME: Can we handle this gracefully?
+      if (offset > UINT32_MAX)
+        fatal(isec->getLocation(rel.offset) + ": offset to initializer " +
+              referent->getName() + " (" + utohexstr(offset) +
+              ") does not fit in 32 bits");
+
+      // Entries need to be added in the order they appear in the section, but
+      // relocations aren't guaranteed to be sorted.
+      size_t index = rel.offset >> target->p2WordSize;
+      write32le(&buf[index * sizeof(uint32_t)], offset);
+    }
+    buf += isec->relocs.size() * sizeof(uint32_t);
+  }
+}
+
+// The inputs are __mod_init_func sections, which contain pointers to
+// initializer functions, therefore all relocations should be of the UNSIGNED
+// type. InitOffsetsSection stores offsets, so if the initializer's address is
+// not known at link time, stub-indirection has to be used.
+void InitOffsetsSection::setUp() {
+  for (const ConcatInputSection *isec : sections) {
+    for (const Reloc &rel : isec->relocs) {
+      RelocAttrs attrs = target->getRelocAttrs(rel.type);
+      if (!attrs.hasAttr(RelocAttrBits::UNSIGNED))
+        error(isec->getLocation(rel.offset) +
+              ": unsupported relocation type: " + attrs.name);
+      if (rel.addend != 0)
+        error(isec->getLocation(rel.offset) +
+              ": relocation addend is not representable in __init_offsets");
+      if (rel.referent.is<InputSection *>())
+        error(isec->getLocation(rel.offset) +
+              ": unexpected section relocation");
+
+      Symbol *sym = rel.referent.dyn_cast<Symbol *>();
+      if (auto *undefined = dyn_cast<Undefined>(sym))
+        treatUndefinedSymbol(*undefined, isec, rel.offset);
+      if (needsBinding(sym))
+        in.stubs->addEntry(sym);
+    }
+  }
+}
+
 void macho::createSyntheticSymbols() {
   auto addHeaderSymbol = [](const char *name) {
     symtab->addSynthetic(name, in.header->isec, /*value=*/0,
                          /*isPrivateExtern=*/true, /*includeInSymtab=*/false,
                          /*referencedDynamically=*/false);
   };
 
   switch (config->outputType) {

lld/MachO/Writer.cpp

void Writer::treatSpecialUndefineds() {
   for (const CachedHashStringRef &cachedName :
        config->exportedSymbols.literals) {
     if (const Symbol *sym = symtab->find(cachedName))
       if (const auto *undefined = dyn_cast<Undefined>(sym))
         treatUndefinedSymbol(*undefined, "-exported_symbol(s_list)");
   }
 }
 
-// Can a symbol's address can only be resolved at runtime?
-static bool needsBinding(const Symbol *sym) {
-  if (isa<DylibSymbol>(sym))
-    return true;
-  if (const auto *defined = dyn_cast<Defined>(sym))
-    return defined->isExternalWeakDef() || defined->interposable;
-  return false;
-}
-
 static void prepareSymbolRelocation(Symbol *sym, const InputSection *isec,
                                     const lld::macho::Reloc &r) {
   assert(sym->isLive());
   const RelocAttrs &relocAttrs = target->getRelocAttrs(r.type);
 
   if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     if (needsBinding(sym))
       in.stubs->addEntry(sym);
template <class LP> void Writer::run() {
 
   // Canonicalization of all pointers to InputSections should be handled by
   // these two scan* methods. I.e. from this point onward, for all live
   // InputSections, we should have `isec->canonical() == isec`.
   scanSymbols();
   if (in.objcStubs->isNeeded())
     in.objcStubs->setUp();
   scanRelocations();
+  if (in.initOffsets->isNeeded())
+    in.initOffsets->setUp();
 
   // Do not proceed if there was an undefined symbol.
   reportPendingUndefinedSymbols();
   if (errorCount())
     return;
 
   if (in.stubHelper->isNeeded())
     in.stubHelper->setUp();
void macho::createSyntheticSections() {
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.objcStubs = make<ObjCStubsSection>();
   in.unwindInfo = makeUnwindInfoSection();
   in.objCImageInfo = make<ObjCImageInfoSection>();
+  in.initOffsets = make<InitOffsetsSection>();
 
   // This section contains space for just a single word, and will be used by
   // dyld to cache an address to the image loader it uses.
   uint8_t *arr = bAlloc().Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   in.imageLoaderCache = makeSyntheticInputSection(
       segment_names::data, section_names::data, S_REGULAR,
       ArrayRef<uint8_t>{arr, target->wordSize},

lld/test/MachO/init-offsets.s

+# REQUIRES: x86
+# RUN: rm -rf %t; split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/first.s -o %t/first.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/second.s -o %t/second.o
+
+# RUN: %lld -lSystem -init_offsets -undefined dynamic_lookup  %t/first.o %t/second.o -o %t/out
+# RUN: llvm-otool -lv %t/out | FileCheck --check-prefix=FLAGS --implicit-check-not=__mod_init_func %s
+# RUN: llvm-otool -l %t/out > %t/dump.txt
+# RUN: llvm-objdump --macho --print-imm-hex --section=__TEXT,__stubs %t/out >> %t/dump.txt
+# RUN: llvm-objdump --macho --syms %t/out >> %t/dump.txt
+# RUN: llvm-objcopy --dump-section=__TEXT,__init_offsets=%t/section.bin %t/out
+# RUN: echo "__TEXT,__init_offsets contents:" >> %t/dump.txt
+# RUN: od -An -txI %t/section.bin >> %t/dump.txt
+# RUN: FileCheck --check-prefix=CONTENT %s < %t/dump.txt
+
+## This test checks that:
+## - __mod_init_func is replaced by __init_offsets.
+## - __mod_init_func has type S_INIT_FUNC_OFFSETS.
+## - initializers show up in the order their parent objects are specified on the
+##   command line, and in the order they show up within __mod_init_func.
+## - for undefined and dylib symbols, stubs are created, and the offsets point to those.
+## - offsets are relative to __TEXT's address, they aren't an absolute virtual address.
+
+# FLAGS:      sectname __init_offsets
+# FLAGS-NEXT:  segname __TEXT
+# FLAGS-NEXT:     addr
+# FLAGS-NEXT:     size 0x0000000000000010
+# FLAGS-NEXT:   offset
+# FLAGS-NEXT:    align
+# FLAGS-NEXT:   reloff 0
+# FLAGS-NEXT:   nreloc 0
+# FLAGS-NEXT:     type S_INIT_FUNC_OFFSETS
+
+# CONTENT:      segname __TEXT
+# CONTENT-NEXT: 0x[[#%x, TEXT:]]
+
+# CONTENT:      Contents of (__TEXT,__stubs) section
+# CONTENT-NEXT: [[#%x, ISNAN:]]: {{.*}} ## literal pool symbol address: ___isnan
+# CONTENT-NEXT: [[#%x, UNDEF:]]: {{.*}} ## literal pool symbol address: _undefined
+
+# CONTENT: SYMBOL TABLE:
+# CONTENT: [[#%x, FIRST:]]  g F __TEXT,__text _first_init
+# CONTENT: [[#%x, SECOND:]] g F __TEXT,__text _second_init
+
+# CONTENT: __TEXT,__init_offsets contents:
+# CONTENT: [[#%.8x, FIRST - TEXT]] [[#%.8x, ISNAN - TEXT]] [[#%.8x, UNDEF - TEXT]] [[#%.8x, SECOND - TEXT]]
+
+#--- first.s
+.globl _first_init, ___isnan, _main
+.text
+_first_init:
+  ret
+_main:
+  ret
+
+.section __DATA,__mod_init_func,mod_init_funcs
+.quad _first_init
+.quad ___isnan
+
+.subsections_via_symbols
+
+#--- second.s
+.globl _second_init, _undefined
+.text
+_second_init:
+  ret
+
+.section __DATA,__mod_init_func,mod_init_funcs
+.quad _undefined
+.quad _second_init
+
+.subsections_via_symbols

llvm/include/llvm/BinaryFormat/MachO.h

enum SectionType : uint32_t {
   /// structure data.
   S_THREAD_LOCAL_VARIABLES = 0x13u,
   /// S_THREAD_LOCAL_VARIABLE_POINTERS - Section with pointers to thread
   /// local structures.
   S_THREAD_LOCAL_VARIABLE_POINTERS = 0x14u,
   /// S_THREAD_LOCAL_INIT_FUNCTION_POINTERS - Section with thread local
   /// variable initialization pointers to functions.
   S_THREAD_LOCAL_INIT_FUNCTION_POINTERS = 0x15u,
+  /// S_INIT_FUNC_OFFSETS - Section with 32-bit offsets to initializer
+  /// functions.
+  S_INIT_FUNC_OFFSETS = 0x16u,
 
-  LAST_KNOWN_SECTION_TYPE = S_THREAD_LOCAL_INIT_FUNCTION_POINTERS
+  LAST_KNOWN_SECTION_TYPE = S_INIT_FUNC_OFFSETS
 };
 
 enum : uint32_t {
   // Constant masks for the "flags[31:24]" field in llvm::MachO::section and
   // llvm::MachO::section_64 (mask "flags" with SECTION_ATTRIBUTES_USR)
 
   /// S_ATTR_PURE_INSTRUCTIONS - Section contains only true machine
   /// instructions.

llvm/lib/MC/MCSectionMachO.cpp

StringLiteral AssemblerName, EnumName;
     {StringLiteral("thread_local_zerofill"),
      StringLiteral("S_THREAD_LOCAL_ZEROFILL")}, // 0x12
     {StringLiteral("thread_local_variables"),
      StringLiteral("S_THREAD_LOCAL_VARIABLES")}, // 0x13
     {StringLiteral("thread_local_variable_pointers"),
      StringLiteral("S_THREAD_LOCAL_VARIABLE_POINTERS")}, // 0x14
     {StringLiteral("thread_local_init_function_pointers"),
      StringLiteral("S_THREAD_LOCAL_INIT_FUNCTION_POINTERS")}, // 0x15
+    {StringLiteral("") /* linker-synthesized */,
+     StringLiteral("S_INIT_FUNC_OFFSETS")}, // 0x16
 };
 
 /// SectionAttrDescriptors - This is an array of descriptors for section
 /// attributes.  Unlike the SectionTypeDescriptors, this is not directly indexed
 /// by attribute, instead it is searched.
 static constexpr struct {
   unsigned AttrFlag;
   StringLiteral AssemblerName, EnumName;

llvm/tools/llvm-objdump/MachODump.cpp

if (verbose) {
     else if (section_type == MachO::S_THREAD_LOCAL_ZEROFILL)
       outs() << " S_THREAD_LOCAL_ZEROFILL\n";
     else if (section_type == MachO::S_THREAD_LOCAL_VARIABLES)
       outs() << " S_THREAD_LOCAL_VARIABLES\n";
     else if (section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
       outs() << " S_THREAD_LOCAL_VARIABLE_POINTERS\n";
     else if (section_type == MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS)
       outs() << " S_THREAD_LOCAL_INIT_FUNCTION_POINTERS\n";
+    else if (section_type == MachO::S_INIT_FUNC_OFFSETS)
+      outs() << " S_INIT_FUNC_OFFSETS\n";
     else
       outs() << format("0x%08" PRIx32, section_type) << "\n";
     outs() << "attributes";
     uint32_t section_attributes = flags & MachO::SECTION_ATTRIBUTES;
     if (section_attributes & MachO::S_ATTR_PURE_INSTRUCTIONS)
       outs() << " PURE_INSTRUCTIONS";
     if (section_attributes & MachO::S_ATTR_NO_TOC)
       outs() << " NO_TOC";