[lld-macho] Fix alignment & layout to match ld64 and satisfy codesign

[gkm]

Summary

Dyld on arm64 macOS has strict requirements for alignment and sequence of segments and sections.

I developed this diff by incrementally changing alignments & sequences to match the output of ld64. I stopped when arm64 macOS began executing my test programs rather than immediately rejecting them in execve(2) with errno == EBADMACHO "Malformed Mach-O file".

[compnerd]

Could you please add a test case for verifying the output order of the load commands? It seems that the load commands are expected to be in a certain order according to your change - it makes sense to have a test which validates that ordering.

lld/MachO/SyntheticSections.cpp

394

Hmm, this is 4 and not WordSize? It is plausible, but might be reasonable to add a comment explaining why 4 on 64-bit systems is needed/correct.

420

Similar.

lld/MachO/Target.h

30 ↗

(On Diff #317425)

Isn't the page size 4K on x64 and 16K on ARM64?

lld/MachO/UnwindInfoSection.cpp

90

IIRC, 4 is correct for the __unwind_info section, but this probably deserves a comment (unless Im mixing up the __compact_unwind_entries).

[gkm]

• remove PageSize change, which is premature.

[gkm]

@compnerd: I am uncertain how to structure a good test. A good test for satisfactory load-command order is already implicit: lld-linked programs don't run on ARM64 macOS otherwise.

lld/MachO/SyntheticSections.cpp

394

__stubs and __stub_helper are text sections populated with machine instruction, so 4-byte alignment is appropriate.

lld/MachO/Target.h

30 ↗

(On Diff #317425)

This belongs in the ARM64 target diff.

lld/MachO/UnwindInfoSection.cpp

90

In all cases, I choose alignment boundaries to mimic ld64. Do you want comment(s) to say that?

[int3]

I am uncertain how to structure a good test.

The output of llvm-objdump --macho --all-headers should allow you to verify the ordering of both load commands and segment/sections.

lld/MachO/SyntheticSections.cpp

394

Maybe naive question: So this means arm64/x86_64 instructions are only 4-byte-aligned?

In any case, this still needs a comment :)

lld/MachO/UnwindInfoSection.cpp

90

Yeah it's worth mentioning IMO to explain why we are not using a larger value. Is this also the minimum alignment, i.e. do we get EBADMACHO if a smaller alignment is used? That's worth mentioning too...

Relatedly, I'm a bit confused by the commit title/message. The commit title mentions codesign, the message mentions dyld first, but later talks about execve and EBADMACHO, which leads me to believe that the error is coming from the kernel. (At least, it looks like EBADMACHO is generated here: https://github.com/apple/darwin-xnu/blob/8f02f2a044b9bb1ad951987ef5bab20ec9486310/bsd/kern/kern_exec.c#L6478).

lld/test/MachO/symtab.s

13

FileCheck does substring matches by default, so we can just skip checking the value at the end

(ditto for the lines below)

[gkm]

lld/MachO/SyntheticSections.cpp

394

Yes. arm64 instructions are fixed-width 4 bytes, with natural 4-byte alignment. x86_64 instructions are variable width and have no alignment requirement, but ld64 aligns them to 4 bytes anyway.

lld/MachO/UnwindInfoSection.cpp

90

Regarding whether we get EBADMACHO at smaller alignment: unknown. I corrected alignments to mimic ld64 until codesign & execve(2) began working and never experimented with underaligning anything to see if it still worked. That never seemed a worthy use of time.

I clarified the commit summary: codesign & kernel execve(2) failures are what guided my changes. dyld(1) is likely also picky, but never gets a chance to run until codesign and kernel are happy.

[gkm]

• revise according to review feedback
• add test

[int3]

lld/test/MachO/load-command-sequence.s

19

[gkm]

• nit + rebase

lld/MachO/SyntheticSections.h

 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
 constexpr const char stringTable[] = "__string_table";
 constexpr const char got[] = "__got";
 constexpr const char threadPtrs[] = "__thread_ptrs";
 constexpr const char unwindInfo[] = "__unwind_info";
 // these are not synthetic, but in service of synthetic __unwind_info
 constexpr const char compactUnwind[] = "__compact_unwind";
 constexpr const char ehFrame[] = "__eh_frame";
+// these are not synthetic, but need to be sorted
+constexpr const char text[] = "__text";
+constexpr const char stubs[] = "__stubs";
+constexpr const char stubHelper[] = "__stub_helper";
+constexpr const char laSymbolPtr[] = "__la_symbol_ptr";
+constexpr const char data[] = "__data";
 
 } // namespace section_names
 
 class Defined;
 class DylibSymbol;
 class LoadCommand;
 class ObjFile;
 
