[lld] [mach-o] Support -l and -syslibroot options

[t.p.northover]

Summary

Hi,

The attached patch implements the -l and -syslibroot options for the
Darwin lld driver. They're in the same patch because testing -l (looks
in /usr/lib and /usr/local/lib) without being able to override the
prefix is rather problematic.

I think the implementation itself is reasonably straightforward (the
one wrinkle is iterating through all arguments now, as opposed to just
OPT_INPUT and OPT_l. Not *strictly* necessary yet, but adding more
filter OPT_nnn arguments to the iterator doesn't scale and we do have
a lot more to support in the end).

The most controversial part is likely to be the testing: it adds
crafted binary MachO inputs, which isn't ideal if they ever need
updating (unlikely, they simply export a single, given symbol). This
isn't exactly unique though, so hopefully won't cause any problems.

OK to commit?

Cheers.

Tim

(Added to Phabricator at Shankar's request)

[shankarke]

include/lld/ReaderWriter/MachOLinkingContext.h

134

should this be setSysRoot ?

lib/Driver/DarwinLdOptions.td

72

I dont see this an option in the ld64 man page, is this fairly new ?

http://www.manpages.info/macosx/ld.1.html

78

nit pick : searchf for -> search for.

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

271

• Can the the system paths be prepended to a set of directories that are being looked up, This could help adding for -L.
• We can possibly search for a library name outside the loop.

300

• • The gnu linker has a way to have the sys root paths be appeneded to the path only if the path starts with an equal to(=) sign, Does MachO also do something like this ? If so this needs to be changed.
• Does not account for -L

[t.p.northover]

Hi Shankar,

Thanks for the comments. I'm not sure I have complete responses to any of them, but I'll have a go...

Cheers.

Tim.

include/lld/ReaderWriter/MachOLinkingContext.h

134

The option is -syslibroot on Darwin. I could see calling the field sysroot anyway, to maintain consistency with ELFLinkingContext. Does lld have any policy on where consistency is preferred?

lib/Driver/DarwinLdOptions.td

72

You'd have to ask someone like Nick for its actual age, but it certainly exists now.

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

271

I started with that system, but specifically moved to this one for two reasons:

+ -syslibroot only applies to the system directories, so I'd need some way of making sure they stay special anyway.
+ Similarly there's a -Z option that removes just these from the search path. This could be handled by dealing with that before any -L or similar, of course.

On the whole, I think the static array is the neatest solution.

300

On the first: I saw that special handling, but I don't believe ld64 has it. The current ld64 man-pages only mention treating "y.o" specially.

On the second: I know. Incremental development and all that. I'd have separated out -syslibroot and -l if I could have reasonably tested one without the other.

[shankarke]

Thanks for the detailed information, Tim. Could you wait if Nick has anything to say here ?

[kledzik]

This sort of testing won't scale up to all the combinations of searching the linker needs to do.

My suggestion is to add a hidden linker option* and change all uses of llvm::sys::fs::exists() to call a new MachOLinkingContext::fileExists(StringRef) method. Normally, fileExists() calls through to llvm::sys::fs::exists(), but if the new option is used, instead it prints out the path and returns false. Now you can write test cases with various combinations of options and then use FileCheck to verify all the correct files and checked for in the right order (for instance -r mode should not look for .dylib files).

• There are various ways expose the option. It could be a command line arg, or an environment variable, or a DEBUG_WITH_TYPE() thing. Each has pros and cons. Also, since this option causes all libraries to fail to be found (so the full search is shown), we may want to have the option also trigger the linker to stop early (setDoNothing()) so the test cases don't have to deal with the errors from "missing" files.

include/lld/ReaderWriter/MachOLinkingContext.h

82–83

"path" is ambiguous is that it can refer to a file or directory. It would clearer to me to have this method as:

ErrorOr<StringRef> searchDirForLibrary(StringRef dir, StringRef libName) const

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

271

Tim , -syslibroot applies to all -L paths - not just the built in ones, or the "system directories".

The algorithm is that if -syslibroot is used, to walk all search paths and if prepending that path with the syslibroot (aka SDK) path results in a directory, than switch that search path to use the SDK one.

You can add the -v option to ld64 and see it print out the final search paths.

275–276

You can avoid the copy-thru-std::string by using:

return fullPath.str().copy(_allocator);

[t.p.northover]

Hi Nick,

[t.p.northover]

Tim , -syslibroot applies to all -L paths - not just the built in ones, or the "system directories".

I don't think it does:

Ah, I see it applies to a basically randomly chosen set of paths. That
we'll almost certainly have to emulate. What fun! I'm rapidly
developing an abiding horror for linkers.

Tim.

[t.p.northover]

Ah, I see it applies to a basically randomly chosen set of paths. That
we'll almost certainly have to emulate. What fun! I'm rapidly
developing an abiding horror for linkers.

That actual algorithm seems to be closer to:

1. Add -L options to the search path (if it exists and is a directory).
2. Record -syslibroot paths for later.
3. Unless the last one is "/". Then discard the lot, because logic is for wimps.
4. Try the cartesian product of syslibroots and *absolute* library

paths. Add ones that exist to the search path.

5. If not, add the original unless there's just one syslibroot and

it's a default path. Then skip it.

6. Do all the above in a particular order.

I'll fix the patch to do something similar, if I don't lose the will
to live first.

Cheers.

Tim.

[t.p.northover]

I think this new version emulates the ld64 behaviour, certainly with much greater fidelity than before:

• multiple -syslibroot options are accepted.
• They apply to absolute paths (not visible yet because no -L).
• Various quirks around single or special -syslibroot args.

I've also added a variant of the testing mode Nick suggested (in addition to the actual linking test), with a couple of modifications.

• I decided that printing each queried path as it happened was too algorithm-dependent, when what we're really interested in is the outcome, so the actual behaviour is closer to ld64's "-v" option and prints out the final search paths.
• I also decided that all pathExists calls failing was too inflexible and wouldn't allow us to actually test the algorithm's behaviour in most cases, so I also added a -path_exists override.

There's still no -L support, that'll be coming later (though it should be fairly simple). I think I've addressed the other comments though.

So how does this version look?

Cheers.

Tim.

[t.p.northover]

test/mach-o/libresolve-syslibroot.yaml

1

Just noticed this file is a duplicate of libresolve-simple.yaml. I've removed it from my branch.

[kledzik]

I'd change SmallString<128> to SmallString<256> because most sdk usages are buried inside Xcode.app and start at 120 chars.

Otherwise, LGTM

lib/Driver/DarwinLdOptions.td

72–73

A better help message would be "path to SDK"

78

HelpText<"Base name of library searched for in -L directories">;

[t.p.northover]

Thanks Nick. I've committed it with the changes you suggested in r212706. (Sorry about missing the typo again too. It *is* fixed by your new suggested wording in the commit).

Cheers.

Tim.

include/lld/ReaderWriter/MachOLinkingContext.h

 
 #include "lld/Core/LinkingContext.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Writer.h"
 
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachO.h"
 
+#include <set>
+
 using llvm::MachO::HeaderFileType;
 
 namespace lld {
 
 namespace mach_o {
 class KindHandler; // defined in lib. this header is in include.
 }
 
public:
 
   Arch arch() const { return _arch; }
   StringRef archName() const { return nameFromArch(_arch); }
   OS os() const { return _os; }
 
   bool minOS(StringRef mac, StringRef iOS) const;
   void setDoNothing(bool value) { _doNothing = value; }
   bool doNothing() const { return _doNothing; }
   bool printAtoms() const { return _printAtoms; }
+  bool testingLibResolution() const { return _testingLibResolution; }
+  const StringRefVector &searchDirs() const { return _searchDirs; }
+
+  /// \brief Checks whether a given path on the filesystem exists.
+  ///
+  /// When running in -test_libresolution mode, this method consults an
+  /// internally maintained list of files that exist (provided by -path_exists)
+  /// instead of the actual filesystem.
+  bool pathExists(StringRef path) const;
+
+  /// \brief Adds any library search paths derived from the given base, possibly
+  /// modified by -syslibroots.
+  ///
+  /// The set of paths added consists of approximately all syslibroot-prepended
+  /// versions of libPath that exist, or the original libPath if there are none
+  /// for whatever reason. With various edge-cases for compatibility.
+  void addModifiedSearchDir(StringRef libPath,
+                            const StringRefVector &syslibRoots,
+                            bool isSystemPath = false);
+
+  /// \brief Determine whether -lFoo can be resolve within the given path, and
+  /// return the filename if so.
+  ///
+  /// The -lFoo option is documented to search for libFoo.dylib and libFoo.a in
+  /// that order, unless Foo ends in ".o", in which case only the exact file
+  /// matches (e.g. -lfoo.o would only find foo.o).
+  ErrorOr<StringRef> searchDirForLibrary(StringRef path,
+                                         StringRef libName) const;
+
+  /// \brief Iterates through all search path entries lookinf for libName (as
+  /// specified by -lFoo).
+  ErrorOr<StringRef> searchLibrary(StringRef libName) const;
 
   /// \brief The dylib's binary compatibility version, in the raw uint32 format.
   ///
   /// When building a dynamic library, this is the compatibility version that
   /// gets embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command. At
   /// runtime, the loader will verify that the binary is compatible with the
   /// installed dynamic library.
   uint32_t compatibilityVersion() const { return _compatibilityVersion; }
 
   /// \brief The dylib's current version, in the the raw uint32 format.
   ///
   /// When building a dynamic library, this is the current version that gets
   /// embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command.
   uint32_t currentVersion() const { return _currentVersion; }
 
   /// \brief The dylib's install name.
   ///
   /// Binaries that link against the dylib will embed this path into the dylib
   /// load command. When loading the binaries at runtime, this is the location
   /// on disk that the loader will look for the dylib.
   StringRef installName() const { return _installName; }
 
   /// \brief Whether or not the dylib has side effects during initialization.
   ///
   /// Dylibs marked as being dead strippable provide the guarantee that loading
   /// the dylib has no side effects, allowing the linker to strip out the dylib
public:
   void setCompatibilityVersion(uint32_t vers) { _compatibilityVersion = vers; }
   void setCurrentVersion(uint32_t vers) { _currentVersion = vers; }
   void setInstallName(StringRef name) { _installName = name; }
   void setDeadStrippableDylib(bool deadStrippable) {
     _deadStrippableDylib = deadStrippable;
   }
   void setBundleLoader(StringRef loader) { _bundleLoader = loader; }
   void setPrintAtoms(bool value=true) { _printAtoms = value; }
+  void setTestingLibResolution(bool value = true) {
+    _testingLibResolution = value;
+  }
+  void addExistingPathForDebug(StringRef path) {
+    _existingPaths.insert(path);
+  }
+
   StringRef dyldPath() const { return "/usr/lib/dyld"; }
 
   static Arch archFromCpuType(uint32_t cputype, uint32_t cpusubtype);
   static Arch archFromName(StringRef archName);
   static StringRef nameFromArch(Arch arch);
   static uint32_t cpuTypeFromArch(Arch arch);
   static uint32_t cpuSubtypeFromArch(Arch arch);
   static bool is64Bit(Arch arch);
struct ArchInfo {
     MachOLinkingContext::Arch arch;
     bool                      littleEndian;
     uint32_t                  cputype;
     uint32_t                  cpusubtype;
   };
 
   static ArchInfo _s_archInfos[];
 
+  std::set<StringRef> _existingPaths; // For testing only.
+  StringRefVector _searchDirs;
   HeaderFileType _outputMachOType;   // e.g MH_EXECUTE
   bool _outputMachOTypeStatic; // Disambiguate static vs dynamic prog
   bool _doNothing;            // for -help and -v which just print info
   Arch _arch;
   OS _os;
   uint32_t _osMinVersion;
   uint64_t _pageZeroSize;
   uint64_t _pageSize;
   uint32_t _compatibilityVersion;
   uint32_t _currentVersion;
   StringRef _installName;
   bool _deadStrippableDylib;
   bool _printAtoms;
+  bool _testingLibResolution;
   StringRef _bundleLoader;
   mutable std::unique_ptr<mach_o::KindHandler> _kindHandler;
   mutable std::unique_ptr<Writer> _writer;
 };
 
 } // end namespace lld
 
 #endif

