[lld/mac] Honor REFERENCED_DYAMICALLY, set it on __mh_execute_header

[thakis]

Summary

Has the effect that __mh_execute_header stays in the symbol table of
outputs even after running strip on the output. I don't know if that's
important for anything -- my motivation for the patch is just is to make
the output more similar to ld64.

(Corresponds to symbolTableInAndNeverStrip in ld64.)

[thakis]

lld/MachO/InputFiles.cpp

445

Turns out this isn't true, and http://llvm-cs.pcc.me.uk/lib/Support/PrettyStackTrace.cpp#121 does trigger this assert. I'll update.

[thakis]

handle on arbitrary symbols (via .desc, and used in PrettyStackTrace -- but see https://reviews.llvm.org/D27683#2763729 , seems a bit pointless)

This makes the patch quite a bit bigger (see diff to patch set 1) for unclear gain. Maybe we should do patch set 1 and just remove the assert for now? On the other hand, it seems like the correct behavior, so maybe we should just do it. The patch doesn't do this for Common and Absolute symbols; if anyone needs that they can add it themselves.

[int3]

lgtm, maintaining correct behavior seems worth the complexity

lld/MachO/InputFiles.cpp

493–497

Hmm I wonder if we should have Defined's ctor take in n_desc directly and then parses those flags. The list of params is getting a bit unwieldy

lld/MachO/SyntheticSections.cpp

859–860

nit: can we use a ternary like the other two lines above?

[thakis]

Thanks!

lld/MachO/InputFiles.cpp

493–497

That either splits up the isWeakDefCanBeHidden code a bit awkwardly. Mind if I punt on that for now?

lld/MachO/SyntheticSections.cpp

859–860

Sure, done. It's two lines either way, so I figured I could do the more obvious two lines. But local consistency is good too.

[int3]

lld/MachO/InputFiles.cpp

493–497

yeah we can figure it out in a future diff

lld/MachO/Driver.cpp

for (Symbol *sym : symtab->getSymbols()) {
     isec->data = {nullptr, static_cast<size_t>(common->size)};
     isec->flags = S_ZEROFILL;
     inputSections.push_back(isec);
 
     replaceSymbol<Defined>(sym, sym->getName(), isec->file, isec, /*value=*/0,
                            /*size=*/0,
                            /*isWeakDef=*/false,
                            /*isExternal=*/true, common->privateExtern,
-                           /*isThumb=*/false);
+                           /*isThumb=*/false,
+                           /*isReferencedDynamically=*/false);
   }
 }
 
 static void initializeSectionRenameMap() {
   if (config->dataConst) {
     SmallVector<StringRef> v{section_names::got,
                              section_names::authGot,
                              section_names::authPtr,

lld/MachO/InputFiles.cpp

 
 template <class NList>
 static macho::Symbol *createDefined(const NList &sym, StringRef name,
                                     InputSection *isec, uint64_t value,
                                     uint64_t size) {
   // Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
   // N_EXT: Global symbols. These go in the symbol table during the link,
   //        and also in the export table of the output so that the dynamic
   //        linker sees them.
   // N_EXT | N_PEXT: Linkage unit (think: dylib) scoped. These go in the
   //                 symbol table during the link so that duplicates are
   //                 either reported (for non-weak symbols) or merged
   //                 (for weak symbols), but they do not go in the export
   //                 table of the output.
   // N_PEXT: Does not occur in input files in practice,
   //         a private extern must be external.
   // 0: Translation-unit scoped. These are not in the symbol table during
if (sym.n_type & (N_EXT | N_PEXT)) {
     // definition will continue to take priority if more private extern
     // definitions are encountered. With lld's semantics there's no observable
     // difference between a symbol that's isWeakDefCanBeHidden or one that's
     // privateExtern -- neither makes it into the dynamic symbol table. So just
     // promote isWeakDefCanBeHidden to isPrivateExtern here.
     if (isWeakDefCanBeHidden)
       isPrivateExtern = true;
 
     return symtab->addDefined(name, isec->file, isec, value, size,
                               sym.n_desc & N_WEAK_DEF, isPrivateExtern,
-                              sym.n_desc & N_ARM_THUMB_DEF);
+                              sym.n_desc & N_ARM_THUMB_DEF,
+                              sym.n_desc & REFERENCED_DYNAMICALLY);
   }
 
   assert(!isWeakDefCanBeHidden &&
          "weak_def_can_be_hidden on already-hidden symbol?");
   return make<Defined>(name, isec->file, isec, value, size,
                        sym.n_desc & N_WEAK_DEF,
                        /*isExternal=*/false, /*isPrivateExtern=*/false,
-                       sym.n_desc & N_ARM_THUMB_DEF);
+                       sym.n_desc & N_ARM_THUMB_DEF,
+                       sym.n_desc & REFERENCED_DYNAMICALLY);
 }
 
 // Absolute symbols are defined symbols that do not have an associated
 // InputSection. They cannot be weak.
 template <class NList>
 static macho::Symbol *createAbsolute(const NList &sym, InputFile *file,
                                      StringRef name) {
   if (sym.n_type & (N_EXT | N_PEXT)) {
     assert((sym.n_type & N_EXT) && "invalid input");
     return symtab->addDefined(name, file, nullptr, sym.n_value, /*size=*/0,
                               /*isWeakDef=*/false, sym.n_type & N_PEXT,
-                              sym.n_desc & N_ARM_THUMB_DEF);
+                              sym.n_desc & N_ARM_THUMB_DEF,
+                              /*isReferencedDynamically=*/false);
   }
   return make<Defined>(name, file, nullptr, sym.n_value, /*size=*/0,
                        /*isWeakDef=*/false,
                        /*isExternal=*/false, /*isPrivateExtern=*/false,
-                       sym.n_desc & N_ARM_THUMB_DEF);
+                       sym.n_desc & N_ARM_THUMB_DEF,
+                       /*isReferencedDynamically=*/false);
 }
 
 template <class NList>
 macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
                                               StringRef name) {
   uint8_t type = sym.n_type & N_TYPE;
   switch (type) {
   case N_UNDF:
case GlobalValue::ProtectedVisibility:
     error(name + " has protected visibility, which is not supported by Mach-O");
     break;
   case GlobalValue::DefaultVisibility:
     break;
   }
 
   return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
                             /*size=*/0, objSym.isWeak(), isPrivateExtern,
-                            /*isThumb=*/false);
+                            /*isThumb=*/false,
+                            /*isReferencedDynamically=*/false);
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
     : InputFile(BitcodeKind, mbref) {
   obj = check(lto::InputFile::create(mbref));
 
   // Convert LTO Symbols to LLD Symbols in order to perform resolution. The
   // "winning" symbol will then be marked as Prevailing at LTO compilation
   // time.
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(objSym, *this));
 }
 
 template void ObjFile::parse<LP64>();