public:
   const StringRef segname;
 };
 
 // All sections in __LINKEDIT should inherit from this.
 class LinkEditSection : public SyntheticSection {
 public:
   LinkEditSection(const char *segname, const char *name)
       : SyntheticSection(segname, name) {
-    align = WordSize;
+    align = WordSize; // mimic ld64
   }
 
   // Sections in __LINKEDIT are special: their offsets are recorded in the
   // load commands like LC_DYLD_INFO_ONLY and LC_SYMTAB, instead of in section
   // headers.
   bool isHidden() const override final { return true; }
 
   virtual uint64_t getRawSize() const = 0;

lld/MachO/SyntheticSections.cpp

 
 void RebaseSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                      const char *name)
     : SyntheticSection(segname, name) {
-  align = 8;
+  align = WordSize; // vector of pointers / mimic ld64
   flags = MachO::S_NON_LAZY_SYMBOL_POINTERS;
 }
 
 void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
   if (entries.insert(sym)) {
     assert(!sym->isInGot());
     sym->gotIndex = entries.size() - 1;
 
if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     // Undefined symbols are filtered out in scanRelocations(); we should never
     // get here
     llvm_unreachable("cannot bind to an undefined symbol");
   }
 }
 
 StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, "__stubs") {
-  flags = MachO::S_SYMBOL_STUBS;
+  flags = MachO::S_SYMBOL_STUBS | MachO::S_ATTR_SOME_INSTRUCTIONS |
+          MachO::S_ATTR_PURE_INSTRUCTIONS;
+  align = 4; // machine instructions / mimic ld64
   reserved2 = target->stubSize;
 }
 
 uint64_t StubsSection::getSize() const {
   return entries.size() * target->stubSize;
 }
 
 void StubsSection::writeTo(uint8_t *buf) const {
   size_t off = 0;
   for (const Symbol *sym : entries) {
     target->writeStub(buf + off, *sym);
     off += target->stubSize;
   }
 }
 
 bool StubsSection::addEntry(Symbol *sym) {
   bool inserted = entries.insert(sym);
   if (inserted)
     sym->stubsIndex = entries.size() - 1;
   return inserted;
 }
 
 StubHelperSection::StubHelperSection()
