[lld/mac] Implement support for searching dylibs with @rpath/ in install name

[thakis]

Summary

Also adjust a few comments, and move the DylibFile comment talking about
umbrella next to the parameter again.

[thakis]

rebase

[int3]

lgtm

lld/MachO/DriverUtils.cpp

if (magic == file_magic::tapi_file) {
     if (!result) {
       error("could not load TAPI file at " + mbref.getBufferIdentifier() +
             ": " + toString(result.takeError()));
       return nullptr;
     }
     file = make<DylibFile>(**result, umbrella, isBundleLoader);
 
     // parseReexports() can recursively call loadDylib(). That's fine since
-    // we wrote DylibFile we just loaded to the loadDylib cache via the `file`
-    // reference. But the recursive load can grow loadDylibs, so the `file`
-    // reference might become invalid after parseReexports() -- so copy the
-    // pointer it refers to before going on.
+    // we wrote the DylibFile we just loaded to the loadDylib cache via the
+    // `file` reference. But the recursive load can grow loadDylibs, so the
+    // `file` reference might become invalid after parseReexports() -- so copy
+    // the pointer it refers to before continuing.
     newFile = file;
     if (newFile->exportingFile)
       newFile->parseReexports(**result);
   } else {
     assert(magic == file_magic::macho_dynamically_linked_shared_lib ||
            magic == file_magic::macho_dynamically_linked_shared_lib_stub ||
            magic == file_magic::macho_executable ||
            magic == file_magic::macho_bundle);

lld/MachO/InputFiles.h

 
 // command-line -sectcreate file
 class OpaqueFile : public InputFile {
 public:
   OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
-// .dylib file
+// .dylib or .tbd file
 class DylibFile : public InputFile {
 public:
-  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
-                     bool isBundleLoader = false);
-
-  explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
-                     DylibFile *umbrella = nullptr,
-                     bool isBundleLoader = false);
-
   // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
   // symbols in those sub-libraries will be available under the umbrella
   // library's namespace. Those sub-libraries can also have their own
   // re-exports. When loading a re-exported dylib, `umbrella` should be set to
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded
   // (through an -lfoo flag), then `umbrella` should be a nullptr.
+  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
+                     bool isBundleLoader = false);
+  explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
+                     DylibFile *umbrella = nullptr,
+                     bool isBundleLoader = false);
+
   void parseLoadCommands(MemoryBufferRef mb);
   void parseReexports(const llvm::MachO::InterfaceFile &interface);
 
   static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
 
   StringRef installName;
   DylibFile *exportingFile = nullptr;
   DylibFile *umbrella;
+  SmallVector<StringRef, 2> rpaths;
   uint32_t compatibilityVersion = 0;
   uint32_t currentVersion = 0;
   int64_t ordinal = 0; // Ordinal numbering starts from 1, so 0 is a sentinel
   RefState refState;
   bool reexport = false;
   bool forceNeeded = false;
   bool forceWeakImport = false;
   bool deadStrippable = false;