lld/MachO/MergedOutputSection.cpp

for (Reloc &r : reverse(relocs)) {
       thunkInfo.isec->name = isec->name;
       thunkInfo.isec->segname = isec->segname;
       thunkInfo.isec->parent = this;
       StringRef thunkName = saver.save(funcSym->getName() + ".thunk." +
                                        std::to_string(thunkInfo.sequence++));
       r.referent = thunkInfo.sym = symtab->addDefined(
           thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0,
           /*size=*/thunkSize, /*isWeakDef=*/false, /*isPrivateExtern=*/true,
-          /*isThumb=*/false);
+          /*isThumb=*/false, /*isReferencedDynamically=*/false);
       target->populateThunk(thunkInfo.isec, funcSym);
       finalizeOne(thunkInfo.isec);
       thunks.push_back(thunkInfo.isec);
       ++thunkCount;
     }
   }
   size = isecAddr - addr;
   fileSize = isecFileOff - fileOff;

lld/MachO/SymbolTable.h

  * replaceSymbol(), which does an in-place update of the Symbol via `placement
  * new`. Therefore, there is no need to update any relocations that hold
  * pointers the "old" Symbol -- they will automatically point to the new one.
  */
 class SymbolTable {
 public:
   Defined *addDefined(StringRef name, InputFile *, InputSection *,
                       uint64_t value, uint64_t size, bool isWeakDef,
-                      bool isPrivateExtern, bool isThumb);
+                      bool isPrivateExtern, bool isThumb,
+                      bool isReferencedDynamically);
 
   Symbol *addUndefined(StringRef name, InputFile *, bool isWeakRef);
 
   Symbol *addCommon(StringRef name, InputFile *, uint64_t size, uint32_t align,
                     bool isPrivateExtern);
 
   Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef, bool isTlv);
   Symbol *addDynamicLookup(StringRef name);
 
   Symbol *addLazy(StringRef name, ArchiveFile *file,
                   const llvm::object::Archive::Symbol &sym);
 
   Defined *addSynthetic(StringRef name, InputSection *, uint64_t value,
-                        bool isPrivateExtern, bool includeInSymtab);
+                        bool isPrivateExtern, bool includeInSymtab,
+                        bool referencedDynamically);
 
   ArrayRef<Symbol *> getSymbols() const { return symVector; }
   Symbol *find(llvm::CachedHashStringRef name);
   Symbol *find(StringRef name) { return find(llvm::CachedHashStringRef(name)); }
 
 private:
   std::pair<Symbol *, bool> insert(StringRef name, const InputFile *);
   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;

