[LLD] Add NetBSD support as a new flavor of LLD (nb.lld)

[krytarowski]

Summary

The NetBSD target wraps the default Linux/ELF target with OS
specific customization. It is implemented as a light netbsd::link()
module wrapper that mutates arguments in argv[] and calls
elf::link().

This flavor detects the native/current and target Triple based on
argv[0] parsing. This is prerequisite for cross-compilation, in
particular the NetBSD distribution is cross-built always.

The default configuration of the ELF target is tuned for Linux and
there is no way to costomize in-place for the NetBSD target in the
same way as FreeBSD/OpenBSD. FreeBSD whenever needed can check
emulation name ("*_fbsd") and OpenBSD calls its extensions
"PT_OPENBSD_*".

This distinct flavor is needed for NetBSD as:

• the linker MUST work in the standalone mode
• it must be useful with gcc/pcc/others out of the box
• clang NetBSD driver shall not hardcode LLD specific options
• the linker must have support for cross-building
• LLD shall be a drop-in replacement for (NetBSD-patched) GNU ld

There is no code-duplication between the NetBSD and ELF modules.
The NetBSD driver for debugging purposes prints the Target string
for the -v|-V|--version command line argument. There is no functional
or code maintenance change for other Operating Systems, especially
the ELF ones.

Equivalent customization is already done for the Darwin mode. For
instance there are hardcoded default search paths such as "/usr/lib"
and "/Library/Frameworks" in DarwinLdDriver.cpp. There is a prior
art with the MinGW target that similarly wraps coff:link().

This change is a starting point for development of NetBSD support
in LLD.

[krytarowski]

Another approach to achieve the same goal as previous attempts. It is already better as it avoids two forks.

Does this one look like fine for merging?

The previous one for the reference: https://reviews.llvm.org/D69755

[krytarowski]

• fix a typo in a comment.

[krytarowski]

Short summary:

• FreeBSD/OpenBSD ship with mutations of the behavior of ELF/GNU/Linux in certain nits, we do the same with our driver.
• MinGW ships with a frontend driver to COFF, we do the same with a driver to ELF/GNU/Linux.
• Darwin ships with default search paths, we do the same in our driver.
• NetBSD is not a GNU system, it is a BSD system that differs with ELF/GNU/Linux, GNU/Linux is at most an inspiration, none of our project goals is about reimplementing Linux. The same applies to MinGW, Darwin etc that do not reimplement Linux.
• We already patch LLVM code for NetBSD support, especially LLDB and compiler-rt are the most heavily modified one.

The proposed change does not make anything without prior art.

LLD is practically the last piece of the LLVM toolchain stack without NetBSD support. We run the NetBSD buildbot for LLD since 2018 and there are no plans to detach it.

We intend to integrate LLD into our distribution, but we first must make it work in the upstream version out of the box.

[krytarowski]

ping?

[krytarowski]

Ping?

We are in the process of switching our buildbot to newer NetBSD snapshot (-8 to -9) and we keep waiting for this patch to land.

If we could get this patch merged, we could build and link the whole LLVM with lld on NetBSD and it would increase the productivity of the bot (better build times). Right now we need to maintain hacks to link at most with 2/3 cores, while 5/6 ones are idling doing nothing due to enormous RAM consumption of GNU ld.

We also upgraded LLVM in the current snapshot to a 10git version, and for the next snapshot merged (hopefully 10.0 or early 11git) we could ship it together with LLD aboard.

[krytarowski]

Ping?

[MaskRay]

If we could get this patch merged, we could build and link the whole LLVM with lld on NetBSD and it would increase the productivity of the bot (better build times). Right now we need to maintain hacks to link at most with 2/3 cores, while 5/6 ones are idling doing nothing due to enormous RAM consumption of GNU ld.

I will be very happy to see the productivity of NetBSD build bot gets improved. My comments below are about the approach you choose in this patch.

FreeBSD/OpenBSD ship with mutations of the behavior of ELF/GNU/Linux in certain nits, we do the same with our driver.

The FreeBSD specific code is just the following 4 lines in ELF/Driver.cpp:

if (s.endswith("_fbsd")) {
  s = s.drop_back(5);
  osabi = ELFOSABI_FREEBSD;
}