lld/MachO/InputFiles.cpp

 static DylibFile *findDylib(StringRef path, DylibFile *umbrella,
                             const InterfaceFile *currentTopLevelTapi) {
   if (path::is_absolute(path, path::Style::posix))
     for (StringRef root : config->systemLibraryRoots)
       if (Optional<std::string> dylibPath =
               resolveDylibPath((root + path).str()))
         return loadDylib(*dylibPath, umbrella);
 
-  // TODO: Expand @rpath, handle -dylib_file
+  // TODO: Handle -dylib_file
   SmallString<128> newPath;
   if (config->outputType == MH_EXECUTE &&
       path.consume_front("@executable_path/")) {
     // ld64 allows overriding this with the undocumented flag -executable_path.
     // lld doesn't currently implement that flag.
     path::append(newPath, sys::path::parent_path(config->outputFile), path);
     path = newPath;
   } else if (path.consume_front("@loader_path/")) {
     path::append(newPath, sys::path::parent_path(umbrella->getName()), path);
     path = newPath;
+  } else if (path.startswith("@rpath/")) {
+    // `man dyld` says @rpath keeps a stack of active rpaths at dynamic
+    // link time, but ld64 only looks at the loading library's rpaths at
+    // static link time. Match ld64.
+    for (StringRef rpath : umbrella->rpaths) {
+      newPath.clear();
+      if (rpath.consume_front("@loader_path/"))
+        path::append(newPath, sys::path::parent_path(umbrella->getName()));
+      path::append(newPath, rpath, path.drop_front(strlen("@rpath/")));
+      if (Optional<std::string> dylibPath = resolveDylibPath(newPath))
+        return loadDylib(*dylibPath, umbrella);
+    }
   }
 
   if (currentTopLevelTapi) {
     for (InterfaceFile &child :
          make_pointee_range(currentTopLevelTapi->documents())) {
       assert(child.documents().empty());
       if (path == child.getInstallName()) {
         auto file = make<DylibFile>(child, umbrella);
DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
   if (config->printEachFile)
     message(toString(this));
 
   deadStrippable = hdr->flags & MH_DEAD_STRIPPABLE_DYLIB;
 
   if (!checkCompatibility(this))
     return;
 
+  for (auto *cmd : findCommands<rpath_command>(hdr, LC_RPATH)) {
+    StringRef rpath{reinterpret_cast<const char *>(cmd) + cmd->path};
+    rpaths.push_back(rpath);
+  }
+
   // Initialize symbols.
   exportingFile = isImplicitlyLinked(installName) ? this : this->umbrella;
   if (const load_command *cmd = findCommand(hdr, LC_DYLD_INFO_ONLY)) {
     auto *c = reinterpret_cast<const dyld_info_command *>(cmd);
     parseTrie(buf + c->export_off, c->export_size,
               [&](const Twine &name, uint64_t flags) {
                 StringRef savedName = saver.save(name);
                 if (handleLDSymbol(savedName))

lld/test/MachO/link-search-at-rpath.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t; split-file %s %t
+# RUN: mkdir %t/subdir
+# RUN: mkdir %t/subdir2
+
+# RUN: llvm-mc -filetype obj -triple x86_64-apple-darwin %t/foo.s -o %t/foo.o
+# RUN: llvm-mc -filetype obj -triple x86_64-apple-darwin %t/bar.s -o %t/bar.o
+# RUN: llvm-mc -filetype obj -triple x86_64-apple-darwin %t/main.s -o %t/main.o
+
+# RUN: %lld -dylib -install_name @rpath/libfoo.dylib %t/foo.o -o %t/subdir/libfoo.dylib
+
+# RUN: %lld -dylib -reexport_library %t/subdir/libfoo.dylib \
+# RUN:     -rpath @loader_path/../foo \
+# RUN:     -rpath @loader_path/../subdir \
+# RUN:     -rpath @loader_path/../foo \
+# RUN:     %t/bar.o -o %t/subdir2/libbar.dylib
+
+# RUN: %lld -lSystem %t/main.o %t/subdir2/libbar.dylib -o %t/test
+# RUN: %lld -dylib -lSystem %t/main.o %t/subdir2/libbar.dylib -o %t/libtest.dylib
+
+#--- foo.s
+.globl _foo
+_foo:
+  retq
+
+#--- bar.s
+.globl _bar
+_bar:
+  retq
+
+#--- main.s
+.section __TEXT,__text
+.global _main
+_main:
+  callq _foo
+  callq _bar
+  ret

lld/test/MachO/rpath.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: %lld -o %t %t.o
 
 ## Check that -rpath generates LC_RPATH.
-# RUN: %lld -o %t %t.o -rpath /some/rpath
+# RUN: %lld -o %t %t.o -rpath /some/rpath -rpath /another/rpath
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s
 # CHECK:      LC_RPATH
 # CHECK-NEXT: cmdsize 24
 # CHECK-NEXT: path /some/rpath
+# CHECK:      LC_RPATH
+# CHECK-NEXT: cmdsize 32
+# CHECK-NEXT: path /another/rpath
 
 .text
 .global _main
 _main:
   mov $0, %rax
   ret