lld/MachO/SymbolTable.cpp

std::pair<Symbol *, bool> SymbolTable::insert(StringRef name,
 
   sym->isUsedInRegularObj |= !file || isa<ObjFile>(file);
   return {sym, p.second};
 }
 
 Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
                                  InputSection *isec, uint64_t value,
                                  uint64_t size, bool isWeakDef,
-                                 bool isPrivateExtern, bool isThumb) {
+                                 bool isPrivateExtern, bool isThumb,
+                                 bool isReferencedDynamically) {
   Symbol *s;
   bool wasInserted;
   bool overridesWeakDef = false;
   std::tie(s, wasInserted) = insert(name, file);
 
   assert(!isWeakDef || (isa<BitcodeFile>(file) && !isec) ||
          (isa<ObjFile>(file) && file == isec->file));
 
   if (!wasInserted) {
     if (auto *defined = dyn_cast<Defined>(s)) {
       if (isWeakDef) {
+        if (defined->isWeakDef()) {
           // Both old and new symbol weak (e.g. inline function in two TUs):
           // If one of them isn't private extern, the merged symbol isn't.
-        if (defined->isWeakDef()) {
           defined->privateExtern &= isPrivateExtern;
+          defined->referencedDynamically |= isReferencedDynamically;
 
           // FIXME: Handle this for bitcode files.
           // FIXME: We currently only do this if both symbols are weak.
           //        We could do this if either is weak (but getting the
           //        case where !isWeakDef && defined->isWeakDef() right
           //        requires some care and testing).
           if (isec)
             isec->canOmitFromOutput = true;
         }
 
         return defined;
       }
       if (!defined->isWeakDef())
         error("duplicate symbol: " + name + "\n>>> defined in " +
               toString(defined->getFile()) + "\n>>> defined in " +
               toString(file));
     } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
       overridesWeakDef = !isWeakDef && dysym->isWeakDef();
     }
     // Defined symbols take priority over other types of symbols, so in case
     // of a name conflict, we fall through to the replaceSymbol() call below.
   }
 
-  Defined *defined =
-      replaceSymbol<Defined>(s, name, file, isec, value, size, isWeakDef,
-                             /*isExternal=*/true, isPrivateExtern, isThumb);
+  Defined *defined = replaceSymbol<Defined>(
+      s, name, file, isec, value, size, isWeakDef, /*isExternal=*/true,
+      isPrivateExtern, isThumb, isReferencedDynamically);
   defined->overridesWeakDef = overridesWeakDef;
   return defined;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
                                   bool isWeakRef) {
   Symbol *s;
   bool wasInserted;
if (wasInserted)
     replaceSymbol<LazySymbol>(s, file, sym);
   else if (isa<Undefined>(s) || (isa<DylibSymbol>(s) && s->isWeakDef()))
     file->fetch(sym);
   return s;
 }
 
 Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
                                    uint64_t value, bool isPrivateExtern,
-                                   bool includeInSymtab) {
+                                   bool includeInSymtab,
+                                   bool referencedDynamically) {
   Defined *s = addDefined(name, nullptr, isec, value, /*size=*/0,
                           /*isWeakDef=*/false, isPrivateExtern,
-                          /*isThumb=*/false);
+                          /*isThumb=*/false, referencedDynamically);
   s->includeInSymtab = includeInSymtab;
   return s;
 }
 
 void lld::macho::treatUndefinedSymbol(const Undefined &sym, StringRef source) {
   auto message = [source, &sym]() {
     std::string message = "undefined symbol: " + toString(sym);
     if (!source.empty())

lld/MachO/Symbols.h

public:
   // True if this symbol was referenced by a regular (non-bitcode) object.
   bool isUsedInRegularObj;
 };
 
 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputFile *file, InputSection *isec, uint64_t value,
           uint64_t size, bool isWeakDef, bool isExternal, bool isPrivateExtern,
-          bool isThumb)
+          bool isThumb, bool isReferencedDynamically)
       : Symbol(DefinedKind, name, file), isec(isec), value(value), size(size),
         overridesWeakDef(false), privateExtern(isPrivateExtern),
