[lld-macho] Support __dso_handle for C++

[int3]

Summary

The C++ ABI requires dylibs to pass a pointer to __cxa_atexit which does
e.g. cleanup of static global variables. The C++ spec 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.

[compnerd]

lld/MachO/SymbolTable.cpp

101

Debugging left overs?

lld/MachO/Symbols.h

139

What do you think of making this ever so slightly more expensive? I think that we should actually make this computed - the name of the symbol is __dso_handle which is decorated with the user label prefix of _ to give you ___dso_handle. We have the information about the user label prefixes in LLVM, why not make that explicit here? I don't think that the cost is really that high.

[int3]

lld/MachO/Symbols.h

139

I wasn't aware that LLVM had info about user label prefixes (though that makes sense). Happy to change. I suppose I'll want something like getTargetInfo().getDataLayout().getGlobalPrefix()

[int3]

lld/MachO/Symbols.h

139

hmm DataLayout is under the IR folder though. I'm not sure how else to get at the user label, but we could probably just make it a global constant in lld-macho since the prefix applies to all macOS targets?

[int3]

remove fprintf

[pcc]

lld/MachO/Symbols.h

121

I don't think the "C++ spec" says anything about this. If anything, it would be the Itanium C++ ABI.

139

FWIW, in general I'm not a fan of the idea of computing string constants like this, as it makes it harder to grep the code for strings like ___dso_handle.

[int3]

update

[int3]

lld/MachO/Symbols.h

121

yeah I wasn't super sure what the right names for these things were -- I thought the document describing the ABI would be considered a spec -- but I guess 'spec' connotes 'language spec'...

[int3]

lld/MachO/Symbols.h

139

saw @pcc's comment later on, and I think it's a good reason to keep __dso_handle... also it's nice to be able to write the string inline in the class declaration rather than in the .cpp file.

[int3]

rephrase comment about ABI

[int3]

rebase

[compnerd]

lld/MachO/Symbols.h

139

I'm suggesting that we keep __dso_handle which is still grepable, the prefix itself which is a single _ which is what I was suggesting that we remove. I suppose that its not the end of the world if we don't split it up, but using the IRMangler in LLVM is pretty common place and seems more precise/easier to understand to me.

[int3]

lld/MachO/Symbols.h

139

I tried grepping for IRMangler and didn't find anything (and found a lot of results grepping for mangle). Which class were you thinking of?

[pcc]

lld/MachO/Symbols.h

139

If your starting point is ___dso_handle (for example, if you see that in nm output), it doesn't really help that __dso_handle is greppable.

I would also say that it makes the code harder to understand, by adding an unnecessary level of indirection. In order to understand what mangle("__dso_handle") does I would need to read the definition of mangle and establish that it always just prepends _ on Mach-O, so I know that it always returns "___dso_handle". But if I just see "___dso_handle" I get that knowledge straight away.

Anyway, I don't have much of a horse in this race, that's just my viewpoint.

[MaskRay]

lld/MachO/Symbols.h

139

I agree that having literal 3-underline ___dso_handle helps with grepping.

[int3]

Bump. Could this get a stamp?

[smeenai]

lld/MachO/Symbols.h

139

I'm good with leaving the underscore in.

lld/test/MachO/dso-handle-no-override.s

4–8

What do you think about giving an explicit error vs. silently ignoring the user-defined symbol?

The local symbol thing is unfortunate, but I don't see a good way to handle it. (Plus I think symbols beginning with double underscores are supposed to be reserved for the implementation, so if a user has their own __dso_handle symbol they're in undefined territory anyway.)

[int3]

lld/test/MachO/dso-handle-no-override.s

4–8

Giving an explicit error is not much less complicated than discarding it in favor of __dso_handle -- we'd still need to make the createDefined function check that every symbol it's creating doesn't have that name. Not difficult, just ugly...

[smeenai]

lld/test/MachO/dso-handle-no-override.s

