[lld-macho] Define __mh_*_header synthetic symbols.

[oontvoo]

Summary

Bug: https://bugs.llvm.org/show_bug.cgi?id=49290

[int3]

So the reason why I hadn't implemented __mh_*_header symbols is that I'm not happy with the current implementation of DSOHandle. It really should have most of the semantics of a Defined symbol, and having it as a separate case means it's easy to forget to handle it. I've been thinking of having Defined symbols contain a SectionPointerUnion instead of an InputSection field, which should be all that's needed to model these synthetic symbols. The one thing I'm concerned about is the performance implications; I think it will be fine, but it would be good to run some benchmarks, e.g. by linking a large project like LLVM or Chromium.

[int3]

Btw, I've just filed a bunch of tasks on the LLVM bug tracker for known missing features, and I've assigned this one to you :)

Hopefully we can coordinate there in the future to avoid wasted work -- I'd have given you more context beforehand if I knew you were going to work on this.

[oontvoo]

updated diff

[oontvoo]

lld/MachO/SymbolTable.h

70–72

@int3: Why do we need this FIXME? (DSO handle and other mh_* stuff don't have an originating file ...)

[int3]

lld/MachO/SymbolTable.h

70–72

ah, that was already done in D94316, so this FIXME can be removed

[int3]

Did you intend to mark this diff as ready for review?

[oontvoo]

Did you intend to mark this diff as ready for review?

Not yet - i'm adding a test

[int3]

Testing aside, the most recent changes in the diff don't seem to have addressed the concerns in my earlier comment:

It really should have most of the semantics of a Defined symbol, and having it as a separate case means it's easy to forget to handle it. I've been thinking of having Defined symbols contain a SectionPointerUnion instead of an InputSection field, which should be all that's needed to model these synthetic symbols.

[oontvoo]

In D97007#2617844, @int3 wrote:

Testing aside, the most recent changes in the diff don't seem to have addressed the concerns in my earlier comment:

It really should have most of the semantics of a Defined symbol, and having it as a separate case means it's easy to forget to handle it. I've been thinking of having Defined symbols contain a SectionPointerUnion instead of an InputSection field, which should be all that's needed to model these synthetic symbols.

Yup, looking 👀

[oontvoo]

updated diff

[oontvoo]

rebae

[oontvoo]

lld/MachO/Driver.cpp

1060

Unlike the __dso_handle, these __mh_*_header's are implemented as undefined. (can see this by looking at the header section of a binary produced by ld64)

[carlokok]

lld/MachO/Driver.cpp

1061

Would there be a chance of having a mh_*_header that works for all targets, while this gets added anyway? something like mh_header?

[int3]

Hm, why is __mh_execute_header an undefined?

It seems like it's a defined symbol to me:

(base) ~/tmp: cat test.cpp
int main() { return 0; }
(base) ~/tmp: clang -c test.cpp
(base) ~/tmp: ld -lSystem test.o -o test
(base) ~/tmp: llvm-objdump --syms test

test:	file format mach-o 64-bit x86-64

SYMBOL TABLE:
0000000100000000 g     F __TEXT,__text __mh_execute_header
0000000100003fa0 g     F __TEXT,__text _main
0000000000000000         *UND* dyld_stub_binder

Weirdly enough, when I swap out LLD for ld64 in our unit tests, it seems like load-command.s generates __mh_execute_header as an absolute symbol. Aha, turns out that it's an absolute symbol only if we aren't linking a PIE.

Also, ld64 doesn't appear to emit __mh_bundle_header:

--- a/lld/test/MachO/lit.local.cfg
+++ b/lld/test/MachO/lit.local.cfg
@@ -8,7 +8,7 @@ import os
 #
 # Note however that this does not apply to `-syslibroot`: each instance of that
 # flag will append to the set of library roots.
-lld = ('ld64.lld -arch x86_64 -platform_version macos 10.0 11.0 -syslibroot ' +
+lld = ('ld -syslibroot ' +
     os.path.join(config.test_source_root, "MachO", "Inputs", "MacOSX.sdk"))
 config.substitutions.append(('%lld', lld + ' -fatal_warnings'))
 config.substitutions.append(('%no_fatal_warnings_lld', lld))

(base) Output/load-commands.s.tmp: pwd
/Users/jezng/src/llvm-project/build/release/tools/lld/test/MachO/Output/load-commands.s.tmp
(base) Output/load-commands.s.tmp: llvm-objdump --syms executable

executable:	file format mach-o 64-bit x86-64

SYMBOL TABLE:
0000000100000000 g       *ABS* __mh_execute_header
0000000100003fb0 g     F __TEXT,__text _main
0000000000000000         *UND* dyld_stub_binder
(base) Output/load-commands.s.tmp: llvm-objdump --syms bundle

bundle:	file format mach-o 64-bit x86-64

SYMBOL TABLE:
0000000000003fb0 g     F __TEXT,__text _main

I figured it might be interesting to test if our input object files can link against these symbols, and it appears to be the case:

(base) ~/tmp: cat test.s
.text
.globl _main
_main:
  mov __mh_execute_header@GOTPCREL(%rip), %rax
  ret
(base) ~/tmp: llvm-mc test.s -triple=x86_64-apple-macos11.0 -filetype=obj -o test.o
(base) ~/tmp: ld test.o -lSystem -o test
(base) ~/tmp: ld test.o -lSystem -o test -dylib
Undefined symbols for architecture x86_64:
  "__mh_execute_header", referenced from:
      _main in test.o
ld: symbol(s) not found for architecture x86_64

We should add a test for that.

lld/MachO/Symbols.h

84–86

hm why the need to replace linkerInternal with this? (Do we still need it if the __mh_* symbols are Defineds?)

[oontvoo]

In D97007#2632689, @int3 wrote:

Hm, why is __mh_execute_header an undefined?

It seems like it's a defined symbol to me:

Yes, my bad - I thought I was testing against ld64, but ended up using the older darwin port, which seemed to incorrectly implemented it as UNDEF.

Weirdly enough, when I swap out LLD for ld64 in our unit tests, it seems like load-command.s generates __mh_execute_header as an absolute symbol. Aha, turns out that it's an absolute symbol only if we aren't linking a PIE.

No that's not weird - they said the _execute_ is an absolute symbol.
The rest is N_SECT.

Also, ld64 doesn't appear to emit __mh_bundle_header:

but it does 🤔 ... at least, the code looks like should. (it's not included in the symbol table though)

lld/MachO/Driver.cpp

1061

I'm not sure I understand this question.

Are you asking if they would introduce a new symbol to replace all this?
(if so, I don't know :) probably not given each of these symbol is unique to each file type )

Or are you asking/suggesting that in this implementation, we would make an mh_header class and move this code there?
If so, sure. I've moved the synthetic-symbols generations out-of-line for readability.

lld/MachO/Symbols.h

84–86

How about calling it presentInSymbolTable?

Calling it linkerInternal is weird because all of these are linker internal ... it's just some of them are not to be included in the symbol table

[oontvoo]

updated diff

[oontvoo]

format

[int3]

Will do a proper review tomorrow... just some quick comments before I go to sleep.

No that's not weird - they said the _execute_ is an absolute symbol.

I said it was weird because in my first test.cpp example it isn't an absolute symbol, but in the load-command.s test it was. I realized that was because our lit.local.cfg file specifies an early macOS platform version, whereas by default ld64 will target a modern macOS (>= 10.6) where PIEs are the default (see our isPie() function). We should probably mimic this behavior.

lld/MachO/Symbols.h

84–86

Let me sleep on this... but naming aside, I'm also trying to understand if we need a tristate enum rather than a boolean

lld/MachO/SyntheticSections.cpp

72–73

-preload    Produces a mach-o file in which the mach_header, load commands, and sym-
            bol table are not in any segment.  This output type is used for firmware
            or embedded development where the segments are copied out of the mach-o
            into ROM/Flash.

I think it's unlikely that we'll add real support for -preload any time soon (due to lack of use cases), so I wouldn't bother even partially supporting the MH_PRELOAD case.

[int3]

but it does 🤔 ... at least, the code looks like should. (it's not included in the symbol table though)

Ah I see -- we can link against it, but it doesn't appear in the final symbol table...

I'm trying to understand the significance of __mh_execute_header being defined while the others are undefined though. Why not make all of them Defined?

Also I think the tests still need updating :)

lld/MachO/Symbols.h

84–86

Well we have "extern" to indicate external symbols that appear in the symbol table -- c.f. privateExtern. So the "internal" part is meant to contrast with that. but I agree that having "linker" in any variable name that's part of a linker is criminally redundant :P

How about syntheticIntern, or even just internal? I'm not a fan of LongJavaNamesThatSayWhatTheyDo, but if you think those are too cryptic, I'd also be fine with includeInSymtab ("include" seems to make more sense than "present" since nothing is present until we write out the binary.)

</bikeshed>

lld/MachO/SyntheticSections.cpp

1018–1020

this could be a lambda. We should avoid macros if possible

1033

not sure I follow this last part of the sentence. How are they private to a TU, when they only exist in the output binary?

[oontvoo]

updated diff

[oontvoo]

updated tests

[int3]

So if I understand correctly, we need to make __mh_execute_header look like it's part of __text when we emit the symbol table. I have two ideas:

1. This is kinda sneaky but ... if all we care about is the symbol table entry matching the right section, that means we just need to get the n_sect value to match, so we could have MachHeaderSection pretend to be the text section by giving it a section index of 1.
2. We could make MachHeaderSection inherit from an InputSection rather than a OutputSection (SyntheticSection), and then have it be part of the __TEXT MergedOutputSection. This is more architecturally consistent, but would probably require a good deal of refactoring.

My inclination is to go with #1; I think it's a simple enough hack, and unlikely to bite us in the ass down the road (fingers crossed)

lld/MachO/SyntheticSections.cpp

1003

addSynSymMachHeader is kind of a mouthful... how about addHeaderSymbol?

1010–1011

I would drop this comment... the default assumption is that we're emulating ld64's behavior.

1013

instead of passing isPie, we could just check if config->isPic here. MH_EXECUTE + isPic => PIE.

1018

From ld64's output, it looks like the absolute symbol will still have the address of the header. I guess we could support it by putting in.header->addr here, but we would need to move createSyntheticSymbols after assignAddresses.

(If it turns out to be uglier than that, I think it's fine that we don't have 100% parity; modern macOS binaries are all PIE, so this will be a very rare use case.)

1041

can rm

[oontvoo]

Updated diff:

• give MachHeaderSection a section index of 1.
• added tests

lld/MachO/Symbols.h

84–86

went with includeSymtab (because it's less cryptic than internal) Thanks!

lld/MachO/SyntheticSections.cpp

1003

well no-one reads it out loud, but ok. :-)

1018

I've added a FIXME instead. (assignAddresses() is in finalize....(), which is way later )

1033

Updated.

[oontvoo]

rebase

[oontvoo]

fixed map-file test

[int3]

Thanks for getting through this surprisingly hairy feature (and putting up with my nits ;) )

lld/MachO/SymbolTable.h

55

the return type can still be Defined

lld/MachO/SyntheticSections.cpp

1010

1027–1029

nit: formatting (line length)

1043

would be nice to add a llvm_unreachable("unexpected output type") here just to be safe

lld/MachO/Writer.cpp

753–754

could just assign the index = 1 in the constructor of the MachHeaderSection, no need to check for it in a loop here

lld/test/MachO/mh_dylib_header.s

1–2 ↗

(On Diff #331759)

file naming nit: mh_dylib_header.s is a bit misleading since we're doing more than just testing that symbol. How about mh-header-link.s or mh-header-resolution.s?

4 ↗

(On Diff #331759)

nit: REQUIRES should be the first line in the file

7–8 ↗

(On Diff #331759)

(no need to repeat "in a dylib")

11 ↗

(On Diff #331759)

I mean I guess both flags work but one-char flags typically use one dash

13 ↗

(On Diff #331759)

we typically add -o /dev/null so that if it unexpectedly passes we're not creating an a.out in a random directory. ditto for ERR-EXEC

20 ↗

(On Diff #331759)

22 ↗

(On Diff #331759)

The "-arch x86_64 -platform_version macOS 10 11" shouldn't be necessary since we are already defining that in lit.local.cfg

(same for other %lld invocations)

33–35 ↗

(On Diff #331759)

I think this is happening because we are linking a non-PIE, and due to the FIXME in SyntheticSections.cpp, LLD thinks that it is an absolute symbol at address 0, so the jump is too large (because it needs to cross __PAGEZERO). Whereas if it were actually pointing to the header, then it would be a much shorter jump.

I think we should just invoke %lld -pie and use GOTPCREL here, and skip testing the non-PIE case for now.

It would also be nice to check that the relocation resolves to the right address via llvm-objdump -m -d

lld/test/MachO/mh_execute_header.s

1 ↗

(On Diff #331759)

nit: mh-execute-header.s

[oontvoo]

addressed review comments + rebase

[oontvoo]

Thanks!

[smeenai]

In D97007#2636289, @int3 wrote:

2. We could make MachHeaderSection inherit from an InputSection rather than a OutputSection (SyntheticSection), and then have it be part of the __TEXT MergedOutputSection. This is more architecturally consistent, but would probably require a good deal of refactoring.

I don't have the full context here, but does this tie into the larger questions of whether SyntheticSections should be InputSections or OutputSections? https://bugs.llvm.org/show_bug.cgi?id=49780

To be clear, I'm not saying we're at the point where we should consider that refactoring yet; I'm just wondering if it's another data point that should be included when we eventually make that decision :)

[int3]

After D98545: [lld-macho][nfc] Give every SyntheticSection a fake InputSection and this diff, I feel like having SyntheticSections be OutputSections is clean enough. Not sure how thunks might be sped up if synthetics were InputSections though, I guess we'll see. But yeah, this diff is indeed another data point to consider.

lld/MachO/Driver.cpp

for (const CachedHashStringRef &cachedName :
       if (const Symbol *sym = symtab->find(cachedName))
         if (isa<Defined>(sym))
           continue;
       error("undefined symbol " + cachedName.val() +
             "\n>>> referenced from option -exported_symbo(s_list)");
     }
 
     createSyntheticSections();
-
-    // The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
-    // which does e.g. cleanup of static global variables. The ABI document says
-    // that the pointer can point to any address in one of the dylib's segments,
-    // but in practice ld64 seems to set it to point to the header, so that's
-    // what's implemented here.
-    symtab->addSynthetic("___dso_handle", in.header->isec, 0,
-                         /*privateExtern=*/true, /*linkerInternal=*/true);
+    createSyntheticSymbols();
 
     for (const Arg *arg : args.filtered(OPT_sectcreate)) {
       StringRef segName = arg->getValue(0);
       StringRef sectName = arg->getValue(1);
       StringRef fileName = arg->getValue(2);
       Optional<MemoryBufferRef> buffer = readFile(fileName);
       if (buffer)
         inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
     }
 
     // Initialize InputSections.
     for (const InputFile *file : inputFiles) {
       for (const SubsectionMap &map : file->subsections) {
         for (const auto &p : map) {
           InputSection *isec = p.second;
           inputSections.push_back(isec);
         }
       }
     }
 
     // Write to an output file.
     writeResult();
   }

lld/MachO/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_SYMBOL_TABLE_H
 #define LLD_MACHO_SYMBOL_TABLE_H
 
+#include "Symbols.h"
+
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Object/Archive.h"
 
 namespace lld {
 namespace macho {
 
public:
 
   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 *, uint32_t value,
-                        bool isPrivateExtern, bool isLinkerInternal);
+                        bool isPrivateExtern, bool includeInSymtab);
 
   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);
   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
   std::vector<Symbol *> symVector;
 };
 
 void treatUndefinedSymbol(const Undefined &);
 
 extern SymbolTable *symtab;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SymbolTable.cpp

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,
                                    uint32_t value, bool isPrivateExtern,
-                                   bool isLinkerInternal) {
-  Defined *s = addDefined(name, nullptr, isec, value, /*isWeakDef=*/false,
-                          isPrivateExtern);
-  s->linkerInternal = isLinkerInternal;
+                                   bool includeInSymtab) {
+  Defined *s = addDefined(name, nullptr, isec, value,
+                          /*isWeakDef=*/false, isPrivateExtern);
+  s->includeInSymtab = includeInSymtab;
   return s;
 }
 
 void lld::macho::treatUndefinedSymbol(const Undefined &sym) {
   auto message = [](const Undefined &sym) {
     std::string message = "undefined symbol: " + toString(sym);
     std::string fileName = toString(sym.getFile());
     if (!fileName.empty())

lld/MachO/Symbols.h

public:
   // on whether it is a thread-local. A given symbol cannot be referenced by
   // both these sections at once.
   uint32_t gotIndex = UINT32_MAX;
 
   uint32_t stubsIndex = UINT32_MAX;
 
   uint32_t symtabIndex = UINT32_MAX;
 
   InputFile *getFile() const { return file; }
 
 protected:
   Symbol(Kind k, StringRefZ name, InputFile *file)
       : symbolKind(k), nameData(name.data), nameSize(name.size), file(file) {}
 
   Kind symbolKind;
   const char *nameData;
   mutable uint32_t nameSize;
   InputFile *file;
 };
 
 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputFile *file, InputSection *isec, uint32_t value,
           bool isWeakDef, bool isExternal, bool isPrivateExtern)
       : Symbol(DefinedKind, name, file), isec(isec), value(value),
         overridesWeakDef(false), privateExtern(isPrivateExtern),
-        linkerInternal(false), weakDef(isWeakDef), external(isExternal) {}
+        includeInSymtab(true), weakDef(isWeakDef), external(isExternal) {}
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
   bool isTlv() const override {
     return !isAbsolute() && isThreadLocalVariables(isec->flags);
   }
 
   bool isExternal() const { return external; }
   bool isAbsolute() const { return isec == nullptr; }
 
   uint64_t getVA() const override;
   uint64_t getFileOffset() const override;
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 
   InputFile *file;
   InputSection *isec;
   uint32_t value;
 
   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 binary's symbol table.
-  bool linkerInternal : 1;
+  // Whether this symbol should appear in the output symbol table.
+  bool includeInSymtab : 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.h

struct InStruct {
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   ImageLoaderCacheSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
+void createSyntheticSymbols();
+
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SyntheticSections.cpp

SyntheticSection::SyntheticSection(const char *segname, const char *name)
   isec->parent = this;
   isec->outSecOff = 0;
   syntheticSections.push_back(this);
 }
 
 // dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
 // from the beginning of the file (i.e. the header).
 MachHeaderSection::MachHeaderSection()
-    : SyntheticSection(segment_names::text, section_names::header) {}
+    : SyntheticSection(segment_names::text, section_names::header) {
+  // XXX: This is a hack. (See D97007)
+  // Setting the index to 1 to pretend that this section is the text
+  // section.
+  index = 1;
+}
 
 void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
   loadCommands.push_back(lc);
   sizeOfCmds += lc->getSize();
 }
 
 uint64_t MachHeaderSection::getSize() const {
   return sizeof(mach_header_64) + sizeOfCmds + config->headerPad;
 }
 
 static uint32_t cpuSubtype() {
   uint32_t subtype = target->cpuSubtype;
 
   if (config->outputType == MH_EXECUTE && !config->staticLink &&
       target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
       config->target.Platform == PlatformKind::macOS &&
       config->platformInfo.minimum >= VersionTuple(10, 5))
     subtype |= CPU_SUBTYPE_LIB64;
 
   return subtype;
void SymtabSection::finalizeContents() {
 
   // __dyld_private is a local symbol too. It's linker-created and doesn't
   // exist in any object file.
   if (Defined* dyldPrivate = in.stubHelper->dyldPrivate)
     addSymbol(localSymbols, dyldPrivate);
 
   for (Symbol *sym : symtab->getSymbols()) {
     if (auto *defined = dyn_cast<Defined>(sym)) {
-      if (defined->linkerInternal)
+      if (!defined->includeInSymtab)
         continue;
       assert(defined->isExternal());
       addSymbol(externalSymbols, defined);
     } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       if (dysym->isReferenced())
         addSymbol(undefinedSymbols, sym);
     }
   }
void CodeSignatureSection::writeTo(uint8_t *buf) const {
   write64be(&codeDirectory->execSegBase, textSeg->fileOff);
   write64be(&codeDirectory->execSegLimit, textSeg->fileSize);
   write64be(&codeDirectory->execSegFlags,
             config->outputType == MH_EXECUTE ? CS_EXECSEG_MAIN_BINARY : 0);
   auto *id = reinterpret_cast<char *>(&codeDirectory[1]);
   memcpy(id, fileName.begin(), fileName.size());
   memset(id + fileName.size(), 0, fileNamePad);
 }
+
+void macho::createSyntheticSymbols() {
+  auto addHeaderSymbol = [](const char *name) {
+    symtab->addSynthetic(name, in.header->isec, 0,
+                         /*privateExtern=*/true,
+                         /*includeInSymtab*/ false);
+  };
+
+  switch (config->outputType) {
+    // FIXME: Assign the right addresse 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, 0,
+                           /*privateExtern*/ false,
+                           /*includeInSymbtab*/ true);
+    else
+      symtab->addSynthetic("__mh_execute_header",
+                           /*isec*/ nullptr, 0,
+                           /*privateExtern*/ false,
+                           /*includeInSymbtab*/ true);
+    break;
+
+    // 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;
+  case MH_DYLINKER:
+    addHeaderSymbol("__mh_dylinker_header");
+    break;
+  case MH_OBJECT:
+    addHeaderSymbol("__mh_object_header");
+    break;
+  default:
+    llvm_unreachable("unexpected outputType");
+    break;
+  }
+
+  // The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
+  // which does e.g. cleanup of static global variables. The ABI document
+  // says that the pointer can point to any address in one of the dylib's
+  // segments, but in practice ld64 seems to set it to point to the header,
+  // so that's what's implemented here.
+  addHeaderSymbol("___dso_handle");
+}

lld/MachO/Writer.cpp

static void sortSegmentsAndSections() {
 
   uint32_t sectionIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     seg->sortOutputSections(compareByOrder<OutputSection *>(sectionOrder));
     for (OutputSection *osec : seg->getSections()) {
       // Now that the output sections are sorted, assign the final
       // output section indices.
       if (!osec->isHidden())
         osec->index = ++sectionIndex;
-
       if (!firstTLVDataSection && isThreadLocalData(osec->flags))
         firstTLVDataSection = osec;
 
       if (!isecPriorities.empty()) {
         if (auto *merged = dyn_cast<MergedOutputSection>(osec)) {
           llvm::stable_sort(merged->inputs,
                             [&](InputSection *a, InputSection *b) {
                               return isecPriorities[a] > isecPriorities[b];
                             });

lld/test/MachO/export-trie.s

 
 # RUN: llvm-objdump --syms --exports-trie %t | FileCheck %s --check-prefix=EXPORTS
 # EXPORTS-LABEL: SYMBOL TABLE:
 # EXPORTS-DAG:   [[#%x, MAIN_ADDR:]] {{.*}} _main
 # EXPORTS-DAG:   [[#%x, HELLO_ADDR:]] {{.*}} _hello
 # EXPORTS-DAG:   [[#%x, HELLO_WORLD_ADDR:]] {{.*}} _hello_world
 # EXPORTS-DAG:   [[#%x, HELLO_ITS_ME_ADDR:]] {{.*}} _hello_its_me
 # EXPORTS-DAG:   [[#%x, HELLO_ITS_YOU_ADDR:]] {{.*}} _hello_its_you
+# EXPORTS-DAG:   {{0+}} g *ABS* __mh_execute_header
 # EXPORTS-LABEL: Exports trie:
+# EXPORTS-DAG:   0x{{0+}} __mh_execute_header [absolute]
 # EXPORTS-DAG:   0x{{0*}}[[#%X, MAIN_ADDR]] _main
 # EXPORTS-DAG:   0x{{0*}}[[#%X, HELLO_ADDR]] _hello
 # EXPORTS-DAG:   0x{{0*}}[[#%X, HELLO_WORLD_ADDR]] _hello_world
 # EXPORTS-DAG:   0x{{0*}}[[#%x, HELLO_ITS_ME_ADDR:]] _hello_its_me
 # EXPORTS-DAG:   0x{{0*}}[[#%x, HELLO_ITS_YOU_ADDR:]] _hello_its_you
 
 ## Check that we are sharing prefixes in the trie.
 # RUN: obj2yaml %t | FileCheck %s
 # CHECK-LABEL: ExportTrie:
 # CHECK: Name: ''
 # CHECK: Name: _
-# CHECK: Name: main
-# CHECK: Name: hello
+# CHECK-DAG: Name: _mh_execute_header
+# CHECK-DAG: Name: main
+# CHECK-DAG: Name: hello
 # CHECK: Name: _
 # CHECK: Name: world
 # CHECK: Name: its_
-# CHECK: Name: you
-# CHECK: Name: me
+# CHECK-DAG: Name: you
+# CHECK-DAG: Name: me
+
+
 
 .section __TEXT,__cstring
 .globl _hello, _hello_world, _hello_its_me, _hello_its_you, _main
 
 ## Test for when an entire symbol name is a prefix of another.
 _hello:
 .asciz "Hello!\n"
 

lld/test/MachO/map-file.s

 # CHECK-NEXT: 0    __text        {{[0-9a-f]+}}  [[#%x,TEXT:]] TEXT
 # CHECK-NEXT: 1    obj           {{[0-9a-f]+}}  [[#%x,DATA:]] DATA
 # CHECK-NEXT: 2    __common      {{[0-9a-f]+}}  [[#%x,BSS:]]  BSS
 
 # CHECK: SYMBOL TABLE:
 # CHECK-NEXT: [[#%x,MAIN:]]   g     F __TEXT,__text _main
 # CHECK-NEXT: [[#%x,NUMBER:]] g     O __DATA,__common _number
 # CHECK-NEXT: [[#%x,FOO:]]    g     O __TEXT,obj _foo
+# CHECK-NEXT: {{0+}}          g       *ABS* __mh_execute_header
 
 # CHECK-NEXT: # Path: {{.*}}{{/|\\}}map-file.s.tmp/test-map
 # CHECK-NEXT: # Arch: x86_64
 # CHECK-NEXT: # Object files:
 # CHECK-NEXT: [  0] linker synthesized
 # CHECK-NEXT: [  1] {{.*}}{{/|\\}}map-file.s.tmp/test.o
 # CHECK-NEXT: [  2] {{.*}}{{/|\\}}map-file.s.tmp/foo.o
 

lld/test/MachO/mh-execute-header.s

+# REQUIRES: x86
+# RUN: rm -rf %t; mkdir %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
+# RUN: %lld -o %t/test.pie %t/test.o -pie
+# RUN: llvm-objdump --macho --syms %t/test.pie | FileCheck %s --check-prefix=PIE
+
+# RUN: %lld -o %t/test.no_pie %t/test.o -no_pie
+# RUN: llvm-objdump --macho --syms %t/test.no_pie | FileCheck %s --check-prefix=NO-PIE
+
+# PIE:    0000000100000000 g     F __TEXT,__text __mh_execute_header
+# NO-PIE: 0000000000000000 g       *ABS* __mh_execute_header
+
+.text
+.global _main
+_main:
+  ret

lld/test/MachO/mh-header-link.s

+# REQUIRES: x86
+
+## This tests that we can link against these synthetic symbols even
+## if they are not in the symbol table.
+
+# RUN: rm -rf %t; split-file %s %t
+
+## Test that in a dylib, we can link against __mh_dylib_header
+## (but not in other types of files)
+
+# RUN: llvm-mc %t/dylib.s -triple=x86_64-apple-macos11.0 -filetype=obj -o %t/dylib.o
+# RUN: %lld -pie -dylib %t/dylib.o -o %t/dylib.out
+# RUN: llvm-objdump -m --syms %t/dylib.out | FileCheck %s --check-prefix DYLIB
+
+# RUN: not %lld -pie -o /dev/null %t/dylib.o 2>&1 | FileCheck %s --check-prefix ERR-DYLIB
+
+# DYLIB:      SYMBOL TABLE:
+# DYLIB-NEXT: {{[0-9a-f]+}} g     F __TEXT,__text _main
+# DYLIB-NEXT-EMPTY:
+# ERR-DYLIB: error: undefined symbol: __mh_dylib_header
+
+## Test that in an executable, we can link against __mh_execute_header
+# RUN: llvm-mc %t/main.s -triple=x86_64-apple-macos11.0 -filetype=obj -o %t/exec.o
+# RUN: %lld -pie %t/exec.o -o %t/exec.out
+
+## But it would be an error trying to reference __mh_execute_header in a dylib
+# RUN: not %lld -pie -o /dev/null -dylib %t/exec.o 2>&1 | FileCheck %s --check-prefix ERR-EXEC
+
+# ERR-EXEC: error: undefined symbol: __mh_execute_header
+
+#--- main.s
+.text
+.globl _main
+_main:
+ mov __mh_execute_header@GOTPCREL(%rip), %rax
+ ret
+
+#--- dylib.s
+.text
+.globl _main
+_main:
+ mov __mh_dylib_header@GOTPCREL(%rip), %rax
+ ret

lld/test/MachO/objc.s

 # RUN: llvm-objdump --section-headers --syms %t/test | FileCheck %s --check-prefix=NO-OBJC
 
 # NO-OBJC:       Sections:
 # NO-OBJC-NEXT:  Idx Name           Size   VMA  Type
 # NO-OBJC-NEXT:    0 __text         {{.*}}      TEXT
 # NO-OBJC-EMPTY:
 # NO-OBJC-NEXT:  SYMBOL TABLE:
 # NO-OBJC-NEXT:  g     F __TEXT,__text _main
-# NO-OBJC-EMPTY:
+# NO_OBJC-NEXT:  g *ABS* __mh_execute_header
 
 #--- has-objc-symbol.s
 .globl _OBJC_CLASS_$_MyObject
 _OBJC_CLASS_$_MyObject:
 
 #--- has-objc-category.s
 .section  __DATA,__objc_catlist
 .quad 0x1234

lld/test/MachO/stabs.s

 # CHECK-NEXT:  [[#STATIC]]      s _static_var
 # CHECK-NEXT:  [[#MAIN]]        T _main
 # CHECK-NEXT:  {{[0-9af]+}}     A _abs
 # CHECK-NEXT:  [[#FUN]]         S _fun
 # CHECK-NEXT:  [[#GLOB]]        D _global_var
 # CHECK-NEXT:  [[#ZERO]]        S _zero
 # CHECK-NEXT:  [[#FOO]]         T _foo
 # CHECK-NEXT:  {{[0-9af]+}}     T _no_debug
+# CHECK-NEXT:  {{0+}}           A __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:     Type: Section (0xE)
 # CHECK-NEXT:     Section: __text (0x1)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x80)
 # CHECK-NEXT:       WeakDef (0x80)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
-# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: __mh_execute_header (81)
+# CHECK-NEXT:    Extern
+# CHECK-NEXT:    Type: Abs (0x2)
+# CHECK-NEXT:    Section:  (0x0)
+# CHECK-NEXT:    RefType: UndefinedNonLazy (0x0)
+# CHECK-NEXT:    Flags [ (0x0)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Value: 0x0
+# CHECK-NEXT:  }
+# CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: dyld_stub_binder
 # CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Undef (0x0)
 # CHECK-NEXT:     Section:  (0x0)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x100)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x0

 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Dysymtab {
 # CHECK-NEXT:   ilocalsym: 0
 # CHECK-NEXT:   nlocalsym: 2
 # CHECK-NEXT:   iextdefsym: 2
-# CHECK-NEXT:   nextdefsym: 3
-# CHECK-NEXT:   iundefsym: 5
+# CHECK-NEXT:   nextdefsym: 4
+# CHECK-NEXT:   iundefsym: 6
 # CHECK-NEXT:   nundefsym: 2
 
 ## Verify that the first entry in the StringTable is a space, and that
 ## unreferenced symbols aren't emitted.
 # RUN: obj2yaml %t/test | FileCheck %s --check-prefix=YAML
 # YAML:      StringTable:
 # YAML-NEXT: ' '
 # YAML-NOT: _unreferenced