PT_OPENBSD_* extensions are related to https://bugs.llvm.org//show_bug.cgi?id=31288 , which predated my involvement into lld.
It was not a good example of issue reports. Neither the bug nor the link it referenced provided rationale why such extensions were needed. That decision was made before my involvement into lld, though. If such patches were posted now, I would definitely ask if there were alternative ways to do things that would be less intrusive. CC @brad here. I will also ask in their IRC channel and/or send an email to their mailing list.

On the contrary, the NetBSD extension does much more than FreeBSD (4 lines of code) and OpenBSD (7 lines of code modulo comments). The patch introduces another toplevel driver nb.lld, and includes ~200 lines of change.
Moreover, I anticipate you will post another patch with probably more than 200 lines of code that does https://blog.netbsd.org/tnf/entry/the_first_report_on_lld#handling-of-indirect-shared-library-dependencies , which many people (probably even the GNU maintainers) feel no longer appropriate nowadays. IIRC an earlier review already got pushback from several lld contributors.

the linker MUST work in the standalone mode

By standalone mode, do you mean $(LD) or ld? I think for most such use cases, we should probably change them to do gcc/clang -nostdlib instead. In most cases users are not supposed to call ld directly. On FreeBSD (and Google servers and Android, if you consider them distributions), it has been proved many packages don't need ld customization to function properly. I personally fixed >10 instances of direct ld invocation in the internal Google code base. Many (including some third party or Google open sourced projects) use really brittle constructs and can break when different build configurations are considered. They are almost all fixed by changing to $(CC) alternatives, with only a few exceptions where GNU ld has to be used (tricky linker scripts that lld does not provide great compatibility with GNU ld).

If you can't migrate off those packages right now, a shell script that gets installed at "/usr/bin/ld" will probably work.

clang NetBSD driver shall not hardcode LLD specific options

Several toolchains in the clang/lib/Driver/ToolChains detect lld and make lld specific decisions there. While I hope linker specific options should be kept at a minimum, I understand that sometimes it is unavoidable. When we have no choice but to add linker specific options, adding such code to clangDriver is an established practice followed by almost every toolchain (see Android, Fuchsia, MinGW, MSVC, etc). Doing the driver thing in two places will more likely to cause conflicts.

the linker must have support for cross-building

I think this patch will actually harm cross building that targets NetBSD. Before, ld.lld is shared by all ELF platforms: Linux, FreeBSD, Fuchsia, Android, ChromeOS, etc. If an ELF change works on Linux, it will assuredly work on other platforms. This patch will introduce a new driver that naturally gets less test coverage.

[ruiu]

