[lld-macho][reland] Add support for emitting dylibs with a single symbol

[int3]

Summary

This got reverted due to UBSAN errors in a diff lower in the stack,
which is being fixed in D79050: [lld-macho][reland] Add basic symbol table output. This diff is otherwise identical to
the original D76908: [lld-macho] Add support for emitting dylibs with a single symbol.

Depends on D79050.

[smeenai]

(this was a recommit, so I just landed it without an explicit accept)

[MaskRay]

For a reland, you could reuse the old differential and click "Reopen" instead of opening a new one.

Commits will clearly show what commits are associated with that differential revision.

[int3]

Yeah I belatedly noticed that the original differentials were reopened after the unland. FB's Phabricator doesn't work that way so it came as a bit of a surprise. Will keep it in mind for future un/relands.

[smeenai]

In D79051#2009479, @int3 wrote:

Yeah I belatedly noticed that the original differentials were reopened after the unland. FB's Phabricator doesn't work that way so it came as a bit of a surprise. Will keep it in mind for future un/relands.

I reopened them manually. I don't think they automatically reopen.

[int3]

Ahh I see, got it

lld/MachO/Config.h

 //===- Config.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_CONFIG_H
 #define LLD_MACHO_CONFIG_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/MachO.h"
 
 #include <vector>
 
 namespace lld {
 namespace macho {
 
 class Symbol;
 
 struct Configuration {
-  llvm::StringRef outputFile;
   Symbol *entry;
-
+  llvm::MachO::HeaderFileType outputType;
+  llvm::StringRef installName;
+  llvm::StringRef outputFile;
   std::vector<llvm::StringRef> searchPaths;
 };
 
 extern Configuration *config;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Driver.cpp

bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
   target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
+  config->installName =
+      args.getLastArgValue(OPT_install_name, config->outputFile);
   config->searchPaths = getSearchPaths(args);
+  config->outputType = args.hasArg(OPT_dylib) ? MH_DYLIB : MH_EXECUTE;
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     std::vector<StringRef> &searchPaths = config->searchPaths;
     message("Library search paths:\n" +
             llvm::join(searchPaths.begin(), searchPaths.end(), "\n"));
     freeArena();
     return !errorCount();
   }
 
   for (opt::Arg *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_INPUT:
       addFile(arg->getValue());
       break;
     case OPT_l:
       if (Optional<std::string> path = findDylib(arg->getValue()))
         addFile(*path);
       break;
     }
   }
 
