[lld] Initial commit for new Mach-O backend

[int3]

Summary

This is the first commit for the new Mach-O backend, designed to roughly follow the architecture of the existing ELF and COFF backends, and building off work that @ruiu and @pcc did in a branch a while back. Note that this is a very stripped-down commit with the bare minimum of functionality for ease of review. We'll be following up with more diffs soon.

Currently, we're able to generate a simple "Hello World!" executable that runs on OS X Catalina (and possibly on earlier OS X versions; I haven't tested them). (This executable can be obtained by compiling test/MachO/relocations.s.) We're mocking out a few load commands to achieve this -- for example, we can't load dynamic libraries, but Catalina requires binaries to be linked against dyld, so we hardcode the emission of a LC_LOAD_DYLIB command. Other mocked out load commands include LC_SYMTAB and LC_DYSYMTAB.

[MaskRay]

Excited to see this! (I generally like playing with binary formats, though I know close to zero about Mach-O.)

https://lists.llvm.org/pipermail/llvm-dev/2018-June/123784.html

But I don't think that's the real issue. I think the real issue is the lack of maintenance and ownership of the mach-O lld tree. There's no activities for the tree for years, though we've been making efforts to keep it compile and pass all the existing tests.

So, is this an announcement that you want to claim the maintenance? ☺️

[smeenai]

In D75382#1898987, @MaskRay wrote:

Excited to see this! (I generally like playing with binary formats, though I know close to zero about Mach-O.)

https://lists.llvm.org/pipermail/llvm-dev/2018-June/123784.html

But I don't think that's the real issue. I think the real issue is the lack of maintenance and ownership of the mach-O lld tree. There's no activities for the tree for years, though we've been making efforts to keep it compile and pass all the existing tests.

So, is this an announcement that you want to claim the maintenance? ☺️

Yes :) Although note that we're developing a new Mach-O backend that uses the same design as COFF and ELF, not working with the existing one.

[MaskRay]

lld/MachO/Driver.cpp

32

Reorder llvm namespaces before lld.

67

auto -> opt::Arg

148

excess parentheses

lld/MachO/InputFiles.cpp

104

MachO/section-names.s should test a long section name.

105

There should be a test.

125

Logically unreachable code uses llvm_unreachable. Unimplemented features should call error() instead.

149

/usr/lib/gcc/x86_64-linux-gnu/9/../../../../include/c++/9/bits/stl_vector.h:398:7: error: static_assert failed due to requirement 'is_same<llvm::MachO
::section_64, const llvm::MachO::section_64>::value' "std::vector must have a non-const, non-volatile value_type"
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,

lld/MachO/Target.cpp

21

How many targets do Mach-O have? If it can be larger, like ELF/Arch/X86_64.cpp, we can create MachO/Arch accordingly.

37

Logically unreachable code uses llvm_unreachable. Unimplemented relocation types should call error() instead.

lld/MachO/Writer.cpp

250

Is it a const?

Who defines it as /usr/lib/dyld ?

lld/test/MachO/duplicate-symbol.s

5

Does lld -flavor darwinnew -o /dev/null %t.o %t.o work?

lld/test/MachO/relocations.s

12

Delete unneeded instructions.

lld/test/MachO/section-names.s

24

too much indentation

lld/test/MachO/undefined-entry.s

11

8-space indentation may be too much. 2 is fine.
If the instruction is not significant, delete mov $0, %rax

lld/tools/lld/CMakeLists.txt

15

I hope we can name it lldMacho.

[ruiu]

This seems a pretty straightforward port of the existing backends. Very nice!

Can you extend the commit message a bit to explain what you can do with this initial patch -- e.g. can you create a syntactically-valid mach-o executable with this? Can you create a trivial executable? (I guess the answer is no because you need to support dynamic linking.)? etc.

[int3]

I guess the answer is no because you need to support dynamic linking.

The answer is actually yes, though we cheat a bit :D I've updated the summary.

lld/MachO/InputFiles.cpp

149

ah I need to figure out how to build with gcc locally... but it looks like the error comes from the ArrayRef of const, so I've removed the const

lld/MachO/Target.cpp

21

we'll want to target ARM at some point. I'll create the subdir

lld/MachO/Writer.cpp

250

ld64 defaults this value to /usr/lib/dyld but allows you to override it via the env var LD_DYLD_PATH. However recent versions of the kernel don't execute anything with a different dyld path so it's effectively a constant: https://github.com/apple/darwin-xnu/pull/8

I'll make this a const and add a comment.

lld/tools/lld/CMakeLists.txt

15

I'm not sure if anyone is still depending on the old partial Mach-O implementation. If no one objects I'll take over its build/flavor names

[int3]

address comments

[int3]

lld/MachO/InputFiles.cpp

104

okay, added a 16 char section name (the maximum allowed by the format)

lld/test/MachO/duplicate-symbol.s

5

yup it does

[int3]

update

[smeenai]

lld/tools/lld/CMakeLists.txt

15

I believe some people are using it right now, so I was planning to wait until we were more feature-complete to do this.

[pcc]

lld/MachO/InputFiles.cpp

28

Since this isn't implemented yet, maybe this part of the comment should be omitted?

38

I don't believe that this is true in general. In the case where R_SCATTERED is false, bit 27 of r_word1 (the extern bit) indicates whether the relocation refers to a symbol or a section address. You can see this by grepping for rExtern in the existing lld, and seeing how relocations with/without the bit are handled (e.g. http://llvm-cs.pcc.me.uk/tools/lld/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp#434 ).

[int3]

lld/MachO/InputFiles.cpp

38

This was originally written by @ruiu, but I *think* what this means is that R_SCATTERED determines whether the relocation is referring to something within the same section, and not whether it's referring to a symbol or a section. I'll rephrase things...

[int3]

update comment

[aprantl]

lld/MachO/Driver.cpp

2

Putting a -*- C++ -*- mark into a .cpp file is redundant. These are only necessary for .h files where the language is ambiguous.

[alexander-shaposhnikov]