lib/Driver/DarwinLdDriver.cpp

for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_mllvm),
                                it != ie; ++it) {
     ctx.appendLLVMOption((*it)->getValue());
   }
 
   // Handle -print_atoms a
   if (parsedArgs->getLastArg(OPT_print_atoms))
     ctx.setPrintAtoms();
 
+  // In -test_libresolution mode, we'll be given an explicit list of paths that
+  // exist. We'll also be expected to print out information about how we located
+  // libraries and so on that the user specified, but not to actually do any
+  // linking.
+  if (parsedArgs->getLastArg(OPT_test_libresolution)) {
+    ctx.setTestingLibResolution();
+
+    // With paths existing by fiat, linking is not going to end well.
+    ctx.setDoNothing(true);
+
+    // Only bother looking for an existence override if we're going to use it.
+    for (llvm::opt::arg_iterator
+             it = parsedArgs->filtered_begin(OPT_path_exists),
+             ie = parsedArgs->filtered_end();
+         it != ie; ++it) {
+      ctx.addExistingPathForDebug((*it)->getValue());
+    }
+  }
+
   std::unique_ptr<InputGraph> inputGraph(new InputGraph());
 
-  // Handle input files
-  for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_INPUT),
+  // Now construct the set of library search directories, following ld64's
+  // baroque set of accumulated hacks. Mostly, the algorithm constructs
+  //     { syslibroots } x { libpaths }
+  //
+  // Unfortunately, there are numerous exceptions:
+  //   1. Only absolute paths get modified by syslibroot options.
+  //   2. If there is just 1 -syslibroot, system paths not found in it are
+  //      skipped.
+  //   3. If the last -syslibroot is "/", all of them are ignored entirely.
+  //   4. If { syslibroots } x path ==  {}, the original path is kept.
+  std::vector<StringRef> syslibRoots;
+  for (llvm::opt::arg_iterator it = parsedArgs->filtered_begin(OPT_syslibroot),
                                ie = parsedArgs->filtered_end();
                                it != ie; ++it) {
+    syslibRoots.push_back((*it)->getValue());
+  }
+
+  // FIXME: handle -L options: these get added *before* the default paths,
+  // possibly modified by any syslibroot options.
+  ctx.addModifiedSearchDir("/usr/lib", syslibRoots, true);
+  ctx.addModifiedSearchDir("/usr/local/lib", syslibRoots, true);
+
+  // Now that we've constructed the final set of search paths, print out what
+  // we'll be using for testing purposes.
+  if (ctx.testingLibResolution()) {
+    diagnostics << "Library search paths:\n";
+    for (auto path : ctx.searchDirs()) {
+      diagnostics << "    " << path << '\n';
+    }
+  }
+
+  // Handle input files
+  for (auto &arg : *parsedArgs) {
+    StringRef inputPath;
+    switch (arg->getOption().getID()) {
+    default:
+      continue;
+    case OPT_INPUT:
+      inputPath = arg->getValue();
+      break;
+    case OPT_l: {
+      ErrorOr<StringRef> resolvedPath = ctx.searchLibrary(arg->getValue());
+      if (!resolvedPath) {
+        diagnostics << "Unable to find library -l" << arg->getValue() << "\n";
+        return false;
+      } else if (ctx.testingLibResolution()) {
+        diagnostics << "Found library " << resolvedPath.get() << '\n';
+      }
+      inputPath = resolvedPath.get();
+      break;
+    }
+    }
     inputGraph->addInputElement(std::unique_ptr<InputElement>(
-        new MachOFileNode(ctx, (*it)->getValue(), globalWholeArchive)));
+        new MachOFileNode(ctx, inputPath, globalWholeArchive)));
   }
 
   if (!inputGraph->size()) {
     diagnostics << "No input files\n";
     return false;
   }
 
   ctx.setInputGraph(std::move(inputGraph));
 
   // Validate the combination of options used.
   return ctx.validate(diagnostics);
 }
 
 } // namespace lld