-  if (!isa<Defined>(config->entry)) {
+  if (config->outputType == MH_EXECUTE && !isa<Defined>(config->entry)) {
     error("undefined symbol: " + config->entry->getName());
     return false;
   }
 
   createSyntheticSections();
 
   // Initialize InputSections.
   for (InputFile *file : inputFiles)

lld/MachO/Options.td

 include "llvm/Option/OptParser.td"
 
 def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Add directory to library search path">;
 
 def Z: Flag<["-"], "Z">,
   HelpText<"Do not add standard directories to library search path">;
 
 def arch: Separate<["-"], "arch">, MetaVarName<"<arch-name>">,
   HelpText<"Architecture to link">;
 
+def dylib: Flag<["-"], "dylib">, HelpText<"Emit a shared library">;
+
 def e: Separate<["-"], "e">, HelpText<"Name of entry point symbol">;
 
+def install_name: Separate<["-"], "install_name">,
+  MetaVarName<"<install-name>">,
+  HelpText<"Set the install path of the dynamic library.">;
+
 def l: Joined<["-"], "l">, MetaVarName<"<libname>">,
   HelpText<"Base name of library searched for in -L directories">;
 
 def o: Separate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def v: Flag<["-"], "v">, HelpText<"Display the version number and exit">;
 
 // Ignored options
 def: Flag<["-"], "demangle">;
 def: Flag<["-"], "dynamic">;
 def: Flag<["-"], "no_deduplicate">;
 def: Separate<["-"], "lto_library">;
 def: Separate<["-"], "macosx_version_min">;

lld/MachO/SyntheticSections.h

 namespace lld {
 namespace macho {
 
 namespace section_names {
 
 constexpr const char *pageZero = "__pagezero";
 constexpr const char *header = "__mach_header";
 constexpr const char *binding = "__binding";
+constexpr const char *export_ = "__export";
 constexpr const char *symbolTable = "__symbol_table";
 constexpr const char *stringTable = "__string_table";
 
 } // namespace section_names
 
 class DylibSymbol;
 class LoadCommand;
 
public:
   // section headers.
   bool isHidden() const override { return true; }
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) override;
 
   SmallVector<char, 128> contents;
 };
 
+// Stores a trie that describes the set of exported symbols.
+class ExportSection : public InputSection {
+public:
+  ExportSection();
+  void finalizeContents();
+  size_t getSize() const override { return contents.size(); }
+  // Like other sections in __LINKEDIT, the export section is special: its
+  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
+  // section headers.
+  bool isHidden() const override { return true; }
+  void writeTo(uint8_t *buf) override;
+
+  SmallVector<char, 128> contents;
+};
+
 // Stores the strings referenced by the symbol table.
 class StringTableSection : public InputSection {
 public:
   StringTableSection();
   // Returns the start offset of the added string.
   uint32_t addString(StringRef);
   size_t getSize() const override { return size; }
   // Like other sections in __LINKEDIT, the string table section is special: its

lld/MachO/SyntheticSections.cpp

 //===- SyntheticSections.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 "SyntheticSections.h"
+#include "Config.h"
 #include "InputFiles.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Support/EndianStream.h"
size_t MachHeaderSection::getSize() const {
   return sizeof(mach_header_64) + sizeOfCmds;
 }
 
 void MachHeaderSection::writeTo(uint8_t *buf) {
   auto *hdr = reinterpret_cast<mach_header_64 *>(buf);
   hdr->magic = MH_MAGIC_64;
   hdr->cputype = CPU_TYPE_X86_64;
   hdr->cpusubtype = CPU_SUBTYPE_X86_64_ALL | CPU_SUBTYPE_LIB64;
-  hdr->filetype = MH_EXECUTE;
+  hdr->filetype = config->outputType;
   hdr->ncmds = loadCommands.size();
   hdr->sizeofcmds = sizeOfCmds;
   hdr->flags = MH_NOUNDEFS | MH_DYLDLINK | MH_TWOLEVEL;
 
   uint8_t *p = reinterpret_cast<uint8_t *>(hdr + 1);
   for (LoadCommand *lc : loadCommands) {
     lc->writeTo(p);
     p += lc->getSize();
void BindingSection::finalizeContents() {
 
   os << static_cast<uint8_t>(BIND_OPCODE_DONE);
 }
 
 void BindingSection::writeTo(uint8_t *buf) {
   memcpy(buf, contents.data(), contents.size());
 }
 
+ExportSection::ExportSection() {
+  segname = segment_names::linkEdit;
+  name = section_names::export_;
+}
+
+void ExportSection::finalizeContents() {
+  raw_svector_ostream os{contents};
+  std::vector<const Defined *> exported;
+  // TODO: We should check symbol visibility.
+  for (const Symbol *sym : symtab->getSymbols())
+    if (auto *defined = dyn_cast<Defined>(sym))
+      exported.push_back(defined);
+
+  if (exported.empty())
+    return;
+
+  if (exported.size() > 1) {
+    error("TODO: Unable to export more than 1 symbol");
+    return;
+  }
+
+  const Defined *sym = exported.front();
+  os << (char)0; // Indicates non-leaf node
+  os << (char)1; // # of children
+  os << sym->getName() << '\0';
+  encodeULEB128(sym->getName().size() + 4, os); // Leaf offset
+
+  // Leaf node
+  uint64_t addr = sym->getVA() + ImageBase;
+  os << (char)(1 + getULEB128Size(addr));
+  os << (char)0; // Flags
+  encodeULEB128(addr, os);
+  os << (char)0; // Terminator
+}
+
+void ExportSection::writeTo(uint8_t *buf) {
+  memcpy(buf, contents.data(), contents.size());
+}
+
 SymtabSection::SymtabSection(StringTableSection &stringTableSection)
     : stringTableSection(stringTableSection) {
   segname = segment_names::linkEdit;
   name = section_names::symbolTable;
   // TODO: When we introduce the SyntheticSections superclass, we should make
   // all synthetic sections aligned to WordSize by default.
   align = WordSize;
 }
 
 size_t SymtabSection::getSize() const {
   return symbols.size() * sizeof(nlist_64);
 }
 
 void SymtabSection::finalizeContents() {
-  // TODO: We should filter out some symbols.
+  // TODO support other symbol types
   for (Symbol *sym : symtab->getSymbols())
+    if (isa<Defined>(sym))
       symbols.push_back({sym, stringTableSection.addString(sym->getName())});
 }
 
 void SymtabSection::writeTo(uint8_t *buf) {
   auto *nList = reinterpret_cast<nlist_64 *>(buf);
   for (const SymtabEntry &entry : symbols) {
+    nList->n_strx = entry.strx;
     // TODO support other symbol types
     // TODO populate n_desc
     if (auto defined = dyn_cast<Defined>(entry.sym)) {
-      nList->n_strx = entry.strx;
       nList->n_type = N_EXT | N_SECT;
       nList->n_sect = defined->isec->sectionIndex;
       // For the N_SECT symbol type, n_value is the address of the symbol
       nList->n_value = defined->value + defined->isec->addr;
     }
-
     ++nList;
   }
 }
 
 StringTableSection::StringTableSection() {
   segname = segment_names::linkEdit;
   name = section_names::stringTable;
 }

lld/MachO/Writer.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
public:
 
   void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *headerSection = nullptr;
   BindingSection *bindingSection = nullptr;
-  SymtabSection *symtabSection = 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 {
 public:
-  LCDyldInfo(BindingSection *bindingSection) : bindingSection(bindingSection) {}
+  LCDyldInfo(BindingSection *bindingSection, ExportSection *exportSection)
+      : bindingSection(bindingSection), exportSection(exportSection) {}
 
   uint32_t getSize() const override { return sizeof(dyld_info_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dyld_info_command *>(buf);
     c->cmd = LC_DYLD_INFO_ONLY;
     c->cmdsize = getSize();
     if (bindingSection->isNeeded()) {
       c->bind_off = bindingSection->getFileOffset();
       c->bind_size = bindingSection->getFileSize();
     }
-    c->export_off = exportOff;
-    c->export_size = exportSize;
+    if (exportSection->isNeeded()) {
+      c->export_off = exportSection->getFileOffset();
+      c->export_size = exportSection->getFileSize();
+    }
   }
 
   BindingSection *bindingSection;
-  uint64_t exportOff = 0;
-  uint64_t exportSize = 0;
+  ExportSection *exportSection;
 };
 
 class LCDysymtab : public LoadCommand {
 public:
   uint32_t getSize() const override { return sizeof(dysymtab_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dysymtab_command *>(buf);
void writeTo(uint8_t *buf) const override {
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
 private:
   StringRef path;
 };
 
+class LCIdDylib : public LoadCommand {
+public:
+  LCIdDylib(StringRef name) : name(name) {}
+
+  uint32_t getSize() const override {
+    return alignTo(sizeof(dylib_command) + name.size() + 1, 8);
+  }
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<dylib_command *>(buf);
+    buf += sizeof(dylib_command);
+
+    c->cmd = LC_ID_DYLIB;
+    c->cmdsize = getSize();
+    c->dylib.name = sizeof(dylib_command);
+
+    memcpy(buf, name.data(), name.size());
+    buf[name.size()] = '\0';
+  }
+
+private:
+  StringRef name;
+};
+
 class LCLoadDylinker : public LoadCommand {
 public:
   uint32_t getSize() const override {
     return alignTo(sizeof(dylinker_command) + path.size() + 1, 8);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dylinker_command *>(buf);
std::vector<std::pair<StringRef, std::vector<StringRef>>> ordering{
         {segment_names::pageZero, {}},
         {segment_names::text, {section_names::header}},
         {defaultPosition, {}},
         // Make sure __LINKEDIT is the last segment (i.e. all its hidden
         // sections must be ordered after other sections).
         {segment_names::linkEdit,
          {
              section_names::binding,
+             section_names::export_,
              section_names::symbolTable,
              section_names::stringTable,
          }},
     };
 
     for (uint32_t i = 0, n = ordering.size(); i < n; ++i) {
       auto &p = ordering[i];
       StringRef segname = p.first;
void Writer::scanRelocations() {
   for (InputSection *sect : inputSections)
     for (Reloc &r : sect->relocs)
       if (auto *s = r.target.dyn_cast<Symbol *>())
         if (auto *dylibSymbol = dyn_cast<DylibSymbol>(s))
           in.got->addEntry(*dylibSymbol);
 }
 
 void Writer::createLoadCommands() {
-  headerSection->addLoadCommand(make<LCDyldInfo>(bindingSection));
-  headerSection->addLoadCommand(make<LCLoadDylinker>());
+  headerSection->addLoadCommand(
+      make<LCDyldInfo>(bindingSection, exportSection));
   headerSection->addLoadCommand(
       make<LCSymtab>(symtabSection, stringTableSection));
   headerSection->addLoadCommand(make<LCDysymtab>());
+
+  switch (config->outputType) {
+  case MH_EXECUTE:
     headerSection->addLoadCommand(make<LCMain>());
+    headerSection->addLoadCommand(make<LCLoadDylinker>());
+    break;
+  case MH_DYLIB:
+    headerSection->addLoadCommand(make<LCIdDylib>(config->installName));
+    break;
+  default:
+    llvm_unreachable("unhandled output file type");
+  }
 
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     if (seg->isNeeded()) {
       headerSection->addLoadCommand(make<LCSegment>(seg->name, seg));
       seg->index = segIndex++;
     }
   }
headerSection->addLoadCommand(
       make<LCLoadDylib>("/usr/lib/libSystem.B.dylib"));
 }
 
 void Writer::createHiddenSections() {
   headerSection = createInputSection<MachHeaderSection>();
   bindingSection = createInputSection<BindingSection>();
   stringTableSection = createInputSection<StringTableSection>();
   symtabSection = createInputSection<SymtabSection>(*stringTableSection);
+  exportSection = createInputSection<ExportSection>();
+
+  switch (config->outputType) {
+  case MH_EXECUTE:
     createInputSection<PageZeroSection>();
+    break;
+  case MH_DYLIB:
+    break;
+  default:
+    llvm_unreachable("unhandled output file type");
+  }
 }
 
 void Writer::sortSections() {
   llvm::stable_sort(inputSections, SectionComparator());
 
   // TODO This is wrong; input sections ought to be grouped into
   // output sections, which are then organized like this.
   uint32_t sectionIndex = 0;
void Writer::run() {
   // Note that at this point, __LINKEDIT sections are empty, but we need to
   // determine addresses of other segments/sections before generating its
   // contents.
   for (OutputSegment *seg : outputSegments)
     assignAddresses(seg);
 
   // Fill __LINKEDIT contents.
   bindingSection->finalizeContents();
+  exportSection->finalizeContents();
   symtabSection->finalizeContents();
 
   // Now that __LINKEDIT is filled out, do a proper calculation of its
   // addresses and offsets. We don't have to recalculate the other segments
   // since sortSections() ensures that __LINKEDIT is the last segment.
   assignAddresses(getOutputSegment(segment_names::linkEdit));
 
   openFile();

lld/test/MachO/Inputs/goodbye-dylib.yaml

-## This yaml file was originally generated from linking the following source
-## input with ld64:
-##
-## .section __TEXT,__cstring
-## .globl _goodbye_world
-##
-## _goodbye_world:
-## .asciz "Goodbye world!\n"
-##
-## When lld can produce dylibs, we will use that instead for our test setup.
-
---- !mach-o
-FileHeader:
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x00000003
-  filetype:        0x00000006
-  ncmds:           11
-  sizeofcmds:      624
-  flags:           0x00100085
-  reserved:        0x00000000
-LoadCommands:
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         232
-    segname:         __TEXT
-    vmaddr:          0
-    vmsize:          4096
-    fileoff:         0
-    filesize:        4096
-    maxprot:         5
-    initprot:        5
-    nsects:          2
-    flags:           0
-    Sections:
-      - sectname:        __text
-        segname:         __TEXT
-        addr:            0x0000000000000FF0
-        size:            0
-        offset:          0x00000FF0
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-        content:         ''
-      - sectname:        __cstring
-        segname:         __TEXT
-        addr:            0x0000000000000FF0
-        size:            16
-        offset:          0x00000FF0
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000002
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-        content:         476F6F6462796520776F726C64210A00
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         72
-    segname:         __LINKEDIT
-    vmaddr:          4096
-    vmsize:          4096
-    fileoff:         4096
-    filesize:        72
-    maxprot:         1
-    initprot:        1
-    nsects:          0
-    flags:           0
-  - cmd:             LC_ID_DYLIB
-    cmdsize:         64
-    dylib:
-      name:            24
-      timestamp:       1
-      current_version: 0
-      compatibility_version: 0
-    PayloadString:   '@executable_path/libgoodbye.dylib'
-    ZeroPadBytes:    7
-  - cmd:             LC_DYLD_INFO_ONLY
-    cmdsize:         48
-    rebase_off:      0
-    rebase_size:     0
-    bind_off:        0
-    bind_size:       0
-    weak_bind_off:   0
-    weak_bind_size:  0
-    lazy_bind_off:   0
-    lazy_bind_size:  0
-    export_off:      4096
-    export_size:     24
-  - cmd:             LC_SYMTAB
-    cmdsize:         24
-    symoff:          4128
-    nsyms:           1
-    stroff:          4144
-    strsize:         24
-  - cmd:             LC_DYSYMTAB
-    cmdsize:         80
-    ilocalsym:       0
-    nlocalsym:       0
-    iextdefsym:      0
-    nextdefsym:      1
-    iundefsym:       1
-    nundefsym:       0
-    tocoff:          0
-    ntoc:            0
-    modtaboff:       0
-    nmodtab:         0
-    extrefsymoff:    0
-    nextrefsyms:     0
-    indirectsymoff:  0
-    nindirectsyms:   0
-    extreloff:       0
-    nextrel:         0
-    locreloff:       0
-    nlocrel:         0
-  - cmd:             LC_UUID
-    cmdsize:         24
-    uuid:            EA09CDDC-A3EA-3EB9-8C4F-334077FE6E5A
-  - cmd:             LC_BUILD_VERSION
-    cmdsize:         32
-    platform:        1
-    minos:           659200
-    sdk:             659200
-    ntools:          1
-    Tools:
-      - tool:            3
-        version:         34734080
-  - cmd:             LC_SOURCE_VERSION
-    cmdsize:         16
-    version:         0
-  - cmd:             LC_FUNCTION_STARTS
-    cmdsize:         16
-    dataoff:         4120
-    datasize:        8
-  - cmd:             LC_DATA_IN_CODE
-    cmdsize:         16
-    dataoff:         4128
-    datasize:        0
-LinkEditData:
-  ExportTrie:
-    TerminalSize:    0
-    NodeOffset:      0
-    Name:            ''
-    Flags:           0x0000000000000000
-    Address:         0x0000000000000000
-    Other:           0x0000000000000000
-    ImportName:      ''
-    Children:
-      - TerminalSize:    3
-        NodeOffset:      18
-        Name:            _goodbye_world
-        Flags:           0x0000000000000000
-        Address:         0x0000000000000FF0
-        Other:           0x0000000000000000
-        ImportName:      ''
-  NameList:
-    - n_strx:          2
-      n_type:          0x0F
-      n_sect:          2
-      n_desc:          0
-      n_value:         4080
-  StringTable:
-    - ' '
-    - _goodbye_world
-    - ''
-    - ''
-    - ''
-    - ''
-    - ''
-    - ''
-    - ''
-...

lld/test/MachO/Inputs/hello-dylib.yaml

-## This yaml file was originally generated from linking the following source
-## input with ld64:
-##
-## .section __TEXT,__cstring
-## .globl _hello_world
-##
-## _hello_world:
-## .asciz "Hello world!\n"
-##
-## When lld can produce dylibs, we will use that instead for our test setup.
-
---- !mach-o
-FileHeader:
-  magic:           0xFEEDFACF
-  cputype:         0x01000007
-  cpusubtype:      0x00000003
-  filetype:        0x00000006
-  ncmds:           11
-  sizeofcmds:      616
-  flags:           0x00100085
-  reserved:        0x00000000
-LoadCommands:
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         232
-    segname:         __TEXT
-    vmaddr:          0
-    vmsize:          4096
-    fileoff:         0
-    filesize:        4096
-    maxprot:         5
-    initprot:        5
-    nsects:          2
-    flags:           0
-    Sections:
-      - sectname:        __text
-        segname:         __TEXT
-        addr:            0x0000000000000FF2
-        size:            0
-        offset:          0x00000FF2
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x80000400
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-        content:         ''
-      - sectname:        __cstring
-        segname:         __TEXT
-        addr:            0x0000000000000FF2
-        size:            14
-        offset:          0x00000FF2
-        align:           0
-        reloff:          0x00000000
-        nreloc:          0
-        flags:           0x00000002
-        reserved1:       0x00000000
-        reserved2:       0x00000000
-        reserved3:       0x00000000
-        content:         48656C6C6F20776F726C64210A00
-  - cmd:             LC_SEGMENT_64
-    cmdsize:         72
-    segname:         __LINKEDIT
-    vmaddr:          4096
-    vmsize:          4096
-    fileoff:         4096
-    filesize:        64
-    maxprot:         1
-    initprot:        1
-    nsects:          0
-    flags:           0
-  - cmd:             LC_ID_DYLIB
-    cmdsize:         56
-    dylib:
-      name:            24
-      timestamp:       1
-      current_version: 0
-      compatibility_version: 0
-    PayloadString:   '@executable_path/libhello.dylib'
-    ZeroPadBytes:    1
-  - cmd:             LC_DYLD_INFO_ONLY
-    cmdsize:         48
-    rebase_off:      0
-    rebase_size:     0
-    bind_off:        0
-    bind_size:       0
-    weak_bind_off:   0
-    weak_bind_size:  0
-    lazy_bind_off:   0
-    lazy_bind_size:  0
-    export_off:      4096
-    export_size:     24
-  - cmd:             LC_SYMTAB
-    cmdsize:         24
-    symoff:          4128
-    nsyms:           1
-    stroff:          4144
-    strsize:         16
-  - cmd:             LC_DYSYMTAB
-    cmdsize:         80
-    ilocalsym:       0
-    nlocalsym:       0
-    iextdefsym:      0
-    nextdefsym:      1
-    iundefsym:       1
-    nundefsym:       0
-    tocoff:          0
-    ntoc:            0
-    modtaboff:       0
-    nmodtab:         0
-    extrefsymoff:    0
-    nextrefsyms:     0
-    indirectsymoff:  0
-    nindirectsyms:   0
-    extreloff:       0
-    nextrel:         0
-    locreloff:       0
-    nlocrel:         0
-  - cmd:             LC_UUID
-    cmdsize:         24
-    uuid:            4826226E-9210-3984-A388-D5BD6D6DB368
-  - cmd:             LC_BUILD_VERSION
-    cmdsize:         32
-    platform:        1
-    minos:           659200
-    sdk:             659200
-    ntools:          1
-    Tools:
-      - tool:            3
-        version:         34734080
-  - cmd:             LC_SOURCE_VERSION
-    cmdsize:         16
-    version:         0
-  - cmd:             LC_FUNCTION_STARTS
-    cmdsize:         16
-    dataoff:         4120
-    datasize:        8
-  - cmd:             LC_DATA_IN_CODE
-    cmdsize:         16
-    dataoff:         4128
-    datasize:        0
-LinkEditData:
-  ExportTrie:
-    TerminalSize:    0
-    NodeOffset:      0
-    Name:            ''
-    Flags:           0x0000000000000000
-    Address:         0x0000000000000000
-    Other:           0x0000000000000000
-    ImportName:      ''
-    Children:
-      - TerminalSize:    3
-        NodeOffset:      16
-        Name:            _hello_world
-        Flags:           0x0000000000000000
-        Address:         0x0000000000000FF2
-        Other:           0x0000000000000000
-        ImportName:      ''
-  NameList:
-    - n_strx:          2
-      n_type:          0x0F
-      n_sect:          2
-      n_desc:          0
-      n_value:         4082
-  StringTable:
-    - ' '
-    - _hello_world
-    - ''
-...

lld/test/MachO/Inputs/libgoodbye.s

+.section __TEXT,__cstring
+.globl _goodbye_world
+
+_goodbye_world:
+.asciz "Goodbye world!\n"

lld/test/MachO/Inputs/libhello.s

+.section __TEXT,__cstring
+.globl _hello_world
+
+_hello_world:
+.asciz "Hello world!\n"

lld/test/MachO/dylib.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+
+# RUN: lld -flavor darwinnew -dylib -install_name @executable_path/libfoo.dylib \
+# RUN:   %t.o -o %t.dylib
+# RUN: llvm-objdump --macho --dylib-id %t.dylib | FileCheck %s
+# CHECK: @executable_path/libfoo.dylib
+
+## If we are building a dylib, we shouldn't error out even if we are passed
+## a flag for a missing entry symbol (since dylibs don't have entry symbols).
+## Also check that we come up with the right install name if one isn't
+## specified.
+# RUN: lld -flavor darwinnew -dylib %t.o -o %t.defaultInstallName.dylib -e missing_entry
+# RUN: obj2yaml %t.defaultInstallName.dylib | FileCheck %s -DOUTPUT=%t.defaultInstallName.dylib --check-prefix=DEFAULT-INSTALL-NAME
+# DEFAULT-INSTALL-NAME: [[OUTPUT]]
+
+## Check for the absence of load commands / segments that should not be in a
+## dylib.
+# RUN: llvm-objdump --macho --all-headers %t.dylib | FileCheck %s --check-prefix=NCHECK
+# NCHECK-NOT: cmd LC_LOAD_DYLINKER
+# NCHECK-NOT: cmd LC_MAIN
+# NCHECK-NOT: segname __PAGEZERO
+
+# RUN: llvm-objdump --syms --exports-trie %t.dylib | \
+# RUN:   FileCheck %s --check-prefix=EXPORTS
+# EXPORTS-LABEL: SYMBOL TABLE:
+# EXPORTS:       [[#%x, HELLO_WORLD_ADDR:]] {{.*}} _hello_world
+# EXPORTS-LABEL: Exports trie:
+# EXPORTS:       0x{{0*}}[[#%X, HELLO_WORLD_ADDR]] _hello_world
+
+.section __TEXT,__cstring
+.globl _hello_world
+
+_hello_world:
+.asciz "Hello world!\n"

lld/test/MachO/dylink.s

 # REQUIRES: x86
 # RUN: mkdir -p %t
-# RUN: yaml2obj %p/Inputs/hello-dylib.yaml -o %t/libhello.dylib
-# RUN: yaml2obj %p/Inputs/goodbye-dylib.yaml -o %t/libgoodbye.dylib
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/libhello.s \
+# RUN:   -o %t/libhello.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/libgoodbye.s \
+# RUN:   -o %t/libgoodbye.o
+# RUN: lld -flavor darwinnew -dylib -install_name \
+# RUN:   @executable_path/libhello.dylib %t/libhello.o -o %t/libhello.dylib
+# RUN: lld -flavor darwinnew -dylib -install_name \
+# RUN:   @executable_path/libgoodbye.dylib %t/libgoodbye.o -o %t/libgoodbye.dylib
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/dylink.o
 # RUN: lld -flavor darwinnew -o %t/dylink -Z -L%t -lhello -lgoodbye %t/dylink.o
 # RUN: llvm-objdump --bind -d %t/dylink | FileCheck %s
 
 # CHECK: movq [[#%u, HELLO_OFF:]](%rip), %rsi
 # CHECK-NEXT: [[#%x, HELLO_RIP:]]:
 
 # CHECK: movq [[#%u, GOODBYE_OFF:]](%rip), %rsi

lld/test/MachO/load-commands.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: lld -flavor darwinnew -o %t %t.o
-# RUN: obj2yaml %t | FileCheck %s
 
-# Check for the presence of a couple of load commands that are essential for
-# a working binary.
+## Check for the presence of load commands that are essential for a working
+## executable.
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s
+# CHECK-DAG: cmd LC_DYLD_INFO_ONLY
+# CHECK-DAG: cmd LC_SYMTAB
+# CHECK-DAG: cmd LC_DYSYMTAB
+# CHECK-DAG: cmd LC_MAIN
+# CHECK-DAG: cmd LC_LOAD_DYLINKER
 
-# CHECK-DAG: cmd:             LC_DYLD_INFO_ONLY
-# CHECK-DAG: cmd:             LC_SYMTAB
-# CHECK-DAG: cmd:             LC_DYSYMTAB
+## Check for the absence of load commands that should not be in an executable.
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=NCHECK
+# NCHECK-NOT: cmd: LC_ID_DYLIB
 
 .text
 .global _main
 _main:
   mov $0, %rax
   ret

lld/test/MachO/symtab.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: lld -flavor darwinnew -o %t %t.o
 # RUN: llvm-readobj -symbols %t | FileCheck %s
 
 # CHECK:      Symbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _main
 # CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Section (0xE)
 # CHECK-NEXT:     Section: __text (0x1)
 # CHECK-NEXT:     RefType:
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value:
 # CHECK-NEXT:   }
-# CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Name: bar
-# CHECK-NEXT:     Extern
-# CHECK-NEXT:     Type: Section (0xE)
-# CHECK-NEXT:     Section: __text (0x1)
-# CHECK-NEXT:     RefType:
-# CHECK-NEXT:     Flags [ (0x0)
-# CHECK-NEXT:     ]
-# CHECK-NEXT:     Value:
-# CHECK-NEXT:   }
-# CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Name: foo
-# CHECK-NEXT:     Extern
-# CHECK-NEXT:     Type: Section (0xE)
-# CHECK-NEXT:     Section: __data
-# CHECK-NEXT:     RefType:
-# CHECK-NEXT:     Flags [ (0x0)
-# CHECK-NEXT:     ]
-# CHECK-NEXT:     Value:
-# CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
-.data
-.global foo
-foo:
-  .asciz "Hello world!\n"
-
-.text
-.global bar
 .global _main
 
 _main:
   mov $0, %rax
   ret
-
-bar:
-  mov $2, %rax
-  ret