[lld-macho] Add basic support for linking against dylibs

[int3]

Summary

This diff implements:

• dylib loading (much of which is being restored from @pcc and @ruiu's original work)
• The GOT_LOAD relocation, which allows us to load non-lazy dylib symbols
• Basic bind opcode emission, which tells dyld how to populate the GOT

Depends on D75382.

[int3]

delete extra line

[smeenai]

Initial set of comments. I'm still going through the rest.

lld/MachO/Arch/X86_64.cpp

47

Nit: change the two spaces between "are" and "only" to one

lld/MachO/InputFiles.cpp

78

Universal binary support could technically be a diff by itself. I'd prefer to do so, although it's small enough that I'm not super opposed to folding it into this diff. We definitely need to add tests for it either way. llvm-lipo is complete enough to be used for the tests.

I'd also note in the commit message that some of this functionality is being restored from @pcc and @ruiu's initial commit, for completeness.

89

We should add some sort of checking here to prevent going out of bounds of the file (if you have a ridiculously large nfat_arch in a malformed file, for example). We should also add tests for the error conditions here if possible (assuming yaml2obj lets us construct malformed universal binaries that would trigger the conditions).

99

I believe ld64 warns if you give it a universal binary input file and it can't find any slices for the architecture being linked. We should do the same.

246

Is it valid to not have an LC_ID_DYLIB load command? If it is, should we figure out a fallback dylibName? If not, we should error. (Also, we should add tests for this either way if possible.)

251

Is it valid to not have a symtab? If not, we should error.

266

Unnecessary comment change? We aren't adding support for archive files yet. (CC @Ktwu, this'll need to be adjusted when archive file support is added.)

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

2

Description for hello and goodbye seems swapped.

[MaskRay]

lld/MachO/Arch/X86_64.cpp

38

This message enhancement should be moved to the initial patch.

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

2

Use ## for comments and # for RUN and CHECK lines.

109

Are all these fields important? I think we probably should think what fields are optional and improve yaml2obj. Otherwise the verbosity can make tests a lot more complex.

lld/test/MachO/dylink.s

4

> -> -o

8

Should obj2yaml and llvm-objdump -d tests be separated?

[ruiu]

lld/MachO/Arch/X86_64.cpp

38

Yeah, but I'm not worried about the exact order and the contents of initial patch series, as this is going to be submitted as soon as the first patch is submitted, and no one will be using the feature only with the first patch, so I think I'm fine with this.

lld/MachO/Target.h

18

Are you going to make it work only for 64-bit platforms? IIRC, both macOS and iOS are dropping 32-bit app support, so it is probably a good choice to not support 32-bit, but just to confirm.

lld/MachO/Writer.cpp

316

I wonder if you directly dyn_cast to DylibSymbol * as r.target.dyn_cast<DylibSymbol *>().

334

Can you add a comment as to what dyld info contains?

[int3]

address comments

lld/MachO/InputFiles.cpp

78

Fair enough, will split into another diff

251

Not sure why, but unlike the LC_ID_DYLIB case, trying to create a dylib without LC_SYMTAB makes yaml2obj crash. Probably some offsets / indices are off.

Looking at ld64's source, it seems that not having an LC_SYMTAB is only an error if LC_DYLD_INFO(_ONLY) is also missing. The dylib I looked at had LC_DYLD_INFO_ONLY, so I'm not sure if such a case arises in practice...

Anyway, proper handling of a missing LC_SYMTAB should probably cover the ObjectFile case as well, so I'm inclined to punt on it for now.

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

109

@smeenai earlier asked about deleting LC_SYMTAB, and I ran into some issues with yaml2obj while trying it (see my other comment). Given that using yaml2obj is mostly a stop-gap measure until lld itself can emit dylibs, I'd prefer not to spend too much time making the test case minimal.

[int3]

add comment about LC_DYLD_INFO

[int3]

lld/MachO/Arch/X86_64.cpp

38

no worries, wasn't hard to split out

lld/MachO/Target.h

18

I'm not sure we're 100% not going to support it, but we're definitely prioritizing 64-bit for now

lld/MachO/Writer.cpp

316

just tried, doesn't work sadly

[MaskRay]

lld/MachO/Arch/X86_64.cpp

38

I would argue that when sending patches as a series, we should make extra efforts keeping each commit clean and avoiding unneeded code move if possible...

I think the this patch is good in its current status but will hope Jez can make some final cleanups to avoid subsequent formatting/cleanup changes.

[int3]

address another comment

lld/test/MachO/dylink.s

8

not possible with the current setup; I'm using obj2yaml to get the address of the GOT, and to check that the order of the symbols references in it match the addresses printed by objdump

[ruiu]

As to the tests, we generally don't use yaml2obj to write tests (except for COFF which is historically using yaml2obj). If you are using yaml2obj just until lld itself is able to produce files used by tests, I don't think you have to spend too much time writing tests in yaml2obj. Instead, you can submit binary files for now and then replace them later.

lld/MachO/Target.h

18

Then please leave a comment here saying that we are currently supporting only 64-bit targets as macOS and iOS are deprecating 32-bit apps.

[int3]

The no-id-dylink.s test needs yaml2obj to generate an invalid dylib, but yeah I can replace the other two with binary blobs

[MaskRay]

In D76252#1926984, @int3 wrote:

The no-id-dylink.s test needs yaml2obj to generate an invalid dylib, but yeah I can replace the other two with binary blobs

We are trying to avoid binary blob in LLVM binary utilities + lld. @grimar has done lots of work in this area. Can you figure out how much effort it takes to implement relevant features in yaml2obj Mach-O? I hope we can avoid binary blobs early.

[int3]

I am indifferent as to whether we use binary blobs or yaml2obj for now, but I expect I'll have a diff up to make lld produce dylibs within the next week.

[ruiu]

In D76252#1927200, @MaskRay wrote:

In D76252#1926984, @int3 wrote:

The no-id-dylink.s test needs yaml2obj to generate an invalid dylib, but yeah I can replace the other two with binary blobs

We are trying to avoid binary blob in LLVM binary utilities + lld. @grimar has done lots of work in this area. Can you figure out how much effort it takes to implement relevant features in yaml2obj Mach-O? I hope we can avoid binary blobs early.

Yeah but my point is that we are not going to keep using yaml2obj for most test cases. Once lld is able to produce binary files used in the tests, we can replace the binary blobs with an invocation of lld. So checking in binary files as a temporary measure is pretty much okay to me, and it actually look like a good engineering decision to me. At this early stage of development, I think things don't always have to be done in the "right" way, as it usually has lots of scaffolding which will be replaced or removed later.