lld/MachO/OutputSegment.cpp

17

@ruiu, @pcc - just curious, would you mind adding some comments regarding the design considerations which motivated this approach (using global variables to store various parts of the object file, storing the state globally etc) ?

[pcc]

lld/MachO/InputFiles.cpp

38

I think that both non-R_SCATTERED and R_SCATTERED can refer to locations within different sections. You can see this in the implementation of "atomByAddr" in the old linker:
http://llvm-cs.pcc.me.uk/tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp#527
which contains code to look up potentially different sections.

This function is called e.g. here:
http://llvm-cs.pcc.me.uk/tools/lld/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp#444

and the "symbol" field (which becomes the first argument of that function) is filled in here:
http://llvm-cs.pcc.me.uk/tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryUtils.h#144
(and code below to handle the non-R_SCATTERED case).

I would summarise the situation as being:

• non-scattered relocations may refer to either an external symbol or a location within a (same or different) section (index is specified in relocation, or inferred from address if 0)
• scattered relocations may only refer to a location within a (same or different) section (index is inferred from address).

[MaskRay]

lld/MachO/OutputSegment.cpp

17

I started to be heavily involved in lld/ELF since mid 2018. I do not know much about the previous history.

You find the discussions in D70421 and https://reviews.llvm.org/D70766#1761624 helpful. If we can avoid global variables, that will be nice.

[int3]

lld/MachO/InputFiles.cpp

38

Thanks for the pointers! That makes sense. One question:

section (index is specified in relocation, or inferred from address if 0)

Can a valid relocation actually have 0 as the section index? Relocation::value for a non-scattered relocation is always zero, so I'm not sure what address we could infer things from...

[pcc]

lld/MachO/InputFiles.cpp

38

In this case, the address that we infer things from is stored inline in the section data (see getImplicitAddend here, or the second argument to atomByAddr in the old linker).

[int3]

update comments

[int3]

lld/MachO/InputFiles.cpp

38

I see, thanks!

[ruiu]

lld/MachO/OutputSegment.cpp

17

This variable is essentially a singleton, as you need only one list of output segments for each instance of the linker, and in many places you'll need to access it, so I decided to make it a global variable. Other singletons are also represented by global variables. In addition to that, this code is simply written in an old-fashioned way to reflect my taste, which shouldn't be necessarily bad. Actually I'm fairly satisfied with this design as it is pretty straightforward.

An alternative design is to define a "context" object and make that object to have all singletons like this. That design isn't bad too and is perhaps arguably better, but if you do that you'll end up having to add one extra parameter to virtually all functions.

Anyway, this topic tends to become a bikesheddy, so I'd focus on bringing up the mach-o linker while reusing the exact same design as the other ports.

[lhames]

In D75382#1898996, @smeenai wrote:

In D75382#1898987, @MaskRay wrote:

So, is this an announcement that you want to claim the maintenance? ☺️

Yes :) Although note that we're developing a new Mach-O backend that uses the same design as COFF and ELF, not working with the existing one.

I'm happy to resign as code owner of the existing MachO LLD codebase. If/when possible, I think it should be removed from the tree.

[alexander-shaposhnikov]

lld/MachO/OutputSegment.cpp

17

@ruiu, for what it's worth, my 0.02$.
it seems like there are multiple downsides of this "design", starting from readability, clarity of the internal model of the output file, ending with, for example, if one wanted to use LLD as a library and construct multiple instances of different output files, or, e.g. write unit-tests in memory to verify some parts of the functionality separately. Probably, the list can be continued. So it's not clear at all what dictates them to be singletons.
If i am not mistaken at some point it was also mentioned in the LLVM Coding Standards https://llvm.org/docs/CodingStandards.html#do-not-use-static-constructors, some it would be interesting to find out why it was ignored for ELF/COFF.
Regarding the argument "I'd focus on bringing up the mach-o linker while reusing the exact same design as the other ports" - I fully support this effort of writing a modern solid implementation of LLD for MachO and, in particular, don't want to block this diff, however, this argument looks quite weak, in the future when more complexity will be accumulated in this code it'll be much harder to change the course, at least it is hard to see how it can get any simpler. cc: David @dblaikie

[dblaikie]

lld/MachO/OutputSegment.cpp

17