-        includeInSymtab(true), thumb(isThumb), weakDef(isWeakDef),
+        includeInSymtab(true), thumb(isThumb),
+        referencedDynamically(isReferencedDynamically), weakDef(isWeakDef),
         external(isExternal) {
     if (isec)
       isec->numRefs++;
   }
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
public:
 
   bool overridesWeakDef : 1;
   // Whether this symbol should appear in the output binary's export trie.
   bool privateExtern : 1;
   // Whether this symbol should appear in the output symbol table.
   bool includeInSymtab : 1;
   // Only relevant when compiling for Thumb-supporting arm32 archs.
   bool thumb : 1;
+  // Symbols marked referencedDynamically won't be removed from the output's
+  // symbol table by tools like strip. In theory, this could be set on arbitrary
+  // symbols in input object files. In practice, it's used solely for the
+  // synthetic __mh_execute_header symbol.
+  bool referencedDynamically : 1;
 
 private:
   const bool weakDef : 1;
   const bool external : 1;
 };
 
 // This enum does double-duty: as a symbol property, it indicates whether & how
 // a dylib symbol is referenced. As a DylibFile property, it indicates the kind

lld/MachO/SyntheticSections.cpp

void StubHelperSection::setup() {
   stubBinder->refState = RefState::Strong;
   in.got->addEntry(stubBinder);
 
   inputSections.push_back(in.imageLoaderCache);
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false,
-                    /*isThumb=*/false);
+                    /*isThumb=*/false, /*isReferencedDynamically=*/false);
 }
 
 ImageLoaderCacheSection::ImageLoaderCacheSection() {
   segname = segment_names::data;
   name = section_names::data;
   uint8_t *arr = bAlloc.Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   data = {arr, target->wordSize};
if (auto *defined = dyn_cast<Defined>(entry.sym)) {
       } else {
         nList->n_type = scope | N_SECT;
         nList->n_sect = defined->isec->parent->index;
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->getVA();
       }
       nList->n_desc |= defined->thumb ? N_ARM_THUMB_DEF : 0;
       nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
+      nList->n_desc |=
+          defined->referencedDynamically ? REFERENCED_DYNAMICALLY : 0;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
       uint16_t n_desc = nList->n_desc;
       int16_t ordinal = ordinalForDylibSymbol(*dysym);
       if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
         SET_LIBRARY_ORDINAL(n_desc, DYNAMIC_LOOKUP_ORDINAL);
       else if (ordinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)
         SET_LIBRARY_ORDINAL(n_desc, EXECUTABLE_ORDINAL);
       else {
void BitcodeBundleSection::writeTo(uint8_t *buf) const {
   memcpy(buf, xarMap.const_data(), xarSize);
 
   closeFile(handle);
   remove(xarPath);
 }
 
 void macho::createSyntheticSymbols() {
   auto addHeaderSymbol = [](const char *name) {
-    symtab->addSynthetic(name, in.header->isec, 0,
-                         /*privateExtern=*/true,
-                         /*includeInSymtab=*/false);
+    symtab->addSynthetic(name, in.header->isec, /*value=*/0,
+                         /*privateExtern=*/true, /*includeInSymtab=*/false,
+                         /*referencedDynamically=*/false);
   };
 
   switch (config->outputType) {
     // FIXME: Assign the right address value for these symbols
     // (rather than 0). But we need to do that after assignAddresses().
   case MH_EXECUTE:
     // If linking PIE, __mh_execute_header is a defined symbol in
     //  __TEXT, __text)
     // Otherwise, it's an absolute symbol.
     if (config->isPic)
       symtab->addSynthetic("__mh_execute_header", in.header->isec, /*value=*/0,
-                           /*privateExtern=*/false,
-                           /*includeInSymtab=*/true);
+                           /*privateExtern=*/false, /*includeInSymtab=*/true,
+                           /*referencedDynamically=*/true);
     else
-      symtab->addSynthetic("__mh_execute_header",
-                           /*isec*/ nullptr, /*value=*/0,
-                           /*privateExtern=*/false,
-                           /*includeInSymtab=*/true);
+      symtab->addSynthetic("__mh_execute_header", /*isec=*/nullptr, /*value=*/0,
+                           /*privateExtern=*/false, /*includeInSymtab=*/true,
+                           /*referencedDynamically=*/true);
     break;
 
-    // The following symbols are  N_SECT symbols, even though the header is not
+    // The following symbols are N_SECT symbols, even though the header is not
     // part of any section and that they are private to the bundle/dylib/object
     // they are part of.
   case MH_BUNDLE:
     addHeaderSymbol("__mh_bundle_header");
     break;
   case MH_DYLIB:
     addHeaderSymbol("__mh_dylib_header");
     break;

lld/MachO/UnwindInfoSection.cpp

if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
       // Personality functions can be referenced via section relocations
       // if they live in the same object file. Create placeholder synthetic
       // symbols for them in the GOT.
       Symbol *&s = personalityTable[{referentIsec, r.addend}];
       if (s == nullptr) {
         s = make<Defined>("<internal>", /*file=*/nullptr, referentIsec,
                           r.addend, /*size=*/0, /*isWeakDef=*/false,
                           /*isExternal=*/false, /*isPrivateExtern=*/false,
-                          /*isThumb=*/false);
+                          /*isThumb=*/false, /*isReferencedDynamically=*/false);
         in.got->addEntry(s);
       }
       r.referent = s;
       r.addend = 0;
     }
   }
 }
 