[int3]

rebase

[jhenderson]

In D76252#1926005, @ruiu wrote:

As to the tests, we generally don't use yaml2obj to write tests (except for COFF which is historically using yaml2obj). If you are using yaml2obj just until lld itself is able to produce files used by tests, I don't think you have to spend too much time writing tests in yaml2obj. Instead, you can submit binary files for now and then replace them later.

Hi @ruiu,

I'm just doing a quick drive by comment here, since I'm not really doing much LLD work at the moment myself. Why are you opposed to yaml2obj being used to generate test inputs instead of llvm-mc? Surely yaml2obj gives more direct control over what is actually in the input? In llvm-mc you only have relatively limited control over some things like relocations.

It seems to me like yaml2obj is a better instrument to be using for the vast majority of test cases, with only a limited set using llvm-mc as a catch-all test to make sure that we don't miss some odd interaction. Of course, this is all making the assumption that mach-o yaml2obj is straightforward to use (I have a feeling it might not be).

[ruiu]

In D76252#1928398, @jhenderson wrote:

In D76252#1926005, @ruiu wrote:

As to the tests, we generally don't use yaml2obj to write tests (except for COFF which is historically using yaml2obj). If you are using yaml2obj just until lld itself is able to produce files used by tests, I don't think you have to spend too much time writing tests in yaml2obj. Instead, you can submit binary files for now and then replace them later.

Hi @ruiu,

I'm just doing a quick drive by comment here, since I'm not really doing much LLD work at the moment myself. Why are you opposed to yaml2obj being used to generate test inputs instead of llvm-mc? Surely yaml2obj gives more direct control over what is actually in the input? In llvm-mc you only have relatively limited control over some things like relocations.

It seems to me like yaml2obj is a better instrument to be using for the vast majority of test cases, with only a limited set using llvm-mc as a catch-all test to make sure that we don't miss some odd interaction. Of course, this is all making the assumption that mach-o yaml2obj is straightforward to use (I have a feeling it might not be).

You can write tests with yaml2obj too, but if you take a look at ELF, don't you think that we can write fine-grained test cases with llvm-mc too? I want tests to be realistic input files, and in that respect, test cases written in llvm-mc are better than ones in obj2yaml.

I also found that tests written in llvm-mc are easier to maintain. For example, imagine that you already have a test file containing tests for relocations and you want to add a new type of relocation. Then, you'll have to not only add a new relocation to a yaml file but also add a few extra bytes with some addend at a right bit-wise position to the .text section, which isn't easy to do by hand. So, I guess you'll end up writing a test in assembly, compile it and then convert it to yaml -- but if that's the case, we should write tests in assembly in the first place. On the other hand, I didn't find a test case that is easy to write in yaml but not in assembly. There might be some, but that shouldn't be too many. So it looks to me that llvm-mc is a better choice to write test files.

[grimar]

In D76252#1928449, @ruiu wrote:

In D76252#1928398, @jhenderson wrote:

In D76252#1926005, @ruiu wrote:

As to the tests, we generally don't use yaml2obj to write tests (except for COFF which is historically using yaml2obj). If you are using yaml2obj just until lld itself is able to produce files used by tests, I don't think you have to spend too much time writing tests in yaml2obj. Instead, you can submit binary files for now and then replace them later.

Hi @ruiu,

I'm just doing a quick drive by comment here, since I'm not really doing much LLD work at the moment myself. Why are you opposed to yaml2obj being used to generate test inputs instead of llvm-mc? Surely yaml2obj gives more direct control over what is actually in the input? In llvm-mc you only have relatively limited control over some things like relocations.

It seems to me like yaml2obj is a better instrument to be using for the vast majority of test cases, with only a limited set using llvm-mc as a catch-all test to make sure that we don't miss some odd interaction. Of course, this is all making the assumption that mach-o yaml2obj is straightforward to use (I have a feeling it might not be).

You can write tests with yaml2obj too, but if you take a look at ELF, don't you think that we can write fine-grained test cases with llvm-mc too? I want tests to be realistic input files, and in that respect, test cases written in llvm-mc are better than ones in obj2yaml.

I also found that tests written in llvm-mc are easier to maintain. For example, imagine that you already have a test file containing tests for relocations and you want to add a new type of relocation. Then, you'll have to not only add a new relocation to a yaml file but also add a few extra bytes with some addend at a right bit-wise position to the .text section, which isn't easy to do by hand. So, I guess you'll end up writing a test in assembly, compile it and then convert it to yaml -- but if that's the case, we should write tests in assembly in the first place. On the other hand, I didn't find a test case that is easy to write in yaml but not in assembly. There might be some, but that shouldn't be too many. So it looks to me that llvm-mc is a better choice to write test files.

I think there is no universal approach and I agree with both of you. For example, for testing relocation relaxations I'd definetely prefer using YAML because it is important to get the particular op-codes and relocations in the inputs.
It is probaly easier to use YAMLs rather than using llvm-mc and verifying inputs with objdump or alike. For many other things, using llvm-mc is probably a bit more natural.

What I do not agree with is that commiting binaries is OK. From my one last experience after working on
yaml2obj and converting LLVM binaries, I found them are source of all kind of problems. If we can use yaml2obj for that out of box, I think we should.
If we can't then probably it is OK to use binaries temporary, but probably a bug should be reported about lacking features of yaml2obj and the
test should have a FIXME comment with a link.

[ruiu]

In D76252#1928528, @grimar wrote:

In D76252#1928449, @ruiu wrote:

In D76252#1928398, @jhenderson wrote:

In D76252#1926005, @ruiu wrote:

As to the tests, we generally don't use yaml2obj to write tests (except for COFF which is historically using yaml2obj). If you are using yaml2obj just until lld itself is able to produce files used by tests, I don't think you have to spend too much time writing tests in yaml2obj. Instead, you can submit binary files for now and then replace them later.

Hi @ruiu,

I'm just doing a quick drive by comment here, since I'm not really doing much LLD work at the moment myself. Why are you opposed to yaml2obj being used to generate test inputs instead of llvm-mc? Surely yaml2obj gives more direct control over what is actually in the input? In llvm-mc you only have relatively limited control over some things like relocations.

It seems to me like yaml2obj is a better instrument to be using for the vast majority of test cases, with only a limited set using llvm-mc as a catch-all test to make sure that we don't miss some odd interaction. Of course, this is all making the assumption that mach-o yaml2obj is straightforward to use (I have a feeling it might not be).