These issues were discussed at length previously without a particularly satisfying resolution (perhaps more accurately - it didn't go the way I wanted it to go, but not everything can/should/does) in the context of the broader LLVM project (being library centric, etc) - and lld has continued to exist (& be adopted in production even by those, myself included, who had/have misgivings about the design choices here).

(it's probably not helpful to use quotation marks around the word 'design' to call into question someone else's perspective - it is an intentional design choice that has been discussed at length in the past, not an accident or choice made casually)

While writing the design discussion/conclusions down somewhere probably would be nice - even the act of doing that might just end up igniting opinions/relitigating the previous decisions & generally being a bit unproductive. So it's not super high on my priority list nor something I'd strongly encourage/request others do either.

[dblaikie]

lld/MachO/OutputSegment.cpp

17

Oh, one other thing here, I guess - LLVM started with some similar issues & eventually LLVMContext was added, etc. Probably (I'm totally guessing here) when LLVM was a bit larger than lld is now. So it's probably still pretty tractible if/when anyone wants to librarify lld by making it uses non halt-on-error error handling, and moving global state into an LLDContext or similar. (I'm guessing the error handling might be the bigger part of that thing - and could be solved without adding the context & doing that work would help justify the work to migrate from global variables to a context)

[alexander-shaposhnikov]

lld/MachO/OutputSegment.cpp

17

@dblaikie ok, thanks. Even though it feels like some decisions here are suboptimal (and I voiced these concerns because this is just the beginning of the project (for MachO), later it will arguably get more complicated), that's just my personal opinion, no more than that. I can only emphasize that don't want to block this diff and I'm also interested in having MachO support in LLD.

[dblaikie]

lld/MachO/OutputSegment.cpp

17

Yeah, I can totally appreciate the timing there - a new target being a new/independent opportunity to try something different and see how it looks/might inform the existing implementations, but just given the history here I think that'd be difficult and end up derailing this review so better handled as an independent proposal/experiment (which, to be sure, could be done on one target implementation - similarly to inform/see if it's a good idea for the others, etc)

Thanks for keeping these sort of design choices in mind, in any case!

[ruiu]

lld/MachO/OutputSegment.cpp

17

I wrote a comment but deleted to avoid derailing the code review (and most comments were already mentioned in previous threads anyway.) As to this mach-o port, I strongly prefer to stick with the same design as other ports so that we don't have to invent new ways of doing something but focus on writing a working mach-o linker first. In fact, if we want to experiment an idea to change the way how we manage the context, I think we should do that for other port, as it should give you a whole picture how it will look like at last.

[smeenai]

@ruiu, as LLD code owner, would you be able to review this and give a LGTM as well, since it's the initial commit for a new backend?

[ruiu]

LGTM

Thank you very much for doing this!

lld/MachO/InputFiles.cpp

142

nit: ObjKind -> objKind

[int3]

Thanks everyone for the reviews and suggestions!

[int3]

lld/MachO/InputFiles.cpp

142

hm this is an enum value, not a member/parameter, so I think CamelCase is correct here?

[smeenai]

lld/MachO/InputFiles.cpp

142

Yeah ObjKind is consistent with LLD ELF.

[ruiu]

LGTM

[MaskRay]

I'll carefully read through the patch. Hope you don't mind keeping it open for more time.

[smeenai]

In D75382#1921008, @MaskRay wrote:

I'll carefully read through the patch. Hope you don't mind keeping it open for more time.

Sure, go ahead. The more eyes on this the better :)

[ruiu]

Jez and Shoaib, if you guys have more patches on this one, you can send them now for review if you want.

[smeenai]

In D75382#1921018, @ruiu wrote:

Jez and Shoaib, if you guys have more patches on this one, you can send them now for review if you want.

Yup, we'll start putting up follow-ups soon (probably next week).

[int3]

clang-tidy + rebase

[MaskRay]

lld/MachO/Driver.cpp

41

const char *NAME[] = VALUE;

75

Add a -arch i386 test. There is currently no test.

90

Add a test similar to test/ELF/invalid/executable.s

127

Add an -e test with an undefined symbol.

140

vec can be omitted.

lld/MachO/InputFiles.cpp

25

the beginning

Do you mean that a symbol defined in the section must be at the beginning of a subsection, unless the N_ALT_ENTRY attribute is set?

71

Add a cannot open test. See test/ELF/basic.s (I don't think placing many things in one file is good but you can copy one of the tests (%t.no.such.file))

85

for (uint32_t i =0, n = hdr->ncmds, i != n; ++i)

https://llvm.org/docs/CodingStandards.html#don-t-evaluate-end-every-time-through-a-loop

86

reinterpret_cast is more idiomatic.

107

What if sec.align is >= 32 ?

[MaskRay]

lld/MachO/Arch/X86_64.cpp

51

getImplicitAddend errors for an unknown relocation type. Is here unreachable?

lld/MachO/Options.td

12

--version uses a double-dash form while other long options use single-dash form. Can you confirm?

lld/MachO/Target.h

19

pageSize
imageBase

28

In ELF, D73254 renamed relocateOne to relocate and passed in Relocation. You may think whether Mach-O will need other fields of Reloc.

lld/MachO/Writer.cpp

39

virtual uint64_t getSize() const = 0;

50

Why are the two variables not placed with other member variables?

95

const

100

Can os be local to createDyldInfoContents?

[int3]

minor update

[int3]

address comments

[int3]

update

lld/MachO/Arch/X86_64.cpp

51

good point, hadn't noticed that Writer would exit if errorCount was nonzero.

lld/MachO/InputFiles.cpp

25

It was @ruiu who originally wrote this, but I believe it means that a symbol w/o the N_ALT_ENTRY attribute defines the beginning of a subsection. So your statement should be true by definition. Maybe "by default" should be replaced with "by definition"...

86

fair enough. I've converted all the C-style casts I could find.

107

I haven't found the logic in ld64 that handles this, but some experimentation (creating object files with high alignments using yaml2obj and then passing it to ld64) suggests it does applies mod 256 to sec.align w/o emitting warnings or anything. Obviously 2 ** 256 is still ridiculously large, and ultimately ld64 emits a 2GB object file, so it looks like some silent overflows are happening.

I'm leaning towards applying mod 32 here and emitting a warning.

lld/MachO/Options.td

12

hm, ld64 actually doesn't have a version flag at all, I was just copying lld-elf here... but I suppose it would make sense for this to be single-dash to be consistent with the other flags here (and in ld64)

lld/MachO/Target.h

19

clang-tidy specifies enums to be CamelCase

[int3]

update

[ruiu]

lld/MachO/InputFiles.cpp

107

mod 32 seems a bit too arbitrary, so how about always setting isec->align to sec.align with a warning if sec.align is too large?

lld/MachO/Options.td

12

It looks like ld64 does have -v instead of --version or -version.

[int3]

lld/MachO/InputFiles.cpp

107

how do you propose we align the addresses for sections with large align values?

[ruiu]

lld/MachO/InputFiles.cpp

107

Oh, the first thing I'd like to point out is that we store raw alignment values instead of power-of-two values to alignment variables in other ports, and mach-o probably should follow that to avoid confusion, even if it means we compute a power-of-two and then convert it back to an exponent.

To answer to your question, if you use uint32_t for align member, the maximum alignment we can represent is naturally limited to 2^31. How about print out an error (instead of warning) if it is greater than that?

[int3]

change alignment handling

lld/MachO/InputFiles.cpp

107

Ah, thanks for the explanation. And yeah, I guess ld64's behavior isn't worth emulating, erroring out is better.

[ruiu]

LGTM

lld/MachO/InputFiles.cpp

109

nit: error messages should start with a lowercase letter.

110

Set a dummy value (e.g. 1) to isec->align if the input is invalid, so that even after we meet an error condition, all the member variables are at least initialized with some value instead of left uninitialized.

[int3]

lowercase

[int3]

lld/MachO/InputFiles.cpp

110

align is default-initialized to zero in the class definition

[int3]

more const + override

[int3]

fix align handling

[int3]

have LC::getSize() return uint32_t since sizeofcmds is 32 bit

[ruiu]

Can you submit this change? I think this is good enough as an initial commit, and you can make further changes on top of this.

[int3]

rebase

[int3]

I don't have commit access yet. @smeenai, could you do it?

[smeenai]

In D75382#1952987, @int3 wrote:

I don't have commit access yet. @smeenai, could you do it?

Sure, I can get to this soon.

[MaskRay]

In D75382#1953004, @smeenai wrote:

In D75382#1952987, @int3 wrote:

I don't have commit access yet. @smeenai, could you do it?

Sure, I can get to this soon.

Make sure to use git c --amend --author='Jez Ng <.............>'

[smeenai]

In D75382#1953014, @MaskRay wrote:

In D75382#1953004, @smeenai wrote:

In D75382#1952987, @int3 wrote:

I don't have commit access yet. @smeenai, could you do it?

Sure, I can get to this soon.

Make sure to use git c --amend --author='Jez Ng <.............>'

@int3 used arc diff to upload the patch, so arc patch sets the correct author information automatically.

[MaskRay]

This was reverted by af39151f3c54b90ff0ae1064f540a97b640298e9 along with my gn build fix (c886e2be1ee4c57ef9f3a75509b4f2299ad9f61b).

@ostannard Hope you can paste a notice and give some time before reverting :)
This looks like an easy fix. A revert could be more disruptive.

Relanded with commit 6acd3003755db3944f7fcbea7542bd574a41c0a0

lld/CMakeLists.txt

 if (LLVM_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(unittests)
 endif()
 
 add_subdirectory(docs)
 add_subdirectory(COFF)
 add_subdirectory(ELF)
+add_subdirectory(MachO)
 add_subdirectory(MinGW)
 add_subdirectory(wasm)

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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Target.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/Endian.h"
+
+using namespace llvm::MachO;
+using namespace llvm::support::endian;
+using namespace lld;
+using namespace lld::macho;
+
+namespace {
+
+struct X86_64 : TargetInfo {
+  X86_64();
+  uint64_t getImplicitAddend(const uint8_t *loc, uint8_t type) const;
+  void relocateOne(uint8_t *loc, uint8_t type, uint64_t val) const;
+};
+
+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:
+    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.
+    write32le(loc, val - 4);
+    break;
+  default:
+    error("TODO: Unhandled relocation type");
+  }
+}
+
+} // 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
+  Target.cpp
+  Writer.cpp
+
+  LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  BinaryFormat
+  Core
+  DebugInfoDWARF
+  LTO
+  MC
+  Object
+  Option
+  Support
+
+  LINK_LIBS
+  lldCommon
+  ${LLVM_PTHREAD_LIB}
+
+  DEPENDS
+  MachOOptionsTableGen
+  ${tablegen_deps}
+  )

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

