[lld-macho] Support -rpath

[int3]

Summary

Pretty straightforward; just emits LC_RPATH for dyld to consume.

Note that lld itself does not yet support dylib lookup via @rpath.

[compnerd]

LGTM with the renaming of the local variable. Thanks for implementing this (it was the next item I wanted to add)!

lld/MachO/Config.h

44

I don't think that rPaths is correct ... rpaths would be correct here, or runtimePaths.

lld/MachO/Writer.cpp

268

I wish we could use strlcpy.

[int3]

runtimePaths

lld/MachO/Config.h

struct Configuration {
   uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::MachO::Architecture arch;
   PlatformInfo platform;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> librarySearchPaths;
   std::vector<llvm::StringRef> frameworkSearchPaths;
+  std::vector<llvm::StringRef> runtimePaths;
   llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
 };
 
 // The symbol with the highest priority should be ordered first in the output
 // section (modulo input section contiguity constraints). Using priority
 // (highest first) instead of order (lowest first) has the convenient property
 // that the default-constructed zero priority -- for symbols/sections without a
 // user-defined order -- naturally ends up putting them at the end of the

lld/MachO/Driver.cpp

bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
   config->outputType = args.hasArg(OPT_dylib) ? MH_DYLIB : MH_EXECUTE;
+  config->runtimePaths = args::getStrings(args, OPT_rpath);
 
   std::vector<StringRef> roots;
   for (const Arg *arg : args.filtered(OPT_syslibroot))
     roots.push_back(arg->getValue());
   // NOTE: the final `-syslibroot` being `/` will ignore all roots
   if (roots.size() && roots.back() == "/")
     roots.clear();
   // NOTE: roots can never be empty - add an empty root to simplify the library
case OPT_platform_version:
       break;
     case OPT_o:
     case OPT_dylib:
     case OPT_e:
     case OPT_F:
     case OPT_L:
     case OPT_headerpad:
     case OPT_install_name:
+    case OPT_rpath:
+    case OPT_sub_library:
     case OPT_Z:
     case OPT_arch:
     case OPT_syslibroot:
     case OPT_sectcreate:
       // handled elsewhere
       break;
     default:
       warnIfUnimplementedOption(opt);

lld/MachO/Options.td

 def undefined : Separate<["-"], "undefined">,
      MetaVarName<"<treatment>">,
      HelpText<"Handle undefined symbols according to <treatment>: error, warning, suppress, or dynamic_lookup (default is error)">,
      Flags<[HelpHidden]>,
      Group<grp_resolve>;
 def rpath : Separate<["-"], "rpath">,
      MetaVarName<"<path>">,
      HelpText<"Add <path> to dyld search list for dylibs with load path prefix `@rpath/'">,
-     Flags<[HelpHidden]>,
      Group<grp_resolve>;
 def commons : Separate<["-"], "commons">,
      MetaVarName<"<treatment>">,
      HelpText<"Resolve tentative definitions in dylibs according to <treatment>: ignore_dylibs, use_dylibs, error (default is ignore_dylibs)">,
      Flags<[HelpHidden]>,
      Group<grp_resolve>;
 
 def grp_introspect : OptionGroup<"introspect">, HelpText<"INTROSPECTING THE LINKER">;

lld/MachO/Writer.cpp

void writeTo(uint8_t *buf) const override {
     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";
 };
+
+class LCRPath : public LoadCommand {
+public:
+  LCRPath(StringRef path) : path(path) {}
+
+  uint32_t getSize() const override {
+    return alignTo(sizeof(rpath_command) + path.size() + 1, WordSize);
+  }
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<rpath_command *>(buf);
+    buf += sizeof(rpath_command);
+
+    c->cmd = LC_RPATH;
+    c->cmdsize = getSize();
+    c->path = sizeof(rpath_command);
+
+    memcpy(buf, path.data(), path.size());
+    buf[path.size()] = '\0';
+  }
+
+private:
+  StringRef path;
+};
 } // namespace
 
 void Writer::scanRelocations() {
   for (InputSection *isec : inputSections) {
     for (Reloc &r : isec->relocs) {
       if (auto *s = r.target.dyn_cast<lld::macho::Symbol *>()) {
         if (isa<Undefined>(s))
           error("undefined symbol " + s->getName() + ", referenced from " +
                 sys::path::filename(isec->file->getName()));
         else
           target->prepareSymbolRelocation(*s, isec, r);
       }
     }
   }
 }
 
 void Writer::createLoadCommands() {
   in.header->addLoadCommand(
       make<LCDyldInfo>(in.binding, lazyBindingSection, exportSection));
   in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
   in.header->addLoadCommand(make<LCDysymtab>());
+  for (StringRef path : config->runtimePaths)
+    in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
     in.header->addLoadCommand(make<LCMain>());
     in.header->addLoadCommand(make<LCLoadDylinker>());
     break;
   case MH_DYLIB:
     in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName));

lld/test/MachO/rpath.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
+
+## Check that -rpath generates LC_RPATH.
+# RUN: lld -flavor darwinnew -o %t %t.o -rpath /some/rpath
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s
+# CHECK:      LC_RPATH
+# CHECK-NEXT: cmdsize 24
+# CHECK-NEXT: path /some/rpath
+
+.text
+.global _main
+_main:
+  mov $0, %rax
+  ret