-    : SyntheticSection(segment_names::text, "__stub_helper") {}
+    : SyntheticSection(segment_names::text, "__stub_helper") {
+  flags = MachO::S_ATTR_SOME_INSTRUCTIONS | MachO::S_ATTR_PURE_INSTRUCTIONS;
+  align = 4; // machine instructions / mimic ld64
+}
 
 uint64_t StubHelperSection::getSize() const {
   return target->stubHelperHeaderSize +
          in.lazyBinding->getEntries().size() * target->stubHelperEntrySize;
 }
 
 bool StubHelperSection::isNeeded() const { return in.lazyBinding->isNeeded(); }
 

 }
 
 ImageLoaderCacheSection::ImageLoaderCacheSection() {
   segname = segment_names::data;
   name = "__data";
   uint8_t *arr = bAlloc.Allocate<uint8_t>(WordSize);
   memset(arr, 0, WordSize);
   data = {arr, WordSize};
+  align = WordSize; // pointer / mimic ld64
 }
 
 LazyPointerSection::LazyPointerSection()
     : SyntheticSection(segment_names::data, "__la_symbol_ptr") {
-  align = 8;
+  align = WordSize; // vector of pointers / mimic ld64
   flags = MachO::S_LAZY_SYMBOL_POINTERS;
 }
 
 uint64_t LazyPointerSection::getSize() const {
   return in.stubs->getEntries().size() * WordSize;
 }
 
 bool LazyPointerSection::isNeeded() const {

lld/MachO/UnwindInfoSection.cpp

 // non-compressed format. Time will tell if anyone in the field ever
 // overflows the 127-encodings limit.
 
 // TODO(gkm): prune __eh_frame entries superseded by __unwind_info
 // TODO(gkm): how do we align the 2nd-level pages?
 
 UnwindInfoSection::UnwindInfoSection()
     : SyntheticSection(segment_names::text, section_names::unwindInfo) {
-  align = WordSize; // TODO(gkm): make this 4 KiB ?
+  align = 4; // mimic ld64
 }
 
 bool UnwindInfoSection::isNeeded() const {
   return (compactUnwindSection != nullptr);
 }
 
 // Scan the __LD,__compact_unwind entries and compute the space needs of
 // __TEXT,__unwind_info and __TEXT,__eh_frame

lld/MachO/Writer.cpp

for (const macho::Symbol *sym : symtab->getSymbols()) {
     } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       dysym->getFile()->refState =
           std::max(dysym->getFile()->refState, dysym->refState);
     }
   }
 }
 
 void Writer::createLoadCommands() {
+  uint8_t segIndex = 0;
+  for (OutputSegment *seg : outputSegments) {
+    in.header->addLoadCommand(make<LCSegment>(seg->name, seg));
+    seg->index = segIndex++;
+  }
+
   in.header->addLoadCommand(make<LCDyldInfo>(
       in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports));
   in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
   in.header->addLoadCommand(
       make<LCDysymtab>(symtabSection, indirectSymtabSection));
   for (StringRef path : config->runtimePaths)
     in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
-    in.header->addLoadCommand(make<LCMain>());
     in.header->addLoadCommand(make<LCLoadDylinker>());
+    in.header->addLoadCommand(make<LCMain>());
     break;
   case MH_DYLIB:
     in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
                                             config->dylibCompatibilityVersion,
                                             config->dylibCurrentVersion));
     break;
   case MH_BUNDLE:
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
-  in.header->addLoadCommand(make<LCBuildVersion>(config->platform));
-
   uuidCommand = make<LCUuid>();
   in.header->addLoadCommand(uuidCommand);
 
-  uint8_t segIndex = 0;
-  for (OutputSegment *seg : outputSegments) {
-    in.header->addLoadCommand(make<LCSegment>(seg->name, seg));
-    seg->index = segIndex++;
-  }
+  in.header->addLoadCommand(make<LCBuildVersion>(config->platform));
 
   uint64_t dylibOrdinal = 1;
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       LoadCommandType lcType =
           dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak
               ? LC_LOAD_WEAK_DYLIB
               : LC_LOAD_DYLIB;
if (isa<ObjFile>(file))
         if (auto *d = dyn_cast<Defined>(sym))
           addSym(*d);
 
   return sectionPriorities;
 }
 
 static int segmentOrder(OutputSegment *seg) {
   return StringSwitch<int>(seg->name)
-      .Case(segment_names::pageZero, -2)
-      .Case(segment_names::text, -1)
+      .Case(segment_names::pageZero, -4)
+      .Case(segment_names::text, -3)
+      .Case(segment_names::dataConst, -2)
+      .Case(segment_names::data, -1)
       // Make sure __LINKEDIT is the last segment (i.e. all its hidden
       // sections must be ordered after other sections).
       .Case(segment_names::linkEdit, std::numeric_limits<int>::max())
       .Default(0);
 }
 
 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, -1)
+        .Case(section_names::header, -4)
+        .Case(section_names::text, -3)
+        .Case(section_names::stubs, -2)
+        .Case(section_names::stubHelper, -1)
         .Case(section_names::unwindInfo, std::numeric_limits<int>::max() - 1)
         .Case(section_names::ehFrame, std::numeric_limits<int>::max())
         .Default(0);
-  }
-  if (segname == segment_names::data) {
+  } else if (segname == segment_names::data) {
     // 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
     // to minimize the amount of memory used. Additionally, since zerofill
     // sections must be at the end of their segments, and since TLV data
     // sections can be zerofills, we end up putting all TLV data sections at the
     // end of the segment.
     switch (sectionType(osec->flags)) {
     case S_THREAD_LOCAL_REGULAR:
       return std::numeric_limits<int>::max() - 2;
     case S_THREAD_LOCAL_ZEROFILL:
       return std::numeric_limits<int>::max() - 1;
     case S_ZEROFILL:
       return std::numeric_limits<int>::max();
     default:
-      return 0;
-    }
+      return StringSwitch<int>(osec->name)
+          .Case(section_names::laSymbolPtr, -2)
+          .Case(section_names::data, -1)
+          .Default(0);
     }