lld/MachO/Driver.h

+//===- Driver.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_DRIVER_H
+#define LLD_MACHO_DRIVER_H
+
+#include "lld/Common/LLVM.h"
+#include "llvm/Option/OptTable.h"
+
+namespace lld {
+namespace macho {
+
+class MachOOptTable : public llvm::opt::OptTable {
+public:
+  MachOOptTable();
+  llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
+};
+
+// Create enum with OPT_xxx values for each option in Options.td
+enum {
+  OPT_INVALID = 0,
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+} // 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Driver.h"
+#include "Config.h"
+#include "InputFiles.h"
+#include "OutputSegment.h"
+#include "SymbolTable.h"
+#include "Symbols.h"
+#include "Target.h"
+#include "Writer.h"
+
+#include "lld/Common/Args.h"
+#include "lld/Common/Driver.h"
+#include "lld/Common/ErrorHandler.h"
+#include "lld/Common/LLVM.h"
+#include "lld/Common/Memory.h"
+#include "lld/Common/Version.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+using namespace llvm;
+using namespace llvm::MachO;
+using namespace llvm::sys;
+using namespace lld;
+using namespace lld::macho;
+
+Configuration *lld::macho::config;
+
+// Create prefix string literals used in Options.td
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Options.inc"
+#undef PREFIX
+
+// Create table mapping all options defined in Options.td
+static const opt::OptTable::Info optInfo[] = {
+#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
+  {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
+   X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
+#include "Options.inc"
+#undef OPTION
+};
+
+MachOOptTable::MachOOptTable() : OptTable(optInfo) {}
+
+opt::InputArgList MachOOptTable::parse(ArrayRef<const char *> argv) {
+  // Make InputArgList from string vectors.
+  unsigned missingIndex;
+  unsigned missingCount;
+  SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
+
+  opt::InputArgList args = ParseArgs(vec, missingIndex, missingCount);
+
+  if (missingCount)
+    error(Twine(args.getArgString(missingIndex)) + ": missing argument");
+
+  for (opt::Arg *arg : args.filtered(OPT_UNKNOWN))
+    error("unknown argument: " + arg->getSpelling());
+  return args;
+}
+
+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 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;
+  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;
+  lld::stderrOS = &stderrOS;
+
+  MachOOptTable parser;
+  opt::InputArgList args = parser.parse(argsArr.slice(1));
+
+  if (args.hasArg(OPT_version)) {
+    message(getLLDVersion());
+    freeArena();
+    return !errorCount();
+  }
+
+  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");
+
+  getOrCreateOutputSegment("__TEXT", VM_PROT_READ | VM_PROT_EXECUTE);
+  getOrCreateOutputSegment("__DATA", VM_PROT_READ | VM_PROT_WRITE);
+
+  for (opt::Arg *arg : args) {
+    switch (arg->getOption().getID()) {
+    case OPT_INPUT:
+      addFile(arg->getValue());
+      break;
+    }
+  }
+
+  if (!isa<Defined>(config->entry)) {
+    error("undefined symbol: " + config->entry->getName());
+    return false;
+  }
+
+  // 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);
+    std::vector<InputSection *> &vec = os->sections[isec->name];
+    vec.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_MACHO_INPUT_FILES_H
+#define LLD_MACHO_INPUT_FILES_H
+
+#include "lld/Common/LLVM.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <vector>
+
+namespace lld {
+namespace macho {
+
+class InputSection;
+class Symbol;
+struct Reloc;
+
+class InputFile {
+public:
+  enum Kind {
+    ObjKind,
+  };
+
+  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; }
+};
+
+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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains functions to parse Mach-O object files. In this comment,
+// we describe the Mach-O file structure and how we parse it.
+//
+// Mach-O is not very different from ELF or COFF. The notion of symbols,
+// sections and relocations exists in Mach-O as it does in ELF and COFF.
+//
+// Perhaps the notion that is new to those who know ELF/COFF is "subsections".
+// In ELF/COFF, sections are an atomic unit of data copied from input files to
+// output files. When we merge or garbage-collect sections, we treat each
+// section as an atomic unit. In Mach-O, that's not the case. Sections can
+// consist of multiple subsections, and subsections are a unit of merging and
+// garbage-collecting. Therefore, Mach-O's subsections are more similar to
+// ELF/COFF's sections than Mach-O's sections are.
+//
+// A section can have multiple symbols. A symbol that does not have
+// N_ALT_ENTRY attribute indicates a beginning of a subsection. Therefore, by
+// default, a symbol is always present at beginning of each subsection. A
+// symbol with N_ALT_ENTRY attribute does not start a new subsection and can
+// point to a middle of a subsection.
+//
+// The notion of subsections also affects how relocations are represented in
+// Mach-O. All references within a section need to be explicitly represented
+// as relocations if they refer to different subsections, because we obviously
+// need to fix up addresses if subsections are laid out in an output file
+// differently than they were in object files. To represent that, Mach-O
+// relocations can refer to an unnamed location via its address. Scattered
+// relocations (those with the R_SCATTERED bit set) always refer to unnamed
+// locations. Non-scattered relocations refer to an unnamed location if
+// r_extern is not set and r_symbolnum is zero.
+//
+// Without the above differences, I think you can use your knowledge about ELF
+// and COFF for Mach-O.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InputFiles.h"
+#include "InputSection.h"
+#include "OutputSegment.h"
+#include "SymbolTable.h"
+#include "Symbols.h"
+#include "Target.h"
+
+#include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Memory.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+using namespace llvm;
+using namespace llvm::MachO;
+using namespace llvm::support::endian;
+using namespace lld;
+using namespace lld::macho;
+
+std::vector<InputFile *> macho::inputFiles;
+
+// Open a given file path and return it as a memory-mapped file.
+Optional<MemoryBufferRef> macho::readFile(StringRef path) {
+  // Open a file.
+  auto mbOrErr = MemoryBuffer::getFile(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
+  return mbref;
+}
+
+static const load_command *findCommand(const mach_header_64 *hdr,
+                                       uint32_t type) {
+  const uint8_t *p = (const uint8_t *)hdr + sizeof(mach_header_64);
+
+  for (size_t i = 0; i < hdr->ncmds; ++i) {
+    auto *cmd = (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 = (const uint8_t *)mb.getBufferStart();
+
+  for (const section_64 &sec : sections) {
+    InputSection *isec = make<InputSection>();
+    isec->file = this;
+    isec->name = StringRef(sec.sectname, strnlen(sec.sectname, 16));
+    isec->segname = StringRef(sec.segname, strnlen(sec.segname, 16));
+    isec->data = {buf + sec.offset, sec.size};
+    isec->align = 1 << sec.align;
+    isec->flags = sec.flags;
+    ret.push_back(isec);
+  }
+
+  return ret;
+}
+
+void InputFile::parseRelocations(const section_64 &sec,
+                                 std::vector<Reloc> &relocs) {
+  auto *buf = (const uint8_t *)mb.getBufferStart();
+  ArrayRef<any_relocation_info> relInfos(
+      reinterpret_cast<const any_relocation_info *>(buf + sec.reloff),
+      sec.nreloc);
+
+  for (const any_relocation_info &anyRel : relInfos) {
+    Reloc r;
+    if (anyRel.r_word0 & R_SCATTERED) {
+      error("TODO: Scattered relocations not supported");
+    } else {
+      auto rel = reinterpret_cast<const relocation_info &>(anyRel);
+      r.type = rel.r_type;
+      r.offset = rel.r_address;
+      r.addend = target->getImplicitAddend(buf + sec.offset + r.offset, r.type);
+      if (rel.r_extern)
+        r.target = symbols[rel.r_symbolnum];
+      else {
+        error("TODO: Non-extern relocations are not supported");
+        continue;
+      }
+    }
+    relocs.push_back(r);
+  }
+}
+
+ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
+  auto *buf = (const uint8_t *)mb.getBufferStart();
+  auto *hdr = (const mach_header_64 *)mb.getBufferStart();
+  ArrayRef<section_64> objSections;
+
+  if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
+    auto *c = (const segment_command_64 *)cmd;
+    objSections = ArrayRef<section_64>{(const section_64 *)(c + 1), c->nsects};
+    sections = parseSections(objSections);
+  }
+
+  if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
+    auto *c = (const symtab_command *)cmd;
+    const char *strtab = (const char *)buf + c->stroff;
+    ArrayRef<const nlist_64> nList((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");
+        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 (sym.n_type & N_EXT) {
+        symbols.push_back(symtab->addDefined(name, isec, value));
+        continue;
+      }
+
+      // Local defined symbol
+      symbols.push_back(make<Defined>(name, isec, value));
+    }
+  }
+
+  // The relocations may refer to the symbols, so we parse them after we have
+  // the symbols loaded.
+  if (!sections.empty()) {
+    auto it = sections.begin();
+    for (const section_64 &sec : objSections) {
+      parseRelocations(sec, (*it)->relocs);
+      ++it;
+    }
+  }
+}
+
+// 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 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);
+
+  InputFile *file = nullptr;
+  StringRef name;
+  StringRef segname;
+
+  ArrayRef<uint8_t> data;
+  uint64_t addr = 0;
+  uint32_t align = 0;
+  uint32_t flags = 0;
+
+  std::vector<Reloc> relocs;
+};
+
+extern std::vector<InputSection *> inputSections;
+
+} // namespace macho
+} // namespace lld
+
+#endif

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 "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 *>())
+      va = s->getVA();
+    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 arch: Separate<["-"], "arch">, MetaVarName<"<arch-name>">,
+  HelpText<"Architecture to link">;
+
+def e: Separate<["-"], "e">, HelpText<"Name of entry point symbol">;
+
+def o: Separate<["-"], "o">, MetaVarName<"<path>">,
+  HelpText<"Path to file to write output">;
+
+def version: Flag<["--"], "version">, 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:
+  StringRef name;
+  uint32_t perms;
+  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/OutputSegment.cpp

+//===- OutputSegment.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 "OutputSegment.h"
+#include "lld/Common/Memory.h"
+
+using namespace llvm;
+using namespace lld;
+using namespace lld::macho;
+
+std::vector<OutputSegment *> macho::outputSegments;
+
+OutputSegment *macho::getOrCreateOutputSegment(StringRef name, uint32_t perms) {
+  for (OutputSegment *os : outputSegments)
+    if (os->name == name)
+      // TODO: assert that os->perms == perms, once we figure out what to do
+      // about default-created segments.
+      return os;
+
+  auto *os = make<OutputSegment>();
+  os->name = name;
+  os->perms = perms;
+  outputSegments.push_back(os);
+  return os;
+}

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 Symbol;
+
+class SymbolTable {
+public:
+  Symbol *addDefined(StringRef name, InputSection *isec, uint32_t value);
+
+  Symbol *addUndefined(StringRef name);
+
+  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
+//
+//===----------------------------------------------------------------------===//
+
+#include "SymbolTable.h"
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Memory.h"
+
+using namespace llvm;
+using namespace lld;
+using namespace lld::macho;
+
+Symbol *SymbolTable::find(StringRef name) {
+  auto it = symMap.find(llvm::CachedHashStringRef(name));
+  if (it == symMap.end())
+    return nullptr;
+  return symVector[it->second];
+}
+
+std::pair<Symbol *, bool> SymbolTable::insert(StringRef name) {
+  auto p = symMap.insert({CachedHashStringRef(name), (int)symVector.size()});
+
+  // Name already present in the symbol table.
+  if (!p.second)
+    return {symVector[p.first->second], false};
+
+  // Name is a new symbol.
+  Symbol *sym = (Symbol *)make<SymbolUnion>();
+  symVector.push_back(sym);
+  return {sym, true};
+}
+
+Symbol *SymbolTable::addDefined(StringRef name, InputSection *isec,
+                                uint32_t value) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name);
+
+  if (!wasInserted && isa<Defined>(s))
+    error("duplicate symbol: " + name);
+
+  replaceSymbol<Defined>(s, name, isec, value);
+  return s;
+}
+
+Symbol *SymbolTable::addUndefined(StringRef name) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name);
+
+  if (wasInserted)
+    replaceSymbol<Undefined>(s, 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 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,
+  };
+
+  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) {}
+
+  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) {}
+
+  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) {}
+
+  static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
+};
+
+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)];
+};
+
+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 &&
+         "Not a Symbol");
+
+  new (s) T(std::forward<ArgT>(arg)...);
+}
+
+} // namespace macho
+
+std::string toString(const macho::Symbol &);
+} // namespace lld
+
+#endif