lib/Driver/DarwinLdOptions.td

 
 // library options
 def grp_libs : OptionGroup<"libs">, HelpText<"LIBRARY OPTIONS">;
 def L : Joined<["-"], "L">,
         HelpText<"Add directory to library search path">, Group<grp_libs>;
 def all_load : Flag<["-"], "all_load">,
         HelpText<"Forces all members of all static libraries to be loaded">,
         Group<grp_libs>;
+def syslibroot : Separate<["-"], "syslibroot">,
+        HelpText<"Add prefix to all system library search paths">,
+        Group<grp_libs>;
+
+// Input options
+def l : Joined<["-"], "l">,
+        HelpText<"Root name of library to searchf for">;
 
 // test case options
-def print_atoms : Flag<["-"], "print_atoms">, 
+def print_atoms : Flag<["-"], "print_atoms">,
         HelpText<"Emit output as yaml atoms">;
+def test_libresolution : Flag<["-"], "test_libresolution">,
+        HelpText<"Only files specified by -file_exists are considered to exist."
+                 " Print debugging information during resolution">;
+def path_exists : Separate<["-"], "path_exists">,
+        HelpText<"When used with -test_libresolution, only these paths exist">;
+
 
 // general options
 def output : Separate<["-"], "o">, HelpText<"Output file path">;
 def arch : Separate<["-"], "arch">, HelpText<"Architecture to link">;
 
 // extras
 def help : Flag<["-"], "help">;

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 #include "lld/Core/PassManager.h"
 #include "lld/ReaderWriter/Reader.h"
 #include "lld/ReaderWriter/Writer.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MachO.h"