You can write tests with yaml2obj too, but if you take a look at ELF, don't you think that we can write fine-grained test cases with llvm-mc too? I want tests to be realistic input files, and in that respect, test cases written in llvm-mc are better than ones in obj2yaml.

I also found that tests written in llvm-mc are easier to maintain. For example, imagine that you already have a test file containing tests for relocations and you want to add a new type of relocation. Then, you'll have to not only add a new relocation to a yaml file but also add a few extra bytes with some addend at a right bit-wise position to the .text section, which isn't easy to do by hand. So, I guess you'll end up writing a test in assembly, compile it and then convert it to yaml -- but if that's the case, we should write tests in assembly in the first place. On the other hand, I didn't find a test case that is easy to write in yaml but not in assembly. There might be some, but that shouldn't be too many. So it looks to me that llvm-mc is a better choice to write test files.

I think there is no universal approach and I agree with both of you. For example, for testing relocation relaxations I'd definetely prefer using YAML because it is important to get the particular op-codes and relocations in the inputs.
It is probaly easier to use YAMLs rather than using llvm-mc and verifying inputs with objdump or alike. For many other things, using llvm-mc is probably a bit more natural.

What I do not agree with is that commiting binaries is OK. From my one last experience after working on
yaml2obj and converting LLVM binaries, I found them are source of all kind of problems. If we can use yaml2obj for that out of box, I think we should.
If we can't then probably it is OK to use binaries temporary, but probably a bug should be reported about lacking features of yaml2obj and the
test should have a FIXME comment with a link.

I think that we are on the same page. I'm not recommending submitting binary files as a permanent measure. What I'm saying is that if a test file can eventually be produced by mach-o lld itself, then we should allow binary files as a temporary measure. For example, it is okay to submit a shared object file as a binary file as a temporary measure until lld is able to produce a shared library file.

[MaskRay]

I agree with the previous discussions about llvm-mc vs yaml2obj. Most of time an assembly test is easier to read. In some cases yaml2obj can be more convenient. One notable inability of llvm-mc is that it cannot create invalid tests.

As to binary blobs: I am another disliker. I hope we can avoid them if possible. This may require some contribution to yaml2obj.

1. contribute yaml2obj 2) improve lld Mach-O add YAML tests

is better than

1. improve lld Mach-O and add binary tests 2) contribute to yaml2obj 3) convert binary tests to YAML tests

Note that the latter can increase the repository size indefinitely with these binary blobs. I am concerned about some practice in some areas of llvm-project, in particular, XCOFF in Object, and llvm-objdump Mach-O.

[int3]

Just to be clear, none of the tests right now would benefit from additional work on yaml2obj. We just need lld-macho to produce dylibs, which I expect I'll have have a diff for by EOW. In the meantime I'll leave the tests as-is in YAML, and I'm happy to wait for the dylib-production diff to be approved before landing everything as a stack, so we don't have to worry about sullying trunk with undesired test formats :)

[int3]

alphabetize

[int3]

clang-tidy

[int3]

use objdump --bind instead of obj2yaml to get symbol addresses

[int3]

fix test

[ruiu]

lld/MachO/InputFiles.cpp

215

Can you add a brief comment here that we initialize dylibName.

223

Ditto -- we are initializing symbols.

lld/MachO/Symbols.h

79

Isn't uint32_t enough? It's not a big deal, but I'd use uint32_t for an index of GOT.

lld/MachO/SyntheticSections.h

34

So GOT has no data but dynamic relocations? If so, I'd leave a brief comment here.

36

nit: add a blank line before a label.

lld/MachO/Writer.cpp

300

Replace auto with a concrete type.

357–360

nit: we usually do

os << foo << bar
   << baz << fizz;

instead of

os << foo << bar;
os << baz << fizz;

[int3]

lld/MachO/Writer.cpp

357–360

sgtm. Any thoughts on whether we should make a wrapper class like the ByteBuffer in ReaderWriter/MachO? I didn't see a whole lot of usage of raw_ostreams in the other lld implementations but I didn't find any abstraction layer over them either

[int3]

address comments

[int3]

static_cast

[int3]

clang-format

[int3]

lld/MachO/SyntheticSections.h

34