lld/MachO/Symbols.cpp

+//===- Symbols.cpp --------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Symbols.h"
+#include "InputFiles.h"
+#include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Strings.h"
+
+using namespace llvm;
+using namespace lld;
+using namespace lld::macho;
+
+// Returns a symbol for an error message.
+std::string lld::toString(const Symbol &sym) {
+  if (Optional<std::string> s = demangleItanium(sym.getName()))
+    return *s;
+  return std::string(sym.getName());
+}

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 {
+  PageSize = 4096,
+  ImageBase = 4096,
+};
+
+class TargetInfo {
+public:
+  virtual ~TargetInfo() = default;
+  virtual uint64_t getImplicitAddend(const uint8_t *loc,
+                                     uint8_t type) const = 0;
+  virtual void relocateOne(uint8_t *loc, uint8_t type, uint64_t val) const = 0;
+
+  uint32_t cpuType;
+  uint32_t cpuSubtype;
+};
+
+TargetInfo *createX86_64TargetInfo();
+
+extern TargetInfo *target;
+
+} // namespace macho
+} // namespace lld
+
+#endif

lld/MachO/Target.cpp

+//===- Target.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 "Target.h"
+
+using namespace lld;
+using namespace lld::macho;
+
+TargetInfo *macho::target = nullptr;

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();
+
+} // 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 "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 llvm::support;
+using namespace lld;
+using namespace lld::macho;
+
+namespace {
+class LCLinkEdit;
+class LCDyldInfo;
+class LCSymtab;
+
+class LoadCommand {
+public:
+  virtual ~LoadCommand() = default;
+  virtual uint64_t getSize() = 0;
+  virtual void writeTo(uint8_t *buf) = 0;
+};
+
+class Writer {
+public:
+  Writer() : buffer(errorHandler().outputBuffer) {}
+
+  std::vector<LoadCommand *> loadCommands;
+
+  std::unique_ptr<FileOutputBuffer> &buffer;
+  uint64_t fileSize;
+
+  void createLoadCommands();
+  void assignAddresses();
+
+  void openFile();
+  void writeHeader();
+  void writeSections();
+
+  void run();
+
+  uint64_t sizeofCmds = 0;
+  LCLinkEdit *linkEditSeg = nullptr;
+  LCDyldInfo *dyldInfoSeg = nullptr;
+  LCSymtab *symtabSeg = nullptr;
+};
+
+class LCPagezero : public LoadCommand {
+public:
+  uint64_t getSize() { return sizeof(segment_command_64); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<segment_command_64 *>(buf);
+    c->cmd = LC_SEGMENT_64;
+    c->cmdsize = getSize();
+    strcpy(c->segname, "__PAGEZERO");
+    c->vmsize = PageSize;
+  }
+};
+
+class LCLinkEdit : public LoadCommand {
+public:
+  uint64_t getSize() { return sizeof(segment_command_64); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<segment_command_64 *>(buf);
+    c->cmd = LC_SEGMENT_64;
+    c->cmdsize = getSize();
+    strcpy(c->segname, "__LINKEDIT");
+    c->fileoff = fileOff;
+    c->filesize = contents.size();
+    c->maxprot = VM_PROT_READ | VM_PROT_WRITE;
+    c->initprot = VM_PROT_READ;
+  }
+
+  uint64_t getOffset() { return fileOff + contents.size(); }
+
+  uint64_t fileOff = 0;
+
+  SmallVector<char, 128> contents;
+  raw_svector_ostream os{contents};
+};
+
+class LCDyldInfo : public LoadCommand {
+public:
+  uint64_t getSize() { return sizeof(dyld_info_command); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<dyld_info_command *>(buf);
+    c->cmd = LC_DYLD_INFO_ONLY;
+    c->cmdsize = getSize();
+    c->export_off = exportOff;
+    c->export_size = exportSize;
+  }
+
+  uint64_t exportOff = 0;
+  uint64_t exportSize = 0;
+};
+
+class LCDysymtab : public LoadCommand {
+public:
+  uint64_t getSize() { return sizeof(dysymtab_command); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<dysymtab_command *>(buf);
+    c->cmd = LC_DYSYMTAB;
+    c->cmdsize = getSize();
+  }
+};
+
+class LCSegment : public LoadCommand {
+public:
+  LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {}
+
+  uint64_t getSize() {
+    return sizeof(segment_command_64) +
+           seg->sections.size() * sizeof(section_64);
+  }
+
+  void writeTo(uint8_t *buf) {
+    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->vmaddr = c->fileoff + ImageBase;
+    c->vmsize = c->filesize = lastSec->addr + lastSec->data.size() - 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->flags = sections[0]->flags;
+      sectHdr->size = sections.back()->addr + sections.back()->data.size() -
+                      sections[0]->addr;
+    }
+  }
+
+private:
+  StringRef name;
+  OutputSegment *seg;
+};
+
+class LCMain : public LoadCommand {
+  uint64_t getSize() { return sizeof(entry_point_command); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<entry_point_command *>(buf);
+    c->cmd = LC_MAIN;
+    c->cmdsize = getSize();
+    c->entryoff = config->entry->getVA();
+    c->stacksize = 0;
+  }
+};
+
+class LCSymtab : public LoadCommand {
+public:
+  uint64_t getSize() { return sizeof(symtab_command); }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<symtab_command *>(buf);
+    c->cmd = LC_SYMTAB;
+    c->cmdsize = getSize();
+  }
+};
+
+class LCLoadDylib : public LoadCommand {
+public:
+  LCLoadDylib(StringRef path) : path(path) {}
+
+  uint64_t getSize() {
+    return alignTo(sizeof(dylib_command) + path.size() + 1, 8);
+  }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<dylib_command *>(buf);
+    buf += sizeof(dylib_command);
+
+    c->cmd = LC_LOAD_DYLIB;
+    c->cmdsize = getSize();
+    c->dylib.name = sizeof(dylib_command);
+
+    memcpy(buf, path.data(), path.size());
+    buf[path.size()] = '\0';
+  }
+
+private:
+  StringRef path;
+};
+
+class LCLoadDylinker : public LoadCommand {
+public:
+  uint64_t getSize() {
+    return alignTo(sizeof(dylinker_command) + path.size() + 1, 8);
+  }
+
+  void writeTo(uint8_t *buf) {
+    auto *c = reinterpret_cast<dylinker_command *>(buf);
+    buf += sizeof(dylinker_command);
+
+    c->cmd = LC_LOAD_DYLINKER;
+    c->cmdsize = getSize();
+    c->name = sizeof(dylinker_command);
+
+    memcpy(buf, path.data(), path.size());
+    buf[path.size()] = '\0';
+  }
+
+private:
+  // Recent versions of Darwin won't run any binary that has dyld at a
+  // different location.
+  const StringRef path = "/usr/lib/dyld";
+};
+} // namespace
+
+void Writer::createLoadCommands() {
+  linkEditSeg = make<LCLinkEdit>();
+  dyldInfoSeg = make<LCDyldInfo>();
+  symtabSeg = make<LCSymtab>();
+
+  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>());
+  // 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::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();
+      }
+    }
+  }
+
+  linkEditSeg->fileOff = addr - ImageBase;
+}
+
+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()));
+  else
+    buffer = std::move(*bufferOrErr);
+}
+
+void Writer::writeHeader() {
+  auto *hdr = reinterpret_cast<mach_header_64 *>(buffer->getBufferStart());
+  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->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 Writer::writeSections() {
+  uint8_t *buf = buffer->getBufferStart();
+
+  for (OutputSegment *seg : outputSegments)
+    for (auto &sect : seg->sections)
+      for (InputSection *isec : sect.second)
+        isec->writeTo(buf + isec->addr - ImageBase);
+
+  memcpy(buf + linkEditSeg->fileOff, linkEditSeg->contents.data(),
+         linkEditSeg->contents.size());
+}
+
+void Writer::run() {
+  createLoadCommands();
+  assignAddresses();
+  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(); }

lld/include/lld/Common/Driver.h

bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS);
 }
 
 namespace mach_o {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS);
 }
 