lld/test/MachO/referenced-dynamically.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+
+# RUN: %lld %t.o -lSystem -o %t.out
+# RUN: llvm-readobj --syms %t.out | FileCheck %s
+
+## ld64 has a "TEMP work around until <rdar://problem/7702923> goes in"
+## that promotes PrivateExtern ReferencedDynamically symbols in dylibs to
+## normal Externs. lld does not do this.
+# RUN: %lld -dylib %t.o -o %t.dylib
+# RUN: llvm-readobj --syms %t.dylib | FileCheck %s
+
+# CHECK:         Name: ___crashreporter_info__
+# CHECK-NEXT:    PrivateExtern
+# CHECK-NEXT:    Type: Section (0xE)
+# CHECK-NEXT:    Section: __common
+# CHECK-NEXT:    RefType: UndefinedNonLazy (0x0)
+# CHECK-NEXT:    Flags [ (0x10)
+# CHECK-NEXT:      ReferencedDynamically (0x10)
+# CHECK-NEXT:    ]
+
+## Reduced from lib/Support/PrettyStackTrace.cpp
+.section __TEXT,__text,regular,pure_instructions
+
+.globl _main
+_main:
+  ret
+
+## .private_extern maches what PrettyStackTrace.cpp does, but it makes
+## the ReferencedDynamically pointless: https://reviews.llvm.org/D27683#2763729
+.private_extern ___crashreporter_info__
+.globl ___crashreporter_info__
+.desc ___crashreporter_info__,16
+.zerofill __DATA,__common,___crashreporter_info__,8,3
+.subsections_via_symbols

lld/test/MachO/stabs.s

 # CHECK-DAG:  (     SECT EXT) [[#%.2d,TEXT_ID + 1]]      0000   [[#BAZ]]           '_baz'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,TEXT_ID + 1]]      0000   [[#BAZ2]]          '_baz2'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,TEXT_ID + 1]]      0000   [[#QUX]]           '_qux'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,TEXT_ID + 1]]      0000   [[#QUUX]]          '_quux'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,DATA_ID + 1]]      0000   [[#GLOB]]          '_global_var'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,COMM_ID + 1]]      0000   [[#ZERO]]          '_zero'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,MORE_TEXT_ID + 1]] 0000   [[#FUN]]           '_fun'
 # CHECK-DAG:  (     SECT EXT) [[#%.2d,TEXT_ID + 1]]      0000   {{[0-9a-f]+}}      '_no_debug'
-# CHECK-DAG:  (       {{.*}}) {{[0-9]+}}                 0000   {{[0-9a-f]+}}      '__mh_execute_header'
+# CHECK-DAG:  (       {{.*}}) {{[0-9]+}}                 0010   {{[0-9a-f]+}}      '__mh_execute_header'
 # CHECK-EMPTY:
 
 ## Check that we don't attempt to emit rebase opcodes for the debug sections
 ## when building a PIE (since we have filtered the sections out).
 # RUN: %lld -lSystem -pie %t/test.o %t/foo.a %t/no-debug.o -o %t/test
 # RUN: llvm-objdump --macho --rebase %t/test | FileCheck %s --check-prefix=PIE
 # PIE:       Rebase table:
 # PIE-NEXT:  segment  section            address     type

lld/test/MachO/symtab.s

 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:  Symbol {
 # CHECK-NEXT:    Name: __mh_execute_header (81)
 # CHECK-NEXT:    Extern
 # CHECK-NEXT:    Type: Section (0xE)
 # CHECK-NEXT:    Section: __text (0x1)
 # CHECK-NEXT:    RefType: UndefinedNonLazy (0x0)
-# CHECK-NEXT:    Flags [ (0x0)
+# CHECK-NEXT:    Flags [ (0x10)
+# CHECK-NEXT:      ReferencedDynamically (0x10)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Value: 0x100000000
 # CHECK-NEXT:  }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: dyld_stub_binder
 # CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Undef (0x0)
 # CHECK-NEXT:     Section:  (0x0)