4–8

Not sure I follow? We're calling addDSOHandle after all the input files have been read (and their symbols added to the symbol table), correct? In that case, we'd just need to check that no symbol with that name already existed when we inserted it. Unless you meant to handle local symbols, in which case, I agree that seems ugly and probably not worth it.

[int3]

lld/test/MachO/dso-handle-no-override.s

4–8

oh, I'd thought you were talking about the local-defined symbol. Yeah giving an explicit error for the global one wouldn't be a bad idea

[int3]

make duplicate definition an error

lld/MachO/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "OutputSection.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
if (!orderFile.empty())
     parseOrderFile(orderFile);
 
   if (config->outputType == MH_EXECUTE && !isa<Defined>(config->entry)) {
     error("undefined symbol: " + config->entry->getName());
     return false;
   }
 
   createSyntheticSections();
+  symtab->addDSOHandle(in.header);
 
   // Initialize InputSections.
   for (InputFile *file : inputFiles) {
     for (SubsectionMap &map : file->subsections) {
       for (auto &p : map) {
         InputSection *isec = p.second;
         inputSections.push_back(isec);
       }

lld/MachO/SymbolTable.h

 #include "llvm/Object/Archive.h"
 
 namespace lld {
 namespace macho {
 
 class ArchiveFile;
 class DylibFile;
 class InputSection;
+class MachHeaderSection;
 class Symbol;
 
 class SymbolTable {
 public:
   Symbol *addDefined(StringRef name, InputSection *isec, uint32_t value,
                      bool isWeakDef);
 
   Symbol *addUndefined(StringRef name);
 
   Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef);
 
   Symbol *addLazy(StringRef name, ArchiveFile *file,
                   const llvm::object::Archive::Symbol &sym);
 
+  Symbol *addDSOHandle(const MachHeaderSection *);
+
   ArrayRef<Symbol *> getSymbols() const { return symVector; }
   Symbol *find(StringRef name);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef name);
   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
   std::vector<Symbol *> symVector;
 };
 
 extern SymbolTable *symtab;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SymbolTable.cpp

Symbol *SymbolTable::addLazy(StringRef name, ArchiveFile *file,
 
   if (wasInserted)
     replaceSymbol<LazySymbol>(s, file, sym);
   else if (isa<Undefined>(s) || (isa<DylibSymbol>(s) && s->isWeakDef))
     file->fetch(sym);
   return s;
 }
 
+Symbol *SymbolTable::addDSOHandle(const MachHeaderSection *header) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(DSOHandle::name);
+  replaceSymbol<DSOHandle>(s, header);
+  return s;
+}
+
 SymbolTable *macho::symtab;

lld/MachO/Symbols.h

 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 #include "llvm/Object/Archive.h"
 
 namespace lld {
 namespace macho {
 
 class InputSection;
+class MachHeaderSection;
 class DylibFile;
 class ArchiveFile;
 
 struct StringRefZ {
   StringRefZ(const char *s) : data(s), size(-1) {}
   StringRefZ(StringRef s) : data(s.data()), size(s.size()) {}
 
   const char *data;
   const uint32_t size;
 };
 
 class Symbol {
 public:
   enum Kind {
     DefinedKind,
     UndefinedKind,
     DylibKind,
     LazyKind,
+    DSOHandleKind,
   };
 
+  virtual ~Symbol() {}
+
   Kind kind() const { return static_cast<Kind>(symbolKind); }
 
   StringRef getName() const { return {name.data, name.size}; }
 
-  uint64_t getVA() const;
+  virtual uint64_t getVA() const { return 0; }
 
-  uint64_t getFileOffset() const;
+  virtual uint64_t getFileOffset() const {
+    llvm_unreachable("attempt to get an offset from a non-defined symbol");
+  }
 
   uint32_t gotIndex = UINT32_MAX;
 
   // This bool is only meaningful for Defineds and DylibSymbols.
   const bool isWeakDef;
 
 protected:
   Symbol(Kind k, StringRefZ name, bool isWeakDef)
       : isWeakDef(isWeakDef), symbolKind(k), name(name) {}
 
   Kind symbolKind;
   StringRefZ name;
 };
 
 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputSection *isec, uint32_t value, bool isWeakDef)
       : Symbol(DefinedKind, name, isWeakDef), isec(isec), value(value) {}
 
+  uint64_t getVA() const override { return isec->getVA() + value; }
+
+  uint64_t getFileOffset() const override {
+    return isec->getFileOffset() + value;
+  }
+
   InputSection *isec;
   uint32_t value;
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 };
 
 class Undefined : public Symbol {
 public:
public:
 
   void fetchArchiveMember();
 
 private:
   ArchiveFile *file;
   const llvm::object::Archive::Symbol sym;
 };
 
-inline uint64_t Symbol::getVA() const {
-  if (auto *d = dyn_cast<Defined>(this))
-    return d->isec->getVA() + d->value;
-  return 0;
-}
+// The C++ ABI requires dylibs to pass a pointer to __cxa_atexit which does
+// e.g. cleanup of static global variables. The C++ spec 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.
+//
+// This effectively functions like a Defined symbol, but it doesn't belong to
+// an InputSection, and it has precedence over Defined symbols.
+class DSOHandle : public Symbol {
+public:
+  DSOHandle(const MachHeaderSection *header)
+      : Symbol(DSOHandleKind, name, /*isWeakDef*/ false), header(header) {}
 
-inline uint64_t Symbol::getFileOffset() const {
-  if (auto *d = dyn_cast<Defined>(this))
-    return d->isec->getFileOffset() + d->value;
-  llvm_unreachable("attempt to get an offset from an undefined symbol");
-}
+  const MachHeaderSection *header;
+
+  uint64_t getVA() const override;
+
+  uint64_t getFileOffset() const override;
+
+  static const constexpr StringRef name = "___dso_handle";
+
+  static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
+};
 
 union SymbolUnion {
   alignas(Defined) char a[sizeof(Defined)];
   alignas(Undefined) char b[sizeof(Undefined)];
   alignas(DylibSymbol) char c[sizeof(DylibSymbol)];
   alignas(LazySymbol) char d[sizeof(LazySymbol)];
 };
 

lld/MachO/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "InputFiles.h"
+#include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
 void LazySymbol::fetchArchiveMember() { file->fetch(sym); }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &sym) {
   if (Optional<std::string> s = demangleItanium(sym.getName()))
     return *s;
   return std::string(sym.getName());
 }