+namespace macho {
+bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
+          llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS);
+}
+
 namespace wasm {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS);
 }
 }
 
 #endif

lld/test/MachO/duplicate-symbol.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t-dup.o
+# RUN: not lld -flavor darwinnew -o /dev/null %t-dup.o %t.o 2>&1 | FileCheck %s
+
+# CHECK: duplicate symbol: _main
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret

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-DAG: cmd:             LC_DYLD_INFO_ONLY
+# CHECK-DAG: cmd:             LC_SYMTAB
+# CHECK-DAG: cmd:             LC_DYSYMTAB
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret

lld/test/MachO/relocations.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-objdump -d %t | FileCheck %s
+
+# CHECK: leaq 17(%rip), %rsi
+
+.section __TEXT,__text
+.globl _main
+_main:
+  movl $0x2000004, %eax # write() syscall
+  mov $1, %rdi # stdout
+  leaq str(%rip), %rsi
+  mov $13, %rdx # length of str
+  syscall
+  mov $0, %rax
+  ret
+
+.section __TEXT,__cstring
+str:
+  .asciz "Hello world!\n"

lld/test/MachO/section-names.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 --section-headers %t | FileCheck %s
+
+# CHECK:      Name: __text
+# CHECK-NEXT: Segment: __TEXT
+# CHECK:      Type: Regular (0x0)
+# CHECK-NEXT: Attributes [ (0x800004)
+# CHECK-NEXT:   PureInstructions (0x800000)
+# CHECK-NEXT:   SomeInstructions (0x4)
+# CHECK-NEXT: ]
+# CHECK:      Name: __cstring
+# CHECK-NEXT: Segment: __TEXT
+# CHECK:      Type: CStringLiterals (0x2)
+# CHECK-NEXT: Attributes [ (0x0)
+# CHECK-NEXT: ]
+# CHECK:      Name: maxlen_16ch_name
+# CHECK-NEXT: Segment: __TEXT
+# CHECK:      Type: Regular (0x0)
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret
+
+.section __TEXT,__cstring
+str:
+  .asciz "Hello world!\n"
+
+.section __TEXT,maxlen_16ch_name