-  if (segname == segment_names::linkEdit) {
+  } else if (segname == segment_names::linkEdit) {
     return StringSwitch<int>(osec->name)
         .Case(section_names::rebase, -8)
         .Case(section_names::binding, -7)
         .Case(section_names::weakBinding, -6)
         .Case(section_names::lazyBinding, -5)
         .Case(section_names::export_, -4)
         .Case(section_names::symbolTable, -3)
         .Case(section_names::indirectSymbolTable, -2)

lld/test/MachO/dylib-stub.yaml

 ## Stub dylibs differ from "real" dylibs in that they lack any content in their
 ## sections. What they do have are export tries and symbol tables, which means
 ## we can still link against them. I (jezng) am unclear how to properly create
 ## these stub dylibs; XCode 11.3's `lipo` is able to create stub dylibs, but
 ## those lack LC_ID_DYLIB load commands and are considered invalid by most
 ## tooling. Newer versions of `lipo` aren't able to create stub dylibs at all.
 ## However, recent SDKs in XCode still come with valid stub dylibs, so it still
 ## seems worthwhile to support them. The YAML in this test was generated by
 ## taking a non-stub dylib and editing the appropriate fields.
 
 # REQUIRES: x86
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: yaml2obj %t/fat.dylib.yaml > %t/fat.dylib
 # RUN: %lld -lSystem %t/test.o %t/fat.dylib -o %t/test
 # RUN: llvm-objdump --macho --lazy-bind %t/test | FileCheck %s
-# CHECK: __DATA   __la_symbol_ptr    0x100001008 foo  _foo
+# CHECK: __DATA   __la_symbol_ptr    0x100002000 foo  _foo
 
 #--- test.s
 .globl _main
 _main:
   callq _foo
   ret
 
 #--- fat.dylib.yaml

lld/test/MachO/entry-symbol.s

 # REQUIRES: x86
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/not-main.s -o %t/not-main.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
 # RUN: %lld -lSystem -dylib %t/libfoo.o -o %t/libfoo.dylib
 
 # RUN: %lld -o %t/not-main %t/not-main.o -e _not_main
 # RUN: llvm-objdump --macho --all-headers --syms %t/not-main | FileCheck %s
 # CHECK-LABEL: SYMBOL TABLE
 # CHECK-NEXT: {{0*}}[[#%x, ENTRY_ADDR:]] {{.*}} __TEXT,__text _not_main
-# CHECK:      cmd  LC_MAIN
-# CHECK-NEXT: cmdsize  24
-# CHECK-NEXT: entryoff [[#ENTRYOFF:]]
 # CHECK:      sectname __text
 # CHECK-NEXT: segname __TEXT
 ## Note: the following checks assume that the entry symbol is right at the
 ## beginning of __text.
 # CHECK-NEXT: addr 0x{{0*}}[[#ENTRY_ADDR]]
 # CHECK-NEXT: size
-# CHECK-NEXT: offset [[#ENTRYOFF]]
+# CHECK-NEXT: offset [[#ENTRYOFF:]]
+# CHECK:      cmd  LC_MAIN
+# CHECK-NEXT: cmdsize  24
+# CHECK-NEXT: entryoff [[#ENTRYOFF]]
 
 # RUN: %lld -lSystem -o %t/dysym-main %t/not-main.o %t/libfoo.dylib -e _dysym_main
 # RUN: llvm-objdump --macho --all-headers --indirect-symbols --lazy-bind %t/dysym-main | FileCheck %s --check-prefix=DYSYM
 # DYSYM-LABEL: Indirect symbols for (__TEXT,__stubs) 1 entries
 # DYSYM-NEXT:  address                      index  name
 # DYSYM-NEXT:  0x[[#%x,DYSYM_ENTRY_ADDR:]]  [[#]]  _dysym_main
 # DYSYM-LABEL: cmd  LC_MAIN
 # DYSYM-NEXT:  cmdsize  24

lld/test/MachO/indirect-symtab.s

 # CHECK-NEXT: callq {{.*}} ## symbol stub for: _foo_fn
 # CHECK-NEXT: callq {{.*}} ## symbol stub for: _bar_fn
 # CHECK-NEXT: retq
 
 # CHECK:      Indirect symbols for (__TEXT,__stubs) 2 entries
 # CHECK-NEXT: address            index name
 # CHECK-NEXT: _bar_fn
 # CHECK-NEXT: _foo_fn
-# CHECK-NEXT: Indirect symbols for (__DATA,__thread_ptrs) 2 entries
+# CHECK-NEXT: Indirect symbols for (__DATA_CONST,__got) 3 entries
 # CHECK-NEXT: address            index name
-# CHECK-NEXT: _bar_tlv
-# CHECK-NEXT: _foo_tlv
+# CHECK-NEXT: _bar
+# CHECK-NEXT: _foo
+# CHECK-NEXT: _stub_binder
 # CHECK-NEXT: Indirect symbols for (__DATA,__la_symbol_ptr) 2 entries
 # CHECK-NEXT: address            index name
 # CHECK-NEXT: _bar_fn
 # CHECK-NEXT: _foo_fn
-# CHECK-NEXT: Indirect symbols for (__DATA_CONST,__got) 3 entries
+# CHECK-NEXT: Indirect symbols for (__DATA,__thread_ptrs) 2 entries
 # CHECK-NEXT: address            index name
-# CHECK-NEXT: _bar
-# CHECK-NEXT: _foo
-# CHECK-NEXT: _stub_binder
+# CHECK-NEXT: _bar_tlv
+# CHECK-NEXT: _foo_tlv
 
 #--- libfoo.s
 
 .globl _foo, _foo_fn, _bar, _bar_fn
 _foo:
 _foo_fn:
 _bar:
 _bar_fn:

lld/test/MachO/lc-build-version.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: %lld -platform_version macos 10.14.1 10.15 -o %t %t.o
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s
 
 # CHECK: cmd LC_BUILD_VERSION
 # CHECK-NEXT: cmdsize 32
 # CHECK-NEXT: platform macos
 # CHECK-NEXT: sdk 10.15
 # CHECK-NEXT: minos 10.14.1
 # CHECK-NEXT: ntools 1
 # CHECK-NEXT: tool ld
 # CHECK-NEXT: version {{[0-9\.]+}}
-# CHECK-NEXT: Load command [[#]]
 
 .text
 .global _main
 _main:
   mov $0, %eax
   ret

lld/test/MachO/load-command-sequence.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
+# RUN: %lld -execute -o %t/exec %t/test.o -lSystem
+# RUN: %lld -dylib -o %t/dylib %t/test.o -lSystem
+# RUN: %lld -bundle -o %t/bundle %t/test.o -lSystem
+
+# RUN: llvm-objdump --macho --all-headers %t/exec | \
+# RUN:     FileCheck %s --check-prefixes=EXEC,COMMON
+# RUN: llvm-objdump --macho --all-headers %t/dylib | \
+# RUN:     FileCheck %s --check-prefixes=DYLIB,COMMON
+# RUN: llvm-objdump --macho --all-headers %t/bundle | \
+# RUN:     FileCheck %s --check-prefixes=BUNDLE,COMMON
+
+## Check that load commands and sections within segments occur in the proper
+## sequence. On ARM64 kernel is especially picky about layout, and will
+## barf with errno=EBADMACHO when the sequence is wrong.
+
+# EXEC: cmd LC_SEGMENT_64
+# EXEC: segname __PAGEZERO
+
+# COMMON: cmd LC_SEGMENT_64
+# COMMON: segname __TEXT
+# COMMON: sectname __text
+# COMMON: segname __TEXT
+# COMMON: sectname __cstring
+# COMMON: segname __TEXT
+# COMMON: cmd LC_SEGMENT_64
+# COMMON: segname __DATA_CONST
+# COMMON: sectname __got
+# COMMON: segname __DATA_CONST
+# COMMON: cmd LC_SEGMENT_64
+# COMMON: segname __DATA
+# COMMON: sectname __data
+# COMMON: segname __DATA
+# COMMON: sectname __const
+# COMMON: segname __DATA
+# COMMON: cmd LC_SEGMENT_64
+# COMMON: segname __LINKEDIT
+# COMMON: cmd LC_DYLD_INFO_ONLY
+# COMMON: cmd LC_SYMTAB
+# COMMON: cmd LC_DYSYMTAB
+
+# EXEC: cmd LC_LOAD_DYLINKER
+# EXEC: cmd LC_MAIN
+# DYLIB: cmd LC_ID_DYLIB
+
+# COMMON: cmd LC_UUID
+# COMMON: cmd LC_BUILD_VERSION
+# COMMON: cmd LC_LOAD_DYLIB
+
+.section __TEXT,__cstring
+_str:
+  .asciz "Help me! I'm trapped in a test!\n"
+
+.globl _mutable
+.section __DATA,__data
+mutable:
+  .long 0x1234
+
+.globl _constant
+.section __DATA,__const
+constant:
+  .long 0x4567
+
+.text
+.global _main
+_main:
+  mov ___nan@GOTPCREL(%rip), %rax
+  ret

lld/test/MachO/symtab.s

 # REQUIRES: x86
 # RUN: rm -rf %t && split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
 # RUN: %lld -dylib %t/libfoo.o -o %t/libfoo.dylib
 # RUN: %lld -lSystem %t/test.o %t/libfoo.dylib -o %t/test
 
 # RUN: llvm-readobj --syms --macho-dysymtab %t/test | FileCheck %s
 # CHECK:      Symbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _local
 # CHECK-NEXT:     Type: Section (0xE)
-# CHECK-NEXT:     Section: __data (0x4)
+# CHECK-NEXT:     Section: __data
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: __dyld_private
 # CHECK-NEXT:     Type: Section (0xE)
-# CHECK-NEXT:     Section: __data (0x4)
+# CHECK-NEXT:     Section: __data
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _main
 # CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Section (0xE)
 # CHECK-NEXT:     Section: __text (0x1)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _external
 # CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Section (0xE)
-# CHECK-NEXT:     Section: __data (0x4)
+# CHECK-NEXT:     Section: __data
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _external_weak
 # CHECK-NEXT:     Extern

lld/test/MachO/weak-binding.s

 # REQUIRES: x86
 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
 # RUN: %lld -dylib %t/libfoo.o -o %t/libfoo.dylib
 # RUN: %lld %t/test.o -L%t -lfoo -o %t/test -lSystem
 # RUN: llvm-objdump -d --no-show-raw-insn --bind --lazy-bind --weak-bind --full-contents %t/test | \
 # RUN:   FileCheck %s
 
-# CHECK:      Contents of section __DATA,__la_symbol_ptr:
+# CHECK:      Contents of section __DATA_CONST,__got:
 ## Check that this section contains a nonzero pointer. It should point to
-## _weak_external_fn, but we don't have a good way of testing the exact value as
-## the bytes here are in little-endian order.
+## _weak_external_for_gotpcrel.
 # CHECK-NEXT: {{[0-9a-f]+}} {{[0-9a-f ]*[1-9a-f]+[0-9a-f ]*}}
 
-# CHECK:      Contents of section __DATA_CONST,__got:
+# CHECK:      Contents of section __DATA,__la_symbol_ptr:
 ## Check that this section contains a nonzero pointer. It should point to
-## _weak_external_for_gotpcrel.
+## _weak_external_fn, but we don't have a good way of testing the exact value as
+## the bytes here are in little-endian order.
 # CHECK-NEXT: {{[0-9a-f]+}} {{[0-9a-f ]*[1-9a-f]+[0-9a-f ]*}}
 
 # CHECK:      <_main>:
 # CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_GOT_ADDR:]]
 # CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_EXT_GOT_ADDR:]]
 # CHECK-NEXT: leaq  [[#]](%rip), %rax  # [[#%X,WEAK_INT_GOT_ADDR:]]
 # CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_TLV_ADDR:]]
 # CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_TLV_ADDR:]]
 # CHECK-NEXT: leaq  [[#]](%rip), %rax  # [[#%X,WEAK_INT_TLV_ADDR:]]
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 
 # CHECK-LABEL: Bind table:
+# CHECK-DAG:   __DATA_CONST  __got           0x[[#WEAK_DY_GOT_ADDR]] pointer 0 libfoo    _weak_dysym_for_gotpcrel
+# CHECK-DAG:   __DATA        __la_symbol_ptr 0x[[#%x,WEAK_DY_FN:]]   pointer 0 libfoo    _weak_dysym_fn
 # CHECK-DAG:   __DATA        __data          0x[[#%x,WEAK_DY:]]      pointer 0 libfoo    _weak_dysym
 # CHECK-DAG:   __DATA        __thread_vars   0x{{[0-9a-f]*}}         pointer 0 libSystem __tlv_bootstrap
 # CHECK-DAG:   __DATA        __thread_ptrs   0x[[#WEAK_DY_TLV_ADDR]] pointer 0 libfoo    _weak_dysym_tlv
-# CHECK-DAG:   __DATA_CONST  __got           0x[[#WEAK_DY_GOT_ADDR]] pointer 0 libfoo    _weak_dysym_for_gotpcrel
-# CHECK-DAG:   __DATA        __la_symbol_ptr 0x[[#%x,WEAK_DY_FN:]]   pointer 0 libfoo    _weak_dysym_fn
 ## Check that we don't have any other bindings
 # CHECK-NOT:   pointer
 
 # CHECK-LABEL: Lazy bind table:
 ## Verify that we have no lazy bindings
 # CHECK-NOT:   pointer
 
 # CHECK-LABEL: Weak bind table:

lld/test/MachO/weak-reference.s

 # BIND-DAG:  __DATA_CONST  __got            0x{{[0-9a-f]+}} pointer       0 libfoo  _foo (weak_import)
 # BIND-DAG:  __DATA        __thread_ptrs    0x{{[0-9a-f]+}} pointer       0 libfoo  _foo_tlv (weak_import)
 # BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer       0 libfoo  _weak_foo (weak_import)
 # BIND-DAG:  __DATA        __la_symbol_ptr  0x{{[0-9a-f]+}} pointer       0 libfoo  _weak_foo_fn (weak_import)
 
 # YAML-LABEL: WeakBindOpcodes:
 # YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # YAML-NEXT:     Imm:             0
-# YAML-NEXT:     Symbol:          _weak_foo
+# YAML-NEXT:     Symbol:          _weak_foo_fn
 # YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # YAML-NEXT:     Imm:             0
-# YAML-NEXT:     Symbol:          _weak_foo_fn
+# YAML-NEXT:     Symbol:          _weak_foo
 # YAML-LABEL: LazyBindOpcodes:
 # YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # YAML-NEXT:     Imm:             1
 # YAML-NEXT:     Symbol:          _foo_fn
 
 ## Check that if both strong & weak references are present in inputs, the weak
 ## reference takes priority. NOTE: ld64 actually emits a strong reference if
 ## the reference is to a function symbol or a TLV. I'm not sure if there's a

 # STRONG-BIND-DAG:  __DATA        __thread_ptrs    0x{{[0-9a-f]+}} pointer         0 libfoo  _foo_tlv{{$}}
 # STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo{{$}}
 # STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo{{$}}
 # STRONG-BIND-DAG:  __DATA        __la_symbol_ptr  0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo_fn{{$}}
 
 # STRONG-YAML-LABEL: WeakBindOpcodes:
 # STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # STRONG-YAML-NEXT:     Imm:             0
-# STRONG-YAML-NEXT:     Symbol:          _weak_foo
+# STRONG-YAML-NEXT:     Symbol:          _weak_foo_fn
 # STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # STRONG-YAML-NEXT:     Imm:             0
 # STRONG-YAML-NEXT:     Symbol:          _weak_foo
-# STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
-# STRONG-YAML-NEXT:     Imm:             0
-# STRONG-YAML-NEXT:     Symbol:          _weak_foo_fn
 # STRONG-YAML-LABEL: LazyBindOpcodes:
 # STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 # STRONG-YAML-NEXT:     Imm:             0
 # STRONG-YAML-NEXT:     Symbol:          _foo_fn
 
 ## Weak references must still be satisfied at link time.
 # RUN: not %lld -lSystem %t/invalid.o -o /dev/null 2>&1 | FileCheck %s \
 # RUN:   --check-prefix=INVALID -DDIR=%t