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

[int3]

Summary

Add logic for emitting the correct set of load commands and segments when -dylib is passed.

I haven't gotten to implementing a real export trie yet, so we can only emit a single symbol, but it's enough to replace the YAML test files introduced in D76252.

Depends on D76742: [lld-macho] Add basic symbol table output.

[int3]

make error messages lowercase

[int3]

rebase

[int3]

update test to use symtab addresses

[ruiu]

lld/MachO/Driver.cpp

150–152

Does this have to be in the for loop?

153–155

Do you have to process this option in a for loop? It looks like you can do somethin glike

config->outputFile = args.getLastArgValue(OPT_o, "a.out");
config->installName = args.getLastArgValue(OPT_install_name, config->outputFile);

lld/MachO/SyntheticSections.h

99

I'd write a class comment.

[int3]

address comments

lld/MachO/Driver.cpp

153–155

Oh, that's indeed nicer. Thanks!

[ruiu]

LGTM

[int3]

rebase

[int3]

rebase

[smeenai]

Nice!

lld/MachO/SyntheticSections.cpp

142

This can be done in a follow-up, but we should be checking if the symbol has hidden visibility before exporting it, right?

lld/MachO/SyntheticSections.h

24

Nit: why the trailing underscore?

lld/include/lld/Common/Sort.h

1 ↗

(On Diff #254341)

Was this meant to be part of a previous diff?

lld/test/MachO/dylib.s

7

Where's the corresponding FileCheck for these?

11

Which part of the test is checking this?

13

Is it possible to test these via objdump or readobj instead of obj2yaml? That's more conventional in LLD tests, and their output is probably a bit more stable.

[int3]

rebase

[int3]

address comments

[int3]

lld/MachO/SyntheticSections.cpp

142

yeah probably. I'll add a TODO

lld/MachO/SyntheticSections.h

24

export is a reserved keyword in C++ :)

lld/include/lld/Common/Sort.h

1 ↗

(On Diff #254341)

ugh, rebasing is hard

lld/test/MachO/dylib.s

7

oops

11

The line directly below -- it's checking that lld doesn't error out even when passed -e missing_entry. I'll elaborate the comment.

13

Yeah we can use llvm-objdump --macho --dylib-id. While checking that out I realize we can look for load commands in general using llvm-objdump --macho --all-headers, so load-commands.s can use that too and the test suite can be entirely free of obj2yaml

[int3]

update

[ruiu]

LGTM

lld/MachO/SyntheticSections.cpp

154

auto * -> const Defined *

lld/MachO/Writer.cpp

356

When we reach here, it's an internal error. So this line should be llvm_unreachable rather than error.

395

Ditto

[MaskRay]

lld/test/MachO/symtab.s

18–19

It seems that the previous diff should not add the symbols which will be deleted by this diff...

[int3]

order section name declarations by output order

[int3]

rebase

[smeenai]

lld/MachO/Writer.cpp

356

This one still needs addressing.

395

Same here.

lld/test/MachO/symtab.s

18–19

The export trie diff will restore these symbols, so I think this is okay. (It's because this diff only supports exporting a single symbol.)

[int3]

address comments

[smeenai]

Reverted in rGb52bc2653bbc8da852a804afbb34836bb7f1e58a because of a UBSan failure in D76742.

[int3]

Huh, didn't realize that reverting a diff reopens it in LLVM's Phabricator. This has been relanded as rG62b8f32f7699: [lld-macho][reland] Add support for emitting dylibs with a single symbol.

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

 using namespace llvm::MachO;
 
 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;
 }
 
 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