lld/test/MachO/segments.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 --macho-segment %t | FileCheck %s
+
+# These segments must always be present.
+# CHECK-DAG: Name: __PAGEZERO
+# CHECK-DAG: Name: __LINKEDIT
+# CHECK-DAG: Name: __TEXT
+
+# Check that we handle max-length names correctly.
+# CHECK-DAG: Name: maxlen_16ch_name
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret
+
+.section maxlen_16ch_name,foo

lld/test/MachO/silent-ignore.test

+RUN: lld -flavor darwinnew --version \
+RUN:   -demangle \
+RUN:   -dynamic \
+RUN:   -no_deduplicate \
+RUN:   -lto_library /lib/foo \
+RUN:   -macosx_version_min 0
+RUN: not lld -flavor darwinnew --version --not-an-ignored-argument

lld/test/MachO/text-segment.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 --macho-segment %t | FileCheck %s
+
+# CHECK: Name: __TEXT
+# CHECK-NOT: }
+# dyld3 assumes that the __TEXT segment starts from the file header
+# CHECK:       fileoff: 0
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret

lld/test/MachO/undefined-entry.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: not lld -flavor darwinnew -o %t %t.o 2>&1 | FileCheck %s
+
+# CHECK: undefined symbol: _main
+
+.text
+.global _not_main
+_not_main:
+  ret