+
+uint64_t DSOHandle::getVA() const { return header->addr; }
+
+uint64_t DSOHandle::getFileOffset() const { return header->fileOff; }
+
+constexpr StringRef DSOHandle::name;

lld/MachO/SyntheticSections.h

public:
   void writeTo(uint8_t *buf) const override;
 
 private:
   StringTableSection &stringTableSection;
   std::vector<SymtabEntry> symbols;
 };
 
 struct InStruct {
+  MachHeaderSection *header = nullptr;
   BindingSection *binding = nullptr;
   GotSection *got = nullptr;
   LazyPointerSection *lazyPointers = nullptr;
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   ImageLoaderCacheSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Writer.cpp

public:
   void openFile();
   void writeSections();
 
   void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
-  MachHeaderSection *headerSection = nullptr;
+  MachHeaderSection *header = nullptr;
   LazyBindingSection *lazyBindingSection = nullptr;
   ExportSection *exportSection = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
for (Reloc &r : isec->relocs) {
         else
           target->prepareSymbolRelocation(*s, isec, r);
       }
     }
   }
 }
 
 void Writer::createLoadCommands() {
-  headerSection->addLoadCommand(
+  in.header->addLoadCommand(
       make<LCDyldInfo>(in.binding, lazyBindingSection, exportSection));
-  headerSection->addLoadCommand(
-      make<LCSymtab>(symtabSection, stringTableSection));
-  headerSection->addLoadCommand(make<LCDysymtab>());
+  in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
+  in.header->addLoadCommand(make<LCDysymtab>());
 
   switch (config->outputType) {
   case MH_EXECUTE:
-    headerSection->addLoadCommand(make<LCMain>());
-    headerSection->addLoadCommand(make<LCLoadDylinker>());
+    in.header->addLoadCommand(make<LCMain>());
+    in.header->addLoadCommand(make<LCLoadDylinker>());
     break;
   case MH_DYLIB:
-    headerSection->addLoadCommand(
-        make<LCDylib>(LC_ID_DYLIB, config->installName));
+    in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName));
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
-    headerSection->addLoadCommand(make<LCSegment>(seg->name, seg));
+    in.header->addLoadCommand(make<LCSegment>(seg->name, seg));
     seg->index = segIndex++;
   }
 
   uint64_t dylibOrdinal = 1;
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
-      headerSection->addLoadCommand(
+      in.header->addLoadCommand(
           make<LCDylib>(LC_LOAD_DYLIB, dylibFile->dylibName));
       dylibFile->ordinal = dylibOrdinal++;
 
       if (dylibFile->reexport)
-        headerSection->addLoadCommand(
+        in.header->addLoadCommand(
             make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->dylibName));
     }
   }
 }
 
 static size_t getSymbolPriority(const SymbolPriorityEntry &entry,
                                 const InputFile &file) {
   return std::max(entry.objectFiles.lookup(sys::path::filename(file.getName())),
for (auto *osec : seg->getSections()) {
         }
       }
     }
   }
 }
 
 void Writer::createOutputSections() {
   // First, create hidden sections
-  headerSection = make<MachHeaderSection>();
   lazyBindingSection = make<LazyBindingSection>();
   stringTableSection = make<StringTableSection>();
   symtabSection = make<SymtabSection>(*stringTableSection);
   exportSection = make<ExportSection>();
 
   switch (config->outputType) {
   case MH_EXECUTE:
     make<PageZeroSection>();
void Writer::run() {
 
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
 void macho::writeResult() { Writer().run(); }
 
 void macho::createSyntheticSections() {
+  in.header = make<MachHeaderSection>();
   in.binding = make<BindingSection>();
   in.got = make<GotSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.imageLoaderCache = make<ImageLoaderCacheSection>();
 }

lld/test/MachO/dso-handle-no-override.s

+# REQUIRES: x86
+
+## If for some bizarre reason the input file defines its own ___dso_handle, we
+## should ignore it. At least, we've implemented this behavior if the
+## conflicting symbol is a global. A local symbol of the same name will still
+## take priority in our implementation, unlike in ld64. But that's a pretty
+## far-out edge case that should be safe to ignore.
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: lld -flavor darwinnew -dylib %t.o -o %t.dylib
+# RUN: llvm-objdump -d --no-show-raw-insn %t.dylib | FileCheck %s --check-prefix=DYLIB-CHECK
+# DYLIB-CHECK: leaq {{.*}} # 0
+
+.globl _main, ___dso_handle
+.text
+_main:
+  leaq ___dso_handle(%rip), %rdx
+  ret
+
+___dso_handle:
+  .space 1

lld/test/MachO/dso-handle.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+
+# RUN: lld -flavor darwinnew %t.o -o %t
+# RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
+# CHECK: leaq {{.*}} # 100000000
+
+# RUN: lld -flavor darwinnew -dylib %t.o -o %t.dylib
+# RUN: llvm-objdump -d --no-show-raw-insn %t.dylib | FileCheck %s --check-prefix=DYLIB-CHECK
+# DYLIB-CHECK: leaq {{.*}} # 0
+
+.globl _main
+.text
+_main:
+  leaq ___dso_handle(%rip), %rdx
+  ret