+#include "llvm/Support/Path.h"
 
 using lld::mach_o::KindHandler;
 using namespace llvm::MachO;
 
 namespace lld {
 
 bool MachOLinkingContext::parsePackedVersion(StringRef str, uint32_t &result) {
   result = 0;
uint32_t MachOLinkingContext::cpuSubtypeFromArch(Arch arch) {
   llvm_unreachable("Unknown arch type");
 }
 
 MachOLinkingContext::MachOLinkingContext()
     : _outputMachOType(MH_EXECUTE), _outputMachOTypeStatic(false),
       _doNothing(false), _arch(arch_unknown), _os(OS::macOSX), _osMinVersion(0),
       _pageZeroSize(0), _pageSize(4096), _compatibilityVersion(0),
       _currentVersion(0), _deadStrippableDylib(false), _printAtoms(false),
-      _kindHandler(nullptr) {}
+      _testingLibResolution(false), _kindHandler(nullptr) {}
 
 MachOLinkingContext::~MachOLinkingContext() {}
 
 void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os,
                                     uint32_t minOSVersion) {
   _outputMachOType = type;
   _arch = arch;
   _os = os;
bool MachOLinkingContext::addUnixThreadLoadCommand() const {
   case MH_DYLINKER:
   case MH_PRELOAD:
     return true;
   default:
     return false;
   }
 }
 
+bool MachOLinkingContext::pathExists(StringRef path) const {
+  if (!testingLibResolution())
+    return llvm::sys::fs::exists(path.str());
+
+  // Otherwise, we're in test mode: only files explicitly provided on the
+  // command-line exist.
+  return _existingPaths.find(path) != _existingPaths.end();
+}
+
+void MachOLinkingContext::addModifiedSearchDir(
+    StringRef libPath, const StringRefVector &syslibRoots, bool isSystemPath) {
+  bool addedModifiedPath = false;
+
+  // Two cases to consider here:
+  //   + If the last -syslibroot is "/", all of them are ignored (don't ask).
+  //   + -syslibroot only applies to absolute paths.
+  if (!syslibRoots.empty() && syslibRoots.back() != "/" &&
+      llvm::sys::path::is_absolute(libPath)) {
+    for (auto syslibRoot : syslibRoots) {
+      SmallString<128> path(syslibRoot);
+      llvm::sys::path::append(path, libPath);
+      if (pathExists(path)) {
+        _searchDirs.push_back(path.str().copy(_allocator));
+        addedModifiedPath = true;
+      }
+    }
+  }
+
+  if (addedModifiedPath)
+    return;
+
+  // Finally, if only one -syslibroot is given, system paths which aren't in it
+  // get suppressed.
+  if (syslibRoots.size() != 1 || !isSystemPath) {
+    if (pathExists(libPath)) {
+      _searchDirs.push_back(libPath);
+    }
+  }
+}
+
+ErrorOr<StringRef>
+MachOLinkingContext::searchDirForLibrary(StringRef path,
+                                         StringRef libName) const {
+  SmallString<128> fullPath;
+  if (libName.endswith(".o")) {
+    // A request ending in .o is special: just search for the file directly.
+    fullPath.assign(path);
+    llvm::sys::path::append(fullPath, libName);
+    if (pathExists(fullPath))
+      return fullPath.str().copy(_allocator);
+    return make_error_code(llvm::errc::no_such_file_or_directory);
+  }
+
+  // Search for dynamic library
+  fullPath.assign(path);
+  llvm::sys::path::append(fullPath, Twine("lib") + libName + ".dylib");
+  if (pathExists(fullPath))
+    return fullPath.str().copy(_allocator);
+
+  // If not, try for a static library
+  fullPath.assign(path);
+  llvm::sys::path::append(fullPath, Twine("lib") + libName + ".a");
+  if (pathExists(fullPath))
+    return fullPath.str().copy(_allocator);
+
+  return make_error_code(llvm::errc::no_such_file_or_directory);
+}
+
+
+
+ErrorOr<StringRef> MachOLinkingContext::searchLibrary(StringRef libName) const {
+  SmallString<128> path;
+  for (StringRef dir : searchDirs()) {
+    ErrorOr<StringRef> ec = searchDirForLibrary(dir, libName);
+    if (ec)
+      return ec;
+  }
+
+  return make_error_code(llvm::errc::no_such_file_or_directory);
+}
+
 bool MachOLinkingContext::validateImpl(raw_ostream &diagnostics) {
   // TODO: if -arch not specified, look at arch of first .o file.
 
   if (_currentVersion && _outputMachOType != MH_DYLIB) {
     diagnostics << "error: -current_version can only be used with dylibs\n";
     return false;
   }
 

test/mach-o/lib-search-paths.yaml

+# RUN: lld -flavor darwin -arch x86_64 %s -syslibroot %p/Inputs/lib-search-paths -lmyshared -lmystatic -lfile.o -print_atoms 2>&1 -r | FileCheck %s
+
+--- !native
+undefined-atoms:
+    - name: _from_myshared
+    - name: _from_mystatic
+    - name: _from_fileo
+
+# CHECK: defined-atoms:
+# CHECK:   - name:            _from_mystatic
+# CHECK:     content:         [ 02, 00, 00, 00 ]
+# CHECK:   - name:            _from_fileo
+# CHECK:     content:         [ 2A, 00, 00, 00 ]
+# CHECK: shared-library-atoms:
+# CHECK:   - name:            _from_myshared
+# CHECK:     load-name:       libmyshared.dylib

test/mach-o/libresolve-bizarre-root-override.yaml

+# RUN: not lld -flavor darwin -test_libresolution \
+# RUN:        -path_exists /usr/lib \
+# RUN:        -path_exists /Applications/MySDK/usr/local/lib \
+# RUN:        -path_exists /Applications/MySDK/usr/lib \
+# RUN:        -path_exists /Applications/MySDK/usr/lib/libSystem.dylib \
+# RUN:        -syslibroot /Applications/MySDK \
+# RUN:        -syslibroot / \
+# RUN:        -lSystem \
+# RUN: 2>&1 | FileCheck %s
+
+# When the last -syslibroot is simply "/", all of them get discarded. So in this
+# case, only /usr/lib should show up.
+
+# CHECK: Library search paths:
+# CHECK:     /usr/lib
+# CHECK-NOT:     /usr/local/lib
+# CHECK: Unable to find library -lSystem

test/mach-o/libresolve-multiple-syslibroots.yaml

+# RUN: lld -flavor darwin -test_libresolution \
+# RUN:        -path_exists /usr/lib \
+# RUN:        -path_exists /Applications/MyFirstSDK/usr/local/lib \
+# RUN:        -path_exists /Applications/MySecondSDK/usr/local/lib \
+# RUN:        -path_exists /Applications/MyFirstSDK/usr/local/lib/libSystem.a \
+# RUN:        -path_exists /Applications/MySecondSDK/usr/local/lib/libSystem.a \
+# RUN:        -syslibroot /Applications/MyFirstSDK \
+# RUN:        -syslibroot /Applications/MySecondSDK \
+# RUN:        -lSystem \
+# RUN: 2>&1 | FileCheck %s
+
+
+# CHECK: Library search paths:
+# CHECK:     /usr/lib
+# CHECK:     /Applications/MyFirstSDK/usr/local/lib
+# CHECK:     /Applications/MySecondSDK/usr/local/lib
+# CHECK: Found library /Applications/MyFirstSDK/usr/local/lib/libSystem.a

test/mach-o/libresolve-one-syslibroot.yaml

+# RUN: lld -flavor darwin -test_libresolution \
+# RUN:        -path_exists /usr/lib \
+# RUN:        -path_exists /Applications/MySDK/usr/local/lib \
+# RUN:        -path_exists /Applications/MySDK/usr/local/lib/libSystem.a \
+# RUN:        -syslibroot /Applications/MySDK \
+# RUN:        -lSystem \
+# RUN: 2>&1 | FileCheck %s
+
+# When just one -syslibroot is specified, we apparently want to skip *system*
+# paths that aren't found. User ones should still get added. In this case
+# /usr/lib exists, but not the equivalent in the -syslibroot, so there should be
+# no mention of /usr/lib.
+
+# CHECK: Library search paths:
+# CHECK-NOT:     /usr/lib
+# CHECK-NOT:     /usr/local/lib
+# CHECK:     /Applications/MySDK/usr/local/lib
+# CHECK-NOT:     /usr/local/lib
+# CHECK: Found library /Applications/MySDK/usr/local/lib/libSystem.a

test/mach-o/libresolve-simple.yaml

+# RUN: lld -flavor darwin -arch x86_64 -r -test_libresolution \
+# RUN:        -path_exists /usr/lib \
+# RUN:        -path_exists /usr/local/lib \
+# RUN:        -path_exists /usr/lib/libSystem.dylib \
+# RUN:        -lSystem \
+# RUN: 2>&1 | FileCheck %s
+
+# CHECK: Library search paths:
+# CHECK:     /usr/lib
+# CHECK:     /usr/local/lib
+# CHECK: Found library /usr/lib/libSystem.dylib

test/mach-o/libresolve-syslibroot.yaml

+# RUN: lld -flavor darwin -arch x86_64 -r -test_libresolution \
+# RUN:        -path_exists /usr/lib \
+# RUN:        -path_exists /usr/local/lib \
+# RUN:        -path_exists /usr/lib/libSystem.dylib \
+# RUN:        -lSystem \
+# RUN: 2>&1 | FileCheck %s
+
+# CHECK: Library search paths:
+# CHECK:     /usr/lib
+# CHECK:     /usr/local/lib
+# CHECK: Found library /usr/lib/libSystem.dylib