lld is not that Linux-centric as you implied in your comment. We have code for FreeBSD, OpenBSD, AMDGPU and Fuchsia (which isn't even a POSIX system), and adding code for NetBSD is OK and is appreciated. However, the thing we've been trying to avoid is to hard-code a platform-specific knowledge such as library paths to the linker. Combined with the fact that lld doesn't provide a way to enable/disable targets at build-time, all ld.lld executables (sometimes installed as /usr/bin/ld) work the same way no matter where they are run on. That helps those who do cross compilation a lot. That is a very appreciated property of our linker, and I don't think I want make an exception for NetBSD. Even on NetBSD, lld should behave the same as running on other kind of hosts.

Also, frankly speaking, having a driver only for NetBSD seems very odd to me. We would have 5 drivers for MSVC link.exe, MinGW, ELF-based systems, macOS, and NetBSD? That doesn't feel right. If you strongly feel that the linker should know the library paths and the like, it shouldn't be too hard to write a shell script wrapper to wrap lld.

[krytarowski]

We attempted to patch internally LLD rebasing our code for the buildbot purposes but LLD without being used rots quickly, see: https://reviews.llvm.org/D58892

We use LD as ld and there are no plans neither intentions to break it. It was already decided internally in the project.

If you insist, I can rewrite nb.lld from C++ to shell and upstream to the LLD repository. We require -fuse-ld=lld to be rerouted through this shell script and lld invocation call it so we can revert back to the concept from https://reviews.llvm.org/D69755. Personally I see no gain in this as I prefer to rely on LLVM libs at least for Target Triplet detection.

As I can understand that Linux/GNU behavior is promoted (and enforced to other ELF OSs) it does not work for us. I propose a patch that keeps intact the GNU/Linux code.

If 200 LOC for NetBSD is a show stopper, please see e.g. compiler-rt where we maintain 2 orders of magnitude more NetBSD-only LOC.

I try to avoid forking LLD for downstream and this shall be appreciated.

[MaskRay]

In D58892#1784119, @mgorny wrote:

In D58892#1783042, @MaskRay wrote:

In D58892#1783029, @mgorny wrote:

I know I'm late to the party but this change thoroughly destroyed NetBSD support. The NetBSD loader doesn't support having more than two PT_LOAD sections. -z norosegment helped with that so far but after this change practically everything fails to run.

This seems to be a very serious limitation. I have difficult to understand how such limitation could exist at all, but I think this should be straightforward to fix.

Yes, it is a serious limitation, and no, it's not straightforward to fix. The loader has making a lot of assumptions, especially what PT_LOAD segments to expect and in which order. I've previously made a patch that allowed third segment but it was rejected as apparently 'not doing it the right way'. Almost a year has passed, and I am entirely powerless to fix it.

@mgorny told me that NetBSD ld.so has a limitation that it can only handle 2 PT_LOAD segments.

I think the NetBSD toolchain team's attitude toward certain ELF things should probably be made more flexible. For that particular PT_LOAD limitation issue (a.out heritage?), if @mgorny don't mind giving me a pointer, I'd like to help argue fixing the limitation.

If 200 LOC for NetBSD is a show stopper, please see e.g. compiler-rt where we maintain 2 orders of magnitude more NetBSD-only LOC.

I am not sure compiler-rt is a good example here. The "2 orders of magnitude more" OS specific things make compiler-rt difficult to maintain. Innovations can be easily constrained by the numerous OS specific customization. I am glad that lld hasn't entered that situation.

I feel that NetBSD's stubborn attitude is adding complexity to many other projects.

I try to avoid forking LLD for downstream and this shall be appreciated.

If you can accept DT_RUNPATH and fix the PT_LOAD limitation, then it seems NetBSD just needs its own ld wrapper that adds -L, and probably -znognustack which saves you 56 bytes. I don't understand why such customization should still be upstreamed.

[krytarowski]

@joerg works on the ELF loader and we just need to wait for him. We wrote our temporary patch, but it was not ideal as the long term solution.

compiler-rt is nicely maintained from our perspective and we have almost feature parity with Linux.

We maintain and develop around 4000 NetBSD specific LOC in LLDB. That number grows, especially with each CPU architecture gaining support [soon in upstream].

it seems NetBSD just needs

This is not everything, but I don't want to derail yet another review into offtopic or generic discussion. Getting lld functional standalone is merely a starting point for us.

We need a linker that is a GNU ld drop-in replacement. As we have no interest in fixing it for Linux, we want this property for NetBSD.

I don't understand why such customization should still be upstreamed.

LLD is by default bricked, without upstreaming standalone LLD support it will be broken for NetBSD and we will keep observing that people attempt to cross-build malformed binaries for our OS (as they will be at least tuned for Linux). Additionally this forces us to maintain a subproject (LLD Standalone) externally.

[krytarowski]

Stating it from a different side. If you do not care about GNU ld drop-in replacement property for Linux it's not our business, but we do care about this in NetBSD and we restrict this to our project only (from ELF targets). If you do not care about NetBSD, you shall not care how and whether we use LLD. We try hard to not interfere with Linux looking for a consensus.

You are not forced to use the NetBSD driver neither define it in LLD_SYMLINKS_TO_CREATE. If you have a strong disrespect to this GNU ld drop-in replacement approach, I can patch the die("") invocation in main() to conditionally print "nb.lld". There are around 20 lines patches in the generic code and around 1/3 of that is in the code comments. This shall not be burden for any of you... there is a larger NetBSD-only single code block even in LLVM OpenMP.

[krytarowski]

Ping?

[krytarowski]

@MaskRay I will mail you off-list with one question.

[krytarowski]

Ping?

[krytarowski]

LLVM Release Schedule: 10.0.0: Jan 15, 2020: branch, then rc1

It would be nice to get a reply to my mail proposal before the branch.. so we could push the code for LLVM 10. (If it was lost, I can resend it) It can likely upset both sides, but with the proposal in the end we get a bfd.ld drop-in replacement. (One of LLVM goals was to be a drop-in replacement for GNU toolchain components, even if some of them are irrelevant on a number of platforms.)

clang/lib/Driver/ToolChain.cpp

std::string ToolChain::GetLinkerPath() const {
   } else if (UseLinker.empty() || UseLinker == "ld") {
     // If we're passed -fuse-ld= with no argument, or with the argument ld,
     // then use whatever the default system linker is.
     return GetProgramPath(getDefaultLinker());
   } else {
     llvm::SmallString<8> LinkerName;
     if (Triple.isOSDarwin())
       LinkerName.append("ld64.");
+    else if (Triple.isOSNetBSD())
+      LinkerName.append("nb.");
     else
       LinkerName.append("ld.");
     LinkerName.append(UseLinker);
 
     std::string LinkerPath(GetProgramPath(LinkerName.c_str()));
     if (llvm::sys::fs::can_execute(LinkerPath))
       return LinkerPath;
   }

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(MinGW)
+add_subdirectory(NetBSD)
 add_subdirectory(wasm)

lld/NetBSD/CMakeLists.txt

+set(LLVM_TARGET_DEFINITIONS Options.td)
+tablegen(LLVM Options.inc -gen-opt-parser-defs)
+add_public_tablegen_target(NetBSDOptionsTableGen)
+
+if(NOT LLD_BUILT_STANDALONE)
+  set(tablegen_deps intrinsics_gen)
+endif()
+
+add_lld_library(lldNetBSD
+  Driver.cpp
+
+  LINK_COMPONENTS
+  Option
+  Support
+  Target
+
+  LINK_LIBS
+  lldELF
+  lldCommon
+
+  DEPENDS
+  NetBSDOptionsTableGen
+  ${tablegen_deps}
+)

lld/NetBSD/Driver.cpp

+//===- nb.lld.cpp - NetBSD LLD standalone linker --------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// The NetBSD flavor of LLD.
+//
+// This driver wraps the default ELF/GNU lld linker with NetBSD specific
+// customization.
+//
+// This code supports standalone linker usage.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Driver.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+
+using namespace lld;
+using namespace llvm;
+using namespace llvm::sys;
+
+namespace {
+enum ID {
+  OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+#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 infoTable[] = {
+#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
+};
+
+class NetBSDOptTable : public opt::OptTable {
+public:
+  NetBSDOptTable() : OptTable(infoTable) {}
+};
+} // namespace
+
+static Triple targetTriple;
+
+static void setTargetTriple(StringRef argv0, opt::InputArgList &args) {
+  std::string targetError;
+
+  // Firstly, try to get it from program name prefix
+  std::string ProgName = llvm::sys::path::stem(argv0);
+  size_t lastComponent = ProgName.rfind('-');
+  if (lastComponent != std::string::npos) {
+    std::string prefix = ProgName.substr(0, lastComponent);
+    if (llvm::TargetRegistry::lookupTarget(prefix, targetError)) {
+      targetTriple = llvm::Triple(prefix);
+      return;
+    }
+  }
+
+  // Secondly, use the default target triple
+  targetTriple = llvm::Triple(getDefaultTargetTriple());
+}
+
+static void prependTargetCustomization(std::vector<const char *> &args) {
+  // force-disable RO segment due to ld.elf_so limitations
+  args.push_back("--no-rosegment");
+
+  // force-disable superfluous RUNPATH
+  args.push_back("--disable-new-dtags");
+
+  // force-disable superfluous GNU stack
+  args.push_back("-znognustack");
+
+  // set default image base address
+  switch (targetTriple.getArch()) {
+  case llvm::Triple::aarch64:
+  case llvm::Triple::aarch64_be:
+    args.push_back("--image-base=0x200100000");
+    break;
+  default:
+    break;
+  }
+
+  // NetBSD driver relies on the linker knowing the default search paths.
+  // Please keep this in sync with clang/lib/Driver/ToolChains/NetBSD.cpp
+  // (NetBSD::NetBSD constructor)
+  switch (targetTriple.getArch()) {
+  case llvm::Triple::x86:
+    args.push_back("-L=/usr/lib/i386");
+    break;
+  case llvm::Triple::arm:
+  case llvm::Triple::armeb:
+  case llvm::Triple::thumb:
+  case llvm::Triple::thumbeb:
+    switch (targetTriple.getEnvironment()) {
+    case llvm::Triple::EABI:
+    case llvm::Triple::GNUEABI:
+      args.push_back("-L=/usr/lib/eabi");
+      break;
+    case llvm::Triple::EABIHF:
+    case llvm::Triple::GNUEABIHF:
+      args.push_back("-L=/usr/lib/eabihf");
+      break;
+    default:
+      args.push_back("-L=/usr/lib/oabi");
+      break;
+    }
+    break;
+#if 0 // TODO
+  case llvm::Triple::mips64:
+  case llvm::Triple::mips64el:
+    if (tools::mips::hasMipsAbiArg(Args, "o32")) {
+      args.push_back("-L=/usr/lib/o32");
+    } else if (tools::mips::hasMipsAbiArg(Args, "64")) {
+      args.push_back("-L=/usr/lib/64");
+    }
+    break;
+#endif
+  case llvm::Triple::ppc:
+    args.push_back("-L=/usr/lib/powerpc");
+    break;
+  case llvm::Triple::sparc:
+    args.push_back("-L=/usr/lib/sparc");
+    break;
+  default:
+    break;
+  }
+
+  args.push_back("-L=/usr/lib");
+}
+
+// Adapt command line arguments for NetBSD and then call elf::link.
+bool netbsd::link(ArrayRef<const char *> argsArr, bool canExitEarly,
+                  raw_ostream &diag) {
+  bool printTarget = false;
+
+  NetBSDOptTable parser;
+  unsigned MAI;
+  unsigned MAC;
+  opt::InputArgList args = parser.ParseArgs(argsArr.slice(1), MAI, MAC);
+
+  // Append to -v or -version the target information from slld.
+  if (args.hasArg(OPT_v) || args.hasArg(OPT_version))
+    printTarget = true;
+
+  InitializeAllTargets();
+  setTargetTriple(argsArr[0], args);
+
+  if (!targetTriple.isOSNetBSD()) {
+    error("invalid NetBSD target: " + targetTriple.str());
+    return false;
+  }
+
+  // Construct new argv[] that is passed to elf::link().
+  // It will contain NetBSD specific customization.
+  std::vector<const char *> Argv;
+
+  // Pretend that we were executed as the GNU/ELF target.
+  Argv.push_back("ld.lld");
+
+  // Prepend original arguments with the target options.
+  prependTargetCustomization(Argv);
+
+  // Append original arguments, skipping the program name.
+  for (auto I = argsArr.begin() + 1, E = argsArr.end(); I != E; ++I)
+    Argv.push_back(*I);
+
+  if (printTarget)
+    message("Target: " + targetTriple.str());
+
+  return elf::link(Argv, canExitEarly, diag);
+}

lld/NetBSD/Options.td

+include "llvm/Option/OptParser.td"
+
+class F<string name>: Flag<["--", "-"], name>;
+
+def version: F<"version">, HelpText<"Display the version number and exit">;
+def v: Flag<["-"], "v">, HelpText<"Display the version number">;
+def: Flag<["-"], "V">, Alias<version>, HelpText<"Alias for --version">;

lld/include/lld/Common/Driver.h

bool link(llvm::ArrayRef<const char *> args,
           llvm::raw_ostream &diag = llvm::errs());
 }
 
 namespace elf {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &diag = llvm::errs());
 }
 