Actually, I'm not sure it's right to say that it has "no data" -- it does actually occupy space in the binary (unlike the __PAGEZERO segment, a section can't have zero filesize while having a non-zero-length address range), so I think saying it contains all zeroes is more accurate.

[int3]

rephrase comments

[int3]

forgot to address one more

[ruiu]

lld/MachO/Writer.cpp

357–360

We don't usually use raw_ostream because we usually write to the output file in two passes: in the first pass, we compute an offset for each output element, and then in the second pass, we let each output element to copy itself to the output file.

However, that two-pass technique cannot be used to create a ULEB-encoded stuff. because we don't know the exact size of each output element until we fix the file contents. Constructing an ULEB-encoded section contents are naturally sequential. So the usage of raw_ostream in for this section is fine. I don't see any problem with that.

[smeenai]

This LGTM with the comments. @ruiu, @MaskRay, any further comments? I think it's fine leaving the tests as YAML for now, since subsequent diffs in the stack will enabling LLD to produce dylibs itself and we'll replace the tests at that point.

lld/MachO/InputFiles.cpp

225

Is it correct to just consider LC_SYMTAB for this, or should we also be consulting LC_DYSYMTAB and/or the export trie? If so, we don't have to address that in this diff, but we should add a TODO.

We should also add a TODO about handling a missing LC_SYMTAB.

lld/MachO/InputFiles.h

37

Where is this used?

lld/MachO/SyntheticSections.h

24

It's kinda interesting to me that GotSection would inherit from InputSection, since it's not an input section, of course.

LLD ELF explains this design decision like so:

// Synthetic sections are designed as input sections as opposed to
// output sections because we want to allow them to be manipulated
// using linker scripts just like other input sections from regular
// files.

For Mach-O, we don't have linker scripts, so perhaps that reasoning doesn't hold.

COFF uses Chunks instead of InputSections, since there's more synthesized data (https://lld.llvm.org/NewLLD.html#important-data-structures). I think Mach-O has a good amount of linker-synthesized data and input section processing as well, so a COFF-like design might make more sense. It's hard to say until we have more of the implementation though.

For now, I think leaving this inheritance as-is is fine, but we should add a TODO to reconsider it once we've implemented more of the linker. @ruiu, @MaskRay, what do you think?

[int3]

lld/MachO/InputFiles.cpp

225

I *think* the export trie is only consumed by dyld. Let me see what the deal is with LC_DYSYMTAB...

lld/MachO/InputFiles.h

37

error("dylib " + path + " missing LC_ID_DYLIB load command"); in InputFiles.cpp

[int3]

add TODO; use reinterpret_cast

[int3]

lld/MachO/InputFiles.cpp

225

Okay, I looked through loader.h; didn't entirely understand it, but I think LC_DYSYMTAB just contains additional info about / indirect references to symbols in LC_SYMTAB.

[int3]

update

[smeenai]

I'll give other reviewers a few more days to take a look.

lld/MachO/InputFiles.cpp

235

We shouldn't be doing this for symbols that are undefined in the dylib's symbol table, right? (And if so, we should add a test for that, though I don't think that'll be possible till after your follow-ups.)

Looks like LLD ELF adds both defined and undefined symbols from dylibs into the symbol table, presumably to be able to check if all undefined symbols for dylibs are satisfied when linking an executable. Whether or not we do that depends on ld64's behavior there.

[MaskRay]

lld/MachO/InputFiles.cpp

235

Looks like LLD ELF adds both defined and undefined symbols from dylibs into the symbol table, presumably to be able to check if all undefined symbols for dylibs are satisfied when linking an executable.

Yes. See D57385 and D57569.

[MaskRay]

lld/MachO/InputFiles.cpp

235

It is also used to set the exportDynamic property of a symbol. When linking an executable, the symbols used by DSOs will be added to .dynsym

[int3]

lld/MachO/InputFiles.cpp

235

I think re-exported symbols also appear as undefined in the symbol table... I need to figure out how to distinguish them. I'll add a TODO.

lld/MachO/InputFiles.h

37

Actually, I see that we already have getName(). It just doesn't always work because we neglected to copy the strings from our input arguments before discarding them. I'll fix it and use that

[int3]

use getName(); add TODO for undefined symbols

[int3]

rebase

[smeenai]

LGTM with the comments addressed. I can commit this for you once they are.

lld/MachO/Driver.cpp

91–92

I believe these should actually be placed on the search path *after* any user-specified -L directories. At least that's what ld64 appears to do, based on the output from its -v option.

lld/MachO/InputSection.cpp

34

Nit: when one branch of an if-else has braces, all the others should too.

36

(same here)

[int3]

lld/MachO/Driver.cpp

91–92

Oh good catch. I'll make our -v option emit that too so we can test for it

[int3]

address comments

lld/MachO/Arch/X86_64.cpp

 //===- X86_64.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
 //
 //===----------------------------------------------------------------------===//
 

 X86_64::X86_64() {
   cpuType = CPU_TYPE_X86_64;
   cpuSubtype = CPU_SUBTYPE_X86_64_ALL;
 }
 
 uint64_t X86_64::getImplicitAddend(const uint8_t *loc, uint8_t type) const {
   switch (type) {
   case X86_64_RELOC_SIGNED:
+  case X86_64_RELOC_GOT_LOAD:
     return read32le(loc);
   default:
     error("TODO: Unhandled relocation type " + std::to_string(type));
     return 0;
   }
 }
 
 void X86_64::relocateOne(uint8_t *loc, uint8_t type, uint64_t val) const {
   switch (type) {
   case X86_64_RELOC_SIGNED:
-    // This type is only used for pc-relative relocations, so offset by 4 since
-    // the RIP has advanced by 4 at this point.
+  case X86_64_RELOC_GOT_LOAD:
+    // These types are only used for pc-relative relocations, so offset by 4
+    // since the RIP has advanced by 4 at this point.
     write32le(loc, val - 4);
     break;
   default:
     llvm_unreachable(
         "getImplicitAddend should have flagged all unhandled relocation types");
   }
 }
 
 } // namespace
 
 TargetInfo *macho::createX86_64TargetInfo() {
   static X86_64 t;
   return &t;
 }

lld/MachO/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(MachOOptionsTableGen)
 
 add_lld_library(lldMachO2
   Arch/X86_64.cpp
   Driver.cpp
   InputFiles.cpp
   InputSection.cpp
   OutputSegment.cpp
   SymbolTable.cpp
   Symbols.cpp
+  SyntheticSections.cpp
   Target.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   BinaryFormat
   Core
   DebugInfoDWARF

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 <vector>
+
 namespace lld {
 namespace macho {
 
 class Symbol;
 
 struct Configuration {
   llvm::StringRef outputFile;
   Symbol *entry;
+
+  std::vector<llvm::StringRef> searchPaths;
 };
 
 extern Configuration *config;
 
 } // namespace macho
 } // namespace lld
 
 #endif

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
 //
 //===----------------------------------------------------------------------===//
 
opt::InputArgList MachOOptTable::parse(ArrayRef<const char *> argv) {
   if (missingCount)
     error(Twine(args.getArgString(missingIndex)) + ": missing argument");
 
   for (opt::Arg *arg : args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + arg->getSpelling());
   return args;
 }
 
+// This is for -lfoo. We'll look for libfoo.dylib from search paths.
+static Optional<std::string> findDylib(StringRef name) {
+  for (StringRef dir : config->searchPaths) {
+    std::string path = (dir + "/lib" + name + ".dylib").str();
+    if (fs::exists(path))
+      return path;
+  }
+  error("library not found for -l" + name);
+  return None;
+}
+
 static TargetInfo *createTargetInfo(opt::InputArgList &args) {
   StringRef s = args.getLastArgValue(OPT_arch, "x86_64");
   if (s != "x86_64")
     error("missing or unsupported -arch " + s);
   return createX86_64TargetInfo();
 }
 
+static std::vector<StringRef> getSearchPaths(opt::InputArgList &args) {
+  std::vector<StringRef> ret;
+  if (!args.hasArg(OPT_Z))
+    ret = {"/usr/lib", "/usr/local/lib"};
+  for (StringRef s : args::getStrings(args, OPT_L))
+    ret.push_back(s);
+  return ret;
+}
+
 static void addFile(StringRef path) {
   Optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
   MemoryBufferRef mbref = *buffer;
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::macho_object:
     inputFiles.push_back(make<ObjFile>(mbref));
     break;
+  case file_magic::macho_dynamically_linked_shared_lib:
+    inputFiles.push_back(make<DylibFile>(mbref));
+    break;
   default:
     error(path + ": unhandled file type");
   }
 }
 
 bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
                  raw_ostream &stdoutOS, raw_ostream &stderrOS) {
   lld::stdoutOS = &stdoutOS;
bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   }
 
   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->searchPaths = getSearchPaths(args);
 
   getOrCreateOutputSegment("__TEXT", VM_PROT_READ | VM_PROT_EXECUTE);
   getOrCreateOutputSegment("__DATA", VM_PROT_READ | VM_PROT_WRITE);