lld/tools/lld/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_lld_tool(lld
   lld.cpp
   )
 
 target_link_libraries(lld
   PRIVATE
   lldCommon
   lldCOFF
   lldDriver
   lldELF
+  lldMachO2
   lldMinGW
   lldWasm
   )
 
 install(TARGETS lld
   RUNTIME DESTINATION bin)
 
 if(NOT LLD_SYMLINKS_TO_CREATE)
   set(LLD_SYMLINKS_TO_CREATE lld-link ld.lld ld64.lld wasm-ld)
 endif()
 
 foreach(link ${LLD_SYMLINKS_TO_CREATE})
   add_lld_symlink(${link} lld)
 endforeach()

lld/tools/lld/lld.cpp

 #include <cstdlib>
 
 using namespace lld;
 using namespace llvm;
 using namespace llvm::sys;
 
 enum Flavor {
   Invalid,
-  Gnu,     // -flavor gnu
-  WinLink, // -flavor link
-  Darwin,  // -flavor darwin
-  Wasm,    // -flavor wasm
+  Gnu,       // -flavor gnu
+  WinLink,   // -flavor link
+  Darwin,    // -flavor darwin
+  DarwinNew, // -flavor darwinnew
+  Wasm,      // -flavor wasm
 };
 
 LLVM_ATTRIBUTE_NORETURN static void die(const Twine &s) {
   llvm::errs() << s << "\n";
   exit(1);
 }
 
 static Flavor getFlavor(StringRef s) {
   return StringSwitch<Flavor>(s)
       .CasesLower("ld", "ld.lld", "gnu", Gnu)
       .CasesLower("wasm", "ld-wasm", Wasm)
       .CaseLower("link", WinLink)
       .CasesLower("ld64", "ld64.lld", "darwin", Darwin)
+      .CaseLower("darwinnew", DarwinNew)
       .Default(Invalid);
 }
 
 static cl::TokenizerCallback getDefaultQuotingStyle() {
   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
     return cl::TokenizeWindowsCommandLine;
   return cl::TokenizeGNUCommandLine;
 }
int main(int argc, const char **argv) {
   case Gnu:
     if (isPETarget(args))
       return !mingw::link(args, canExitEarly(), llvm::outs(), llvm::errs());
     return !elf::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case WinLink:
     return !coff::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case Darwin:
     return !mach_o::link(args, canExitEarly(), llvm::outs(), llvm::errs());
+  case DarwinNew:
+    return !macho::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case Wasm:
     return !wasm::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld"
         " (WebAssembly) instead");
   }
 }