+namespace netbsd {
+bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
+          llvm::raw_ostream &diag = llvm::errs());
+}
+
 namespace mach_o {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &diag = llvm::errs());
 }
 
 namespace wasm {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
           llvm::raw_ostream &diag = llvm::errs());
 }
 }
 
 #endif

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
+  lldNetBSD
   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)
+  set(LLD_SYMLINKS_TO_CREATE lld-link ld.lld nb.lld ld64.lld wasm-ld)
 endif()
 
 foreach(link ${LLD_SYMLINKS_TO_CREATE})
   add_lld_symlink(${link} lld)
 endforeach()

lld/tools/lld/lld.cpp

 //===- tools/lld/lld.cpp - Linker Driver Dispatcher -----------------------===//
 //
 // 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 the main function of the lld executable. The main
 // function is a thin wrapper which dispatches to the platform specific
 // driver.
 //
-// lld is a single executable that contains four different linkers for ELF,
-// COFF, WebAssembly and Mach-O. The main function dispatches according to
-// argv[0] (i.e. command name). The most common name for each target is shown
+// lld is a single executable that contains five different linkers for ELF,
+// NetBSD, COFF, WebAssembly and Mach-O. The main function dispatches according
+// to argv[0] (i.e. command name). The most common name for each target is shown
 // below:
 //
 //  - ld.lld:    ELF (Unix)