+  getOrCreateOutputSegment("__DATA_CONST", VM_PROT_READ | VM_PROT_WRITE);
 
   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)) {
     error("undefined symbol: " + config->entry->getName());
     return false;
   }
 
+  createSyntheticSections();
+
   // Initialize InputSections.
   for (InputFile *file : inputFiles)
     for (InputSection *sec : file->sections)
       inputSections.push_back(sec);
 
   // Add input sections to output segments.
   for (InputSection *isec : inputSections) {
     OutputSegment *os =
         getOrCreateOutputSegment(isec->segname, VM_PROT_READ | VM_PROT_WRITE);
+    isec->parent = os;
     os->sections[isec->name].push_back(isec);
   }
 
   // Write to an output file.
   writeResult();
 
   if (canExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   freeArena();
   return !errorCount();
 }

lld/MachO/InputFiles.h

 //===- InputFiles.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
 //
 //===----------------------------------------------------------------------===//
 

 class InputSection;
 class Symbol;
 struct Reloc;
 
 class InputFile {
 public:
   enum Kind {
     ObjKind,
+    DylibKind,
   };
 
   virtual ~InputFile() = default;
-
   Kind kind() const { return fileKind; }
   StringRef getName() const { return mb.getBufferIdentifier(); }
 
   MemoryBufferRef mb;
   std::vector<Symbol *> symbols;
   std::vector<InputSection *> sections;
-  StringRef dylibName;
 
 protected:
   InputFile(Kind kind, MemoryBufferRef mb) : mb(mb), fileKind(kind) {}
 
   std::vector<InputSection *> parseSections(ArrayRef<llvm::MachO::section_64>);
 
   void parseRelocations(const llvm::MachO::section_64 &,
                         std::vector<Reloc> &relocs);
 
 private:
   const Kind fileKind;
 };
 
 // .o file
 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef mb);
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 };
 
+// .dylib file
+class DylibFile : public InputFile {
+public:
+  explicit DylibFile(MemoryBufferRef mb);
+  static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
+
+  StringRef dylibName;
+  uint64_t ordinal = 0; // Ordinal numbering starts from 1, so 0 is a sentinel
+};
+
 extern std::vector<InputFile *> inputFiles;
 
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
 } // namespace macho
 
 std::string toString(const macho::InputFile *file);
 } // namespace lld
 
 #endif

lld/MachO/InputFiles.cpp

 //===- InputFiles.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
 //
 //===----------------------------------------------------------------------===//
 //
Optional<MemoryBufferRef> macho::readFile(StringRef path) {
   if (auto ec = mbOrErr.getError()) {
     error("cannot open " + path + ": " + ec.message());
     return None;
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
+
+  // If this is a regular non-fat file, return it.
+  const char *buf = mbref.getBufferStart();
+  auto *hdr = reinterpret_cast<const MachO::fat_header *>(buf);
+  if (read32be(&hdr->magic) != MachO::FAT_MAGIC)
     return mbref;
+
+  error("TODO: Add support for universal binaries");
+  return None;
 }
 
 static const load_command *findCommand(const mach_header_64 *hdr,
                                        uint32_t type) {
   const uint8_t *p =
       reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
 
   for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const load_command *>(p);
     if (cmd->cmd == type)
       return cmd;
     p += cmd->cmdsize;
   }
   return nullptr;
 }
 
 std::vector<InputSection *>
 InputFile::parseSections(ArrayRef<section_64> sections) {
   std::vector<InputSection *> ret;
   ret.reserve(sections.size());
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
 
   if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
     auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
     objSections = ArrayRef<section_64>{
         reinterpret_cast<const section_64 *>(c + 1), c->nsects};
     sections = parseSections(objSections);
   }
 
+  // TODO: Error on missing LC_SYMTAB?
   if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
     auto *c = reinterpret_cast<const symtab_command *>(cmd);
     const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
     ArrayRef<const nlist_64> nList(
         reinterpret_cast<const nlist_64 *>(buf + c->symoff), c->nsyms);
 
     symbols.reserve(c->nsyms);
 
     for (const nlist_64 &sym : nList) {
       StringRef name = strtab + sym.n_strx;
 
       // Undefined symbol
       if (!sym.n_sect) {
-        error("TODO: Support undefined symbols");
+        symbols.push_back(symtab->addUndefined(name));
         continue;
       }
 
       InputSection *isec = sections[sym.n_sect - 1];
       const section_64 &objSec = objSections[sym.n_sect - 1];
       uint64_t value = sym.n_value - objSec.addr;
 
       // Global defined symbol
if (!sections.empty()) {
     auto it = sections.begin();
     for (const section_64 &sec : objSections) {
       parseRelocations(sec, (*it)->relocs);
       ++it;
     }
   }
 }
 
+DylibFile::DylibFile(MemoryBufferRef mb) : InputFile(DylibKind, mb) {
+  auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
+  auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+
+  // Initialize dylibName.
+  if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
+    auto *c = reinterpret_cast<const dylib_command *>(cmd);
+    dylibName = reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
+  } else {
+    error("dylib " + getName() + " missing LC_ID_DYLIB load command");
+    return;
+  }
+
+  // Initialize symbols.
+  if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
+    auto *c = reinterpret_cast<const symtab_command *>(cmd);
+    const char *strtab = reinterpret_cast<const char *>(buf + c->stroff);
+    ArrayRef<const nlist_64> nList(
+        reinterpret_cast<const nlist_64 *>(buf + c->symoff), c->nsyms);
+
+    symbols.reserve(c->nsyms);
+
+    for (const nlist_64 &sym : nList) {
+      StringRef name = strtab + sym.n_strx;
+      // TODO: Figure out what to do about undefined symbols: ignore or warn
+      // if unsatisfied? Also make sure we handle re-exported symbols
+      // correctly.
+      symbols.push_back(symtab->addDylib(name, this));
+    }
+  }
+}
+
 // Returns "<internal>" or "baz.o".
 std::string lld::toString(const InputFile *file) {
   return file ? std::string(file->getName()) : "<internal>";
 }

lld/MachO/InputSection.h

 //===- InputSection.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_INPUT_SECTION_H
 #define LLD_MACHO_INPUT_SECTION_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 namespace lld {
 namespace macho {
 
 class InputFile;
 class InputSection;
+class OutputSegment;
 class Symbol;
 
 struct Reloc {
   uint8_t type;
   uint32_t addend;
   uint32_t offset;
   llvm::PointerUnion<Symbol *, InputSection *> target;
 };
 
 class InputSection {
 public:
-  void writeTo(uint8_t *buf);
+  virtual ~InputSection() = default;
+  virtual void writeTo(uint8_t *buf);
+  virtual size_t getSize() const { return data.size(); }
 
   InputFile *file = nullptr;
+  OutputSegment *parent = nullptr;
   StringRef name;
   StringRef segname;
 
   ArrayRef<uint8_t> data;
   uint64_t addr = 0;
   uint32_t align = 1;
   uint32_t flags = 0;
 

lld/MachO/InputSection.cpp

 //===- InputSection.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 "InputSection.h"
 #include "Symbols.h"
+#include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::macho;
 
 std::vector<InputSection *> macho::inputSections;
 
 void InputSection::writeTo(uint8_t *buf) {
   memcpy(buf, data.data(), data.size());
 
   for (Reloc &r : relocs) {
     uint64_t va = 0;
-    if (auto *s = r.target.dyn_cast<Symbol *>())
+    if (auto *s = r.target.dyn_cast<Symbol *>()) {
+      if (auto *dylibSymbol = dyn_cast<DylibSymbol>(s)) {
+        va = in.got->addr - ImageBase + dylibSymbol->gotIndex * WordSize;
+      } else {
         va = s->getVA();
-    else if (auto *isec = r.target.dyn_cast<InputSection *>())
+      }
+    } else if (auto *isec = r.target.dyn_cast<InputSection *>())
       va = isec->addr;
     else
       llvm_unreachable("Unknown relocation target");
 
     uint64_t val = va + r.addend;
     if (1) // TODO: handle non-pcrel relocations
       val -= addr - ImageBase + r.offset;
     target->relocateOne(buf + r.offset, r.type, val);
   }
 }

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 e: Separate<["-"], "e">, HelpText<"Name of entry point symbol">;
 
+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/OutputSegment.h

 //===- OutputSegment.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_OUTPUT_SEGMENT_H
 #define LLD_MACHO_OUTPUT_SEGMENT_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace lld {
 namespace macho {
 
 class InputSection;
 
 class OutputSegment {
 public:
+  InputSection *firstSection() const { return sections.front().second.at(0); }
+
+  InputSection *lastSection() const { return sections.back().second.back(); }
+
   StringRef name;
   uint32_t perms;
+  uint8_t index;
   llvm::MapVector<StringRef, std::vector<InputSection *>> sections;
 };
 
 extern std::vector<OutputSegment *> outputSegments;
 
 OutputSegment *getOrCreateOutputSegment(StringRef name, uint32_t perms);
 
 } // namespace macho
 } // namespace lld
 
 #endif

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 "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/Object/Archive.h"
 
 namespace lld {
 namespace macho {
 
-class InputFile;
-class InputSection;
 class ArchiveFile;
+class DylibFile;
+class InputSection;
 class Symbol;
 
 class SymbolTable {
 public:
   Symbol *addDefined(StringRef name, InputSection *isec, uint32_t value);
 
   Symbol *addUndefined(StringRef name);
 
+  Symbol *addDylib(StringRef name, DylibFile *file);
+
   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

 //===- SymbolTable.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
 //
 //===----------------------------------------------------------------------===//
 
Symbol *SymbolTable::addUndefined(StringRef name) {
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 
   if (wasInserted)
     replaceSymbol<Undefined>(s, name);
   return s;
 }
 
+Symbol *SymbolTable::addDylib(StringRef name, DylibFile *file) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name);
+
+  if (wasInserted)
+    replaceSymbol<DylibSymbol>(s, file, name);
+  return s;
+}
+
 SymbolTable *macho::symtab;

lld/MachO/Symbols.h

 //===- Symbols.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_SYMBOLS_H
 #define LLD_MACHO_SYMBOLS_H
 
 #include "InputSection.h"
 #include "Target.h"
 #include "lld/Common/Strings.h"
 #include "llvm/Object/Archive.h"
 
 namespace lld {
 namespace macho {
 
 class InputSection;
-class InputFile;
+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,
   };
 
   Kind kind() const { return static_cast<Kind>(symbolKind); }
 
   StringRef getName() const { return {name.data, name.size}; }
 
   uint64_t getVA() const;
 
-  InputFile *file;
-
 protected:
-  Symbol(Kind k, InputFile *file, StringRefZ name)
-      : file(file), symbolKind(k), name(name) {}
+  Symbol(Kind k, StringRefZ name) : symbolKind(k), name(name) {}
 
   Kind symbolKind;
   StringRefZ name;
 };
 
 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputSection *isec, uint32_t value)
-      : Symbol(DefinedKind, nullptr, name), isec(isec), value(value) {}
+      : Symbol(DefinedKind, name), isec(isec), value(value) {}
 
   InputSection *isec;
   uint32_t value;
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 };
 
 class Undefined : public Symbol {
 public:
-  Undefined(StringRefZ name) : Symbol(UndefinedKind, nullptr, name) {}
+  Undefined(StringRefZ name) : Symbol(UndefinedKind, name) {}
 
   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 };
 