+//  - nb.lld:    ELF (NetBSD)
 //  - ld64:      Mach-O (macOS)
 //  - lld-link:  COFF (Windows)
 //  - ld-wasm:   WebAssembly
 //
 // lld can be invoked as "lld" along with "-flavor" option. This is for
 // backward compatibility and not recommended.
 //
 //===----------------------------------------------------------------------===//

 
 using namespace lld;
 using namespace llvm;
 using namespace llvm::sys;
 
 enum Flavor {
   Invalid,
   Gnu,     // -flavor gnu
+  NetBSD,  // -flavor netbsd
   WinLink, // -flavor link
   Darwin,  // -flavor darwin
   Wasm,    // -flavor wasm
 };
 
 LLVM_ATTRIBUTE_NORETURN static void die(const Twine &s) {
   errs() << s << "\n";
   exit(1);
 }
 
 static Flavor getFlavor(StringRef s) {
   return StringSwitch<Flavor>(s)
       .CasesLower("ld", "ld.lld", "gnu", Gnu)
+      .CasesLower("nb.lld", "netbsd", NetBSD)
       .CasesLower("wasm", "ld-wasm", Wasm)
       .CaseLower("link", WinLink)
       .CasesLower("ld64", "ld64.lld", "darwin", Darwin)
       .Default(Invalid);
 }
 
 static cl::TokenizerCallback getDefaultQuotingStyle() {
   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)

 static Flavor parseProgname(StringRef progname) {
 #if __APPLE__
   // Use Darwin driver for "ld" on Darwin.
   if (progname == "ld")
     return Darwin;
 #endif
 
 #if LLVM_ON_UNIX
-  // Use GNU driver for "ld" on other Unix-like system.
-  if (progname == "ld")
+  // Use GNU or NetBSD driver for "ld" on other Unix-like system.
+  if (progname == "ld") {
+#if defined(__NetBSD__)
+    return NetBSD;
+#else
     return Gnu;
 #endif
+  }
+#endif
 
   // Progname may be something like "lld-gnu". Parse it.
   SmallVector<StringRef, 3> v;
   progname.split(v, "-");
   for (StringRef s : v)
     if (Flavor f = getFlavor(s))
       return f;
   return Invalid;

 // If this function returns true, lld calls _exit() so that it quickly
 // exits without invoking destructors of globally allocated objects.
 //
 // We don't want to do that if we are running tests though, because
 // doing that breaks leak sanitizer. So, lit sets this environment variable,
 // and we use it to detect whether we are running tests or not.
 static bool canExitEarly() { return StringRef(getenv("LLD_IN_TEST")) != "1"; }
 
-/// Universal linker main(). This linker emulates the gnu, darwin, or
+/// Universal linker main(). This linker emulates the gnu, netbsd, darwin, or
 /// windows linker based on the argv[0] or -flavor option.
 int main(int argc, const char **argv) {
   InitLLVM x(argc, argv);
 
   std::vector<const char *> args(argv, argv + argc);
   switch (parseFlavor(args)) {
   case Gnu:
     if (isPETarget(args))
       return !mingw::link(args);
     return !elf::link(args, canExitEarly());
+  case NetBSD:
+    return !netbsd::link(args, canExitEarly());
   case WinLink:
     return !coff::link(args, canExitEarly());
   case Darwin:
     return !mach_o::link(args, canExitEarly());
   case Wasm:
     return !wasm::link(args, canExitEarly());
   default:
     die("lld is a generic driver.\n"
-        "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld"
-        " (WebAssembly) instead");
+        "Invoke ld.lld (Unix), nb.lld (NetBSD), ld64.lld (macOS), lld-link "
+        "(Windows), wasm-ld (WebAssembly) instead");
   }
 }