+class DylibSymbol : public Symbol {
+public:
+  DylibSymbol(DylibFile *file, StringRefZ name)
+      : Symbol(DylibKind, name), file(file) {}
+
+  static bool classof(const Symbol *s) { return s->kind() == DylibKind; }
+
+  DylibFile *file;
+  uint32_t gotIndex = UINT32_MAX;
+};
+
 inline uint64_t Symbol::getVA() const {
   if (auto *d = dyn_cast<Defined>(this))
     return d->isec->addr + d->value - ImageBase;
   return 0;
 }
 
 union SymbolUnion {
   alignas(Defined) char a[sizeof(Defined)];
   alignas(Undefined) char b[sizeof(Undefined)];
+  alignas(DylibSymbol) char c[sizeof(DylibSymbol)];
 };
 
 template <typename T, typename... ArgT>
 void replaceSymbol(Symbol *s, ArgT &&... arg) {
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&

lld/MachO/SyntheticSections.h

+//===- SyntheticSections.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_SYNTHETIC_SECTIONS_H
+#define LLD_MACHO_SYNTHETIC_SECTIONS_H
+
+#include "InputSection.h"
+#include "Target.h"
+#include "llvm/ADT/SetVector.h"
+
+namespace lld {
+namespace macho {
+
+class DylibSymbol;
+
+// This section will be populated by dyld with addresses to non-lazily-loaded
+// dylib symbols.
+class GotSection : public InputSection {
+public:
+  GotSection();
+
+  void addEntry(DylibSymbol &sym);
+  const llvm::SetVector<const DylibSymbol *> &getEntries() const {
+    return entries;
+  }
+
+  size_t getSize() const override { return entries.size() * WordSize; }
+
+  void writeTo(uint8_t *buf) override {
+    // Nothing to write, GOT contains all zeros at link time; it's populated at
+    // runtime by dyld.
+  }
+
+private:
+  llvm::SetVector<const DylibSymbol *> entries;
+};
+
+struct InStruct {
+  GotSection *got;
+};
+
+extern InStruct in;
+
+} // namespace macho
+} // namespace lld
+
+#endif

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 "Symbols.h"
+
+using namespace llvm::MachO;
+
+namespace lld {
+namespace macho {
+
+GotSection::GotSection() {
+  segname = "__DATA_CONST";
+  name = "__got";
+  align = 8;
+  flags = S_NON_LAZY_SYMBOL_POINTERS;
+
+  // TODO: section_64::reserved1 should be an index into the indirect symbol
+  // table, which we do not currently emit
+}
+
+void GotSection::addEntry(DylibSymbol &sym) {
+  if (entries.insert(&sym)) {
+    sym.gotIndex = entries.size() - 1;
+  }
+}
+
+InStruct in;
+
+} // namespace macho
+} // namespace lld

lld/MachO/Target.h

 //===- Target.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_TARGET_H
 #define LLD_MACHO_TARGET_H
 
 #include <cstdint>
 
 namespace lld {
 namespace macho {
 
 enum {
+  // We are currently only supporting 64-bit targets since macOS and iOS are
+  // deprecating 32-bit apps.
+  WordSize = 8,
   PageSize = 4096,
   ImageBase = 4096,
   MaxAlignmentPowerOf2 = 32,
 };
 
 class TargetInfo {
 public:
   virtual ~TargetInfo() = default;

lld/MachO/Writer.h

 //===- Writer.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_WRITER_H
 #define LLD_MACHO_WRITER_H
 
 namespace lld {
 namespace macho {
 
 void writeResult();
 
+void createSyntheticSections();
+
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Writer.cpp

 //===- Writer.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 "Writer.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "OutputSegment.h"
 #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/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::macho;
public:
   virtual void writeTo(uint8_t *buf) const = 0;
 };
 
 class Writer {
 public:
   Writer() : buffer(errorHandler().outputBuffer) {}
 
   void createLoadCommands();
+  void scanRelocations();
   void assignAddresses();
 
+  void createDyldInfoContents();
+
   void openFile();
   void writeHeader();
   void writeSections();
 
   void run();
 
   std::vector<LoadCommand *> loadCommands;
   std::unique_ptr<FileOutputBuffer> &buffer;

 public:
   uint32_t getSize() const override { return sizeof(segment_command_64); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<segment_command_64 *>(buf);
     c->cmd = LC_SEGMENT_64;
     c->cmdsize = getSize();
     strcpy(c->segname, "__LINKEDIT");
+    c->vmaddr = addr;
     c->fileoff = fileOff;
-    c->filesize = contents.size();
+    c->filesize = c->vmsize = contents.size();
     c->maxprot = VM_PROT_READ | VM_PROT_WRITE;
     c->initprot = VM_PROT_READ;
   }
 
   uint64_t getOffset() const { return fileOff + contents.size(); }
 
   uint64_t fileOff = 0;
+  uint64_t addr = 0;
   SmallVector<char, 128> contents;
 };
 
 class LCDyldInfo : public LoadCommand {
 public:
   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();
+    c->bind_off = bindOff;
+    c->bind_size = bindSize;
     c->export_off = exportOff;
     c->export_size = exportSize;
   }
 
+  uint64_t bindOff = 0;
+  uint64_t bindSize = 0;
   uint64_t exportOff = 0;
   uint64_t exportSize = 0;
 };
 
 class LCDysymtab : public LoadCommand {
 public:
   uint32_t getSize() const override { return sizeof(dysymtab_command); }
 
public:
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<segment_command_64 *>(buf);
     buf += sizeof(segment_command_64);
 
     c->cmd = LC_SEGMENT_64;
     c->cmdsize = getSize();
     memcpy(c->segname, name.data(), name.size());
 
-    InputSection *firstSec = seg->sections.front().second[0];
-    InputSection *lastSec = seg->sections.back().second.back();
-
     // dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
     // from the beginning of the file (i.e. the header).
     // TODO: replace this logic by creating a synthetic __TEXT,__mach_header
     // section instead.
-    c->fileoff = name == "__TEXT" ? 0 : firstSec->addr - ImageBase;
+    c->fileoff = name == "__TEXT" ? 0 : seg->firstSection()->addr - ImageBase;
     c->vmaddr = c->fileoff + ImageBase;
-    c->vmsize = c->filesize = lastSec->addr + lastSec->data.size() - c->vmaddr;
+    c->vmsize = c->filesize =
+        seg->lastSection()->addr + seg->lastSection()->getSize() - c->vmaddr;
     c->maxprot = VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE;
     c->initprot = seg->perms;
     c->nsects = seg->sections.size();
 
     for (auto &p : seg->sections) {
       StringRef s = p.first;
       std::vector<InputSection *> &sections = p.second;
 
       auto *sectHdr = reinterpret_cast<section_64 *>(buf);
       buf += sizeof(section_64);
 
       memcpy(sectHdr->sectname, s.data(), s.size());
       memcpy(sectHdr->segname, name.data(), name.size());
 
       sectHdr->addr = sections[0]->addr;
       sectHdr->offset = sections[0]->addr - ImageBase;
       sectHdr->align = sections[0]->align;
       uint32_t maxAlign = 0;
       for (const InputSection *section : sections)
         maxAlign = std::max(maxAlign, section->align);
       sectHdr->align = Log2_32(maxAlign);
       sectHdr->flags = sections[0]->flags;
-      sectHdr->size = sections.back()->addr + sections.back()->data.size() -
+      sectHdr->size = sections.back()->addr + sections.back()->getSize() -
                       sections[0]->addr;
     }
   }
 
 private:
   StringRef name;
   OutputSegment *seg;
 };
void Writer::createLoadCommands() {
 
   loadCommands.push_back(linkEditSeg);
   loadCommands.push_back(dyldInfoSeg);
   loadCommands.push_back(symtabSeg);
   loadCommands.push_back(make<LCPagezero>());
   loadCommands.push_back(make<LCLoadDylinker>());
   loadCommands.push_back(make<LCDysymtab>());
   loadCommands.push_back(make<LCMain>());
+
+  uint8_t segIndex = 1; // LCPagezero is a segment load command
+  for (OutputSegment *seg : outputSegments) {
+    if (!seg->sections.empty()) {
+      loadCommands.push_back(make<LCSegment>(seg->name, seg));
+      seg->index = segIndex++;
+    }
+  }
+
+  uint64_t dylibOrdinal = 1;
+  for (InputFile *file : inputFiles) {
+    if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
+      loadCommands.push_back(make<LCLoadDylib>(dylibFile->dylibName));
+      dylibFile->ordinal = dylibOrdinal++;
+    }
+  }
+
   // TODO: dyld requires libSystem to be loaded. libSystem is a universal
   // binary and we don't have support for that yet, so mock it out here.
   loadCommands.push_back(make<LCLoadDylib>("/usr/lib/libSystem.B.dylib"));
+}
 
-  for (OutputSegment *seg : outputSegments)
-    if (!seg->sections.empty())
-      loadCommands.push_back(make<LCSegment>(seg->name, seg));
+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::assignAddresses() {
   uint64_t addr = ImageBase + sizeof(mach_header_64);
 
   uint64_t size = 0;
   for (LoadCommand *lc : loadCommands)
     size += lc->getSize();
   sizeofCmds = size;
   addr += size;
 
   for (OutputSegment *seg : outputSegments) {
     addr = alignTo(addr, PageSize);
 
     for (auto &p : seg->sections) {
       ArrayRef<InputSection *> sections = p.second;
       for (InputSection *isec : sections) {
         addr = alignTo(addr, isec->align);
         isec->addr = addr;
-        addr += isec->data.size();
+        addr += isec->getSize();
       }
     }
   }
 
+  addr = alignTo(addr, PageSize);
+  linkEditSeg->addr = addr;
   linkEditSeg->fileOff = addr - ImageBase;
 }
 
+// LC_DYLD_INFO_ONLY contains symbol import/export information. Imported
+// symbols are described by a sequence of bind opcodes, which allow for a
+// compact encoding. Exported symbols are described using a trie.
+void Writer::createDyldInfoContents() {
+  uint64_t sectionStart = linkEditSeg->getOffset();
+  raw_svector_ostream os{linkEditSeg->contents};
+
+  if (in.got->getSize() != 0) {
+    // Emit bind opcodes, which tell dyld which dylib symbols to load.
+
+    // Tell dyld to write to the section containing the GOT.
+    os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
+                               in.got->parent->index);
+    encodeULEB128(in.got->addr - in.got->parent->firstSection()->addr, os);
+    for (const DylibSymbol *sym : in.got->getEntries()) {
+      // TODO: Implement compact encoding -- we only need to encode the
+      // differences between consecutive symbol entries.
+      if (sym->file->ordinal <= BIND_IMMEDIATE_MASK) {
+        os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM |
+                                   sym->file->ordinal);
+      } else {
+        error("TODO: Support larger dylib symbol ordinals");
+        continue;
+      }
+      os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
+         << sym->getName() << '\0'
+         << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER)
+         << static_cast<uint8_t>(BIND_OPCODE_DO_BIND);
+    }
+
+    os << static_cast<uint8_t>(BIND_OPCODE_DONE);
+
+    dyldInfoSeg->bindOff = sectionStart;
+    dyldInfoSeg->bindSize = linkEditSeg->getOffset() - sectionStart;
+  }
+
+  // TODO: emit bind opcodes for lazy symbols.
+  // TODO: Implement symbol export trie.
+}
+
 void Writer::openFile() {
   Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
       FileOutputBuffer::create(config->outputFile, fileSize,
                                FileOutputBuffer::F_executable);
 
   if (!bufferOrErr)
     error("failed to open " + config->outputFile + ": " +
           llvm::toString(bufferOrErr.takeError()));
for (auto &sect : seg->sections)
         isec->writeTo(buf + isec->addr - ImageBase);
 
   memcpy(buf + linkEditSeg->fileOff, linkEditSeg->contents.data(),
          linkEditSeg->contents.size());
 }
 
 void Writer::run() {
   createLoadCommands();
+  scanRelocations();
   assignAddresses();
+
+  // Fill __LINKEDIT contents
+  createDyldInfoContents();
   fileSize = linkEditSeg->fileOff + linkEditSeg->contents.size();
 
   openFile();
   if (errorCount())
     return;
 
   writeHeader();
   writeSections();
 
   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.got = make<GotSection>();
+  inputSections.push_back(in.got);
+}

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/no-id-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"
+##
+## Then we deleted the LC_ID_DYLIB command from the YAML file.
+
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x00000006
+  ncmds:           10
+  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_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/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 %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
+# CHECK-NEXT: [[#%x, GOODBYE_RIP:]]:
+
+# CHECK-LABEL: Bind table:
+# CHECK-DAG: __DATA_CONST __got 0x{{0*}}[[#%x, HELLO_RIP + HELLO_OFF]]     pointer 0 libhello   _hello_world
+# CHECK-DAG: __DATA_CONST __got 0x{{0*}}[[#%x, GOODBYE_RIP + GOODBYE_OFF]] pointer 0 libgoodbye _goodbye_world
+
+.section __TEXT,__text
+.globl _main
+
+_main:
+  movl $0x2000004, %eax # write() syscall
+  mov $1, %rdi # stdout
+  movq _hello_world@GOTPCREL(%rip), %rsi
+  mov $13, %rdx # length of str
+  syscall
+
+  movl $0x2000004, %eax # write() syscall
+  mov $1, %rdi # stdout
+  movq _goodbye_world@GOTPCREL(%rip), %rsi
+  mov $15, %rdx # length of str
+  syscall
+  mov $0, %rax
+  ret

lld/test/MachO/missing-dylib.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: not lld -flavor darwinnew -Z -o %t -lmissing %t.o 2>&1 | FileCheck %s
+
+# CHECK: library not found for -lmissing

lld/test/MachO/no-id-dylink.s

+# REQUIRES: x86
+# RUN: mkdir -p %t
+# RUN: yaml2obj %p/Inputs/no-id-dylib.yaml -o %t/libnoid.dylib
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/no-id-dylink.o
+# RUN: not lld -flavor darwinnew -o %t/no-id-dylink -Z -L%t -lnoid %t/no-id-dylink.o 2>&1 | FileCheck %s
+# CHECK: dylib {{.*}}libnoid.dylib missing LC_ID_DYLIB load command
+
+.text
+.globl _main
+
+_main:
+  mov $0, %rax
+  ret