[ELF] Don't consider directories of the same name as libraries

[phosek]

Summary

When processing linker scripts or dependent libraries, if there's a
directory of the same name as the library being searched for, either in
the current directory or earlier in the search order, LLD will try to
open it and report an error. This is because LLD currently uses file
existence check. While we could expand this check and verify that the
file type is not a directory, such a check could be susceptible to
races. Rather, we always try to open the file, but silently ignore the
error and continue with other cases.

[phosek]

I'm not yet sure if this is the best solution, but it's one possible solution to an issue we recently discovered.

[mcgrathr]

lgtm

lld/test/ELF/deplibs-dir.s

14

Another good thing to test here is -L%t.dir/notdir/foo when %t.dir/notdir exists as a regular file. With the old bug this will get "Not a directory" (ENOTDIR, which should also be treated the same as ENOENT).

Ideally, I think we'd also test that a regular file that cannot be opened fails as expected rather than being skipped. That would need two matching files in the search path to be sure it doesn't go on and open the file that works. e.g., make the first match in the path be a file without read permissions. It might be hard to reproduce an existing but unopenable file across all operating systems.

18

Matching the exact perror text might not be reliable across operating systems, but for a negative match that might be tolerable. Also of potential concern is if messages could ever get translated vs running under LC_ALL=C.

[MaskRay]

ignoreError can renamed to something like skipDirectory.

Can you check whether the error_code is an EISDIR?

[MaskRay]

The code move to Driver.h feels a bit uneasy, hope someone may suggest whether there is a better way.

@arichardson @bd1976llvm @ikudrin

The functionality looks good and I am happy to LG if we can't think of a better way.

lld/ELF/Driver.h

97

This change should be made separately.

107

return func(name) || findFromSearchPaths(name, func);

[phosek]

In D117933#3263111, @MaskRay wrote:

The code move to Driver.h feels a bit uneasy, hope someone may suggest whether there is a better way.

@arichardson @bd1976llvm @ikudrin

The functionality looks good and I am happy to LG if we can't think of a better way.

I also considered keeping the functions in DriverUtils.cpp and change the argument to take std::function<bool(StringRef)>. It is less efficient than the template argument, but these functions aren't on a critical path so that's probably not an issue. Would that be preferable?

[MaskRay]

In D117933#3263929, @phosek wrote:

In D117933#3263111, @MaskRay wrote:

The code move to Driver.h feels a bit uneasy, hope someone may suggest whether there is a better way.

@arichardson @bd1976llvm @ikudrin

The functionality looks good and I am happy to LG if we can't think of a better way.

I also considered keeping the functions in DriverUtils.cpp and change the argument to take std::function<bool(StringRef)>. It is less efficient than the template argument, but these functions aren't on a critical path so that's probably not an issue. Would that be preferable?

Function definitions remaining in .cpp looks fine. You may use llvm::function_ref<bool(llvm::StringRef)> instead of std::function (which needs heap allocation).

[MaskRay]

Currently a deplib name (${name}) indicates either the literal ${name} or the -l style lib${name}.{a,so}.
We have a conflict if ${name} is foo and there is a directory named foo.

What if we do

if (name.endswith(".a") || name.endswith(".so"))
  findFromSearchPaths
else
  searchLibraryBaseName

?

That should avoid the conflict, too. A directory is unlikely named .so or .a.

---

I think when the deplib extension was added, I got slightly uneasy with it attempted both findFromSearchPaths and searchLibraryBaseName. And you raised a justifying example which makes users confused...

lld/ELF/InputFiles.cpp

119

Remove ENOTDIR. It is for diagnostics when the file type is expected to be a directory.

We may need to check whether category() is https://en.cppreference.com/w/cpp/error/system_category

lld/ELF/ScriptParser.cpp

319

The comment says skipDirectory but it is actually used for sys::fs::exists(path). The semantic is a bit different which may suggest skipDirectory is not suitable.

[mcgrathr]

In D117933#3267443, @MaskRay wrote:

Currently a deplib name (${name}) indicates either the literal ${name} or the -l style lib${name}.{a,so}.
We have a conflict if ${name} is foo and there is a directory named foo.

What if we do

if (name.endswith(".a") || name.endswith(".so"))
  findFromSearchPaths
else
  searchLibraryBaseName

?

That should avoid the conflict, too. A directory is unlikely named .so or .a.

I don't think introducing more magical rules about naming patterns ever makes things easier.

It is surprising at first blush that deplibs searches for "foo" and not just what "-lfoo" would do, but it makes sense if you want to allow saying "libfoo.a" in deplibs to avoid matching "libfoo.so" in arcane cases.
So I think just the fix here to make all cases of not-existing-files candidates on search paths be ignored robustly is sufficient. The extra set of candidates that deplibs cases will attempt is tolerable and IMHO it's far preferable to having any more magic in the semantics of the behavior than there already is

lld/ELF/InputFiles.cpp

119

This is inaccurate. ENOTDIR is also an expected error for certain cases of a nonexistent path, for example foo/bar/baz when foo/bar is an existing non-directory file is expected to be ignored and not stop continuing to search the next path candidate. The only case when open without O_DIRECTORY returns ENOTDIR is a case that should be treated as equivalent to ENOENT for this use.

[MaskRay]

In D117933#3267519, @mcgrathr wrote:

In D117933#3267443, @MaskRay wrote:

Currently a deplib name (${name}) indicates either the literal ${name} or the -l style lib${name}.{a,so}.
We have a conflict if ${name} is foo and there is a directory named foo.

What if we do

if (name.endswith(".a") || name.endswith(".so"))
  findFromSearchPaths
else
  searchLibraryBaseName

?

That should avoid the conflict, too. A directory is unlikely named .so or .a.

I don't think introducing more magical rules about naming patterns ever makes things easier.

It is surprising at first blush that deplibs searches for "foo" and not just what "-lfoo" would do, but it makes sense if you want to allow saying "libfoo.a" in deplibs to avoid matching "libfoo.so" in arcane cases.
So I think just the fix here to make all cases of not-existing-files candidates on search paths be ignored robustly is sufficient. The extra set of candidates that deplibs cases will attempt is tolerable and IMHO it's far preferable to having any more magic in the semantics of the behavior than there already is

It's not adding more magical rules. The chained findFromSearchPaths and searchLibraryBaseName is replaced with testing just one form.
We can then get rid of llvm::function_ref<bool(StringRef)>.

[bd1976llvm]

In D117933#3267645, @MaskRay wrote:

In D117933#3267519, @mcgrathr wrote:

In D117933#3267443, @MaskRay wrote:

Currently a deplib name (${name}) indicates either the literal ${name} or the -l style lib${name}.{a,so}.
We have a conflict if ${name} is foo and there is a directory named foo.

What if we do

if (name.endswith(".a") || name.endswith(".so"))
  findFromSearchPaths
else
  searchLibraryBaseName

?

That should avoid the conflict, too. A directory is unlikely named .so or .a.

I don't think introducing more magical rules about naming patterns ever makes things easier.

It is surprising at first blush that deplibs searches for "foo" and not just what "-lfoo" would do, but it makes sense if you want to allow saying "libfoo.a" in deplibs to avoid matching "libfoo.so" in arcane cases.
So I think just the fix here to make all cases of not-existing-files candidates on search paths be ignored robustly is sufficient. The extra set of candidates that deplibs cases will attempt is tolerable and IMHO it's far preferable to having any more magic in the semantics of the behavior than there already is

It's not adding more magical rules. The chained findFromSearchPaths and searchLibraryBaseName is replaced with testing just one form.
We can then get rid of llvm::function_ref<bool(StringRef)>.

I would rather keep the search scheme as simple and general as possible. The ".a" and ".so" suffixes are just conventions (not part of the ELF standard). My hope was to make the autolinking scheme implementable by any ELF linker.

LGTM to the proposed fix from me. If memory serves, I experimented with the same approach (as proposed here) when autolinking was first implemented; however, I decided to make the code as minimal as possible and see what fell out from real world usage as It wasn't clear to me what problems build systems would be able to workaround vs which would be blockers.

[MaskRay]

In D117933#3267868, @bd1976llvm wrote:

I would rather keep the search scheme as simple and general as possible. The ".a" and ".so" suffixes are just conventions (not part of the ELF standard). My hope was to make the autolinking scheme implementable by any ELF linker.

LGTM to the proposed fix from me. If memory serves, I experimented with the same approach (as proposed here) when autolinking was first implemented; however, I decided to make the code as minimal as possible and see what fell out from real world usage as It wasn't clear to me what problems build systems would be able to workaround vs which would be blockers.

If we want to keep minimum code, we can just swap searchLibraryBaseName and findFromSearchPaths branches.

I'd really liked that the feature started with -lfoo (instead of foo) in the first place if it were augmented with the ability to link an arbitrary absolute/relative path, since that is unambiguous.
Perhaps the ship has sailed now.

[phosek]

Have we reached a decision on this? I'd like to land this change since it's currently blocking a Clang roll for us.

[MaskRay]

In D117933#3277661, @phosek wrote:

Have we reached a decision on this? I'd like to land this change since it's currently blocking a Clang roll for us.

Just swap searchLibraryBaseName and findFromSearchPaths branches. It's the simplest/least intrusive fix.

[phosek]

In D117933#3277690, @MaskRay wrote:

In D117933#3277661, @phosek wrote:

Have we reached a decision on this? I'd like to land this change since it's currently blocking a Clang roll for us.

Just swap searchLibraryBaseName and findFromSearchPaths branches. It's the simplest/least intrusive fix.

That alone is not sufficient if the directory with the same name exists in the current directory as is the case in the attached test case, since we'll take this branch https://github.com/llvm/llvm-project/blob/249a21ab188419b019adea21716f5c779c063de3/lld/ELF/InputFiles.cpp#L493 and fail.

[MaskRay]

In D117933#3278789, @phosek wrote:

In D117933#3277690, @MaskRay wrote:

In D117933#3277661, @phosek wrote:

Have we reached a decision on this? I'd like to land this change since it's currently blocking a Clang roll for us.

Just swap searchLibraryBaseName and findFromSearchPaths branches. It's the simplest/least intrusive fix.

That alone is not sufficient if the directory with the same name exists in the current directory as is the case in the attached test case, since we'll take this branch https://github.com/llvm/llvm-project/blob/249a21ab188419b019adea21716f5c779c063de3/lld/ELF/InputFiles.cpp#L493 and fail.

OK. Then move searchLibraryBaseName to the top. I think the comment https://reviews.llvm.org/D117933#3267443 is also relevant to decrease the number of filesystem probing.

[phosek]

We went with D118498 instead.

lld/ELF/Driver.h

 namespace lld {
 namespace elf {
 
 extern std::unique_ptr<class LinkerDriver> driver;
 
 class LinkerDriver {
 public:
   void linkerMain(ArrayRef<const char *> args);
-  void addFile(StringRef path, bool withLOption);
+  bool addFile(StringRef path, bool withLOption, bool ignoreError = false);
   void addLibrary(StringRef name);
 
 private:
   void createFiles(llvm::opt::InputArgList &args);
   void inferMachineType();
   template <class ELFT> void link(llvm::opt::InputArgList &args);
   template <class ELFT> void compileBitcodeFiles(bool skipLinkedOutput);
 

 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 void printHelp();
 std::string createResponseFile(const llvm::opt::InputArgList &args);
 
-llvm::Optional<std::string> findFromSearchPaths(StringRef path);
-llvm::Optional<std::string> searchScript(StringRef path);
-llvm::Optional<std::string> searchLibraryBaseName(StringRef path);
-llvm::Optional<std::string> searchLibrary(StringRef path);
+using HandlePath = std::function<bool(StringRef)>;
+
+bool findFromSearchPaths(StringRef path, HandlePath func);
+bool searchLibraryBaseName(StringRef name, HandlePath func);
+bool searchLibrary(StringRef name, HandlePath func);
+bool searchScript(StringRef name, HandlePath func);
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/Driver.cpp

std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
   // Take ownership of memory buffers created for members of thin archives.
   for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
     make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
 
   return v;
 }
 
 // Opens a file and create a file object. Path has to be resolved already.
-void LinkerDriver::addFile(StringRef path, bool withLOption) {
+bool LinkerDriver::addFile(StringRef path, bool withLOption, bool skipDirectory) {
   using namespace sys::fs;
 
-  Optional<MemoryBufferRef> buffer = readFile(path);
+  Optional<MemoryBufferRef> buffer = readFile(path, skipDirectory);
   if (!buffer.hasValue())
-    return;
+    return false;
   MemoryBufferRef mbref = *buffer;
 
   if (config->formatBinary) {
     files.push_back(make<BinaryFile>(mbref));
-    return;
+    return true;
   }
 
   switch (identify_magic(mbref.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(mbref);
-    return;
+    break;
   case file_magic::archive: {
     if (inWholeArchive) {
       for (const auto &p : getArchiveMembers(mbref))
         files.push_back(createObjectFile(p.first, path, p.second));
-      return;
+      break;
     }
 
     std::unique_ptr<Archive> file =
         CHECK(Archive::create(mbref), path + ": failed to parse archive");
 
     // If an archive file has no symbol table, it may be intentional (used as a
     // group of lazy object files where the symbol table is not useful), or the
     // user is attempting LTO and using a default ar command that doesn't
     // understand the LLVM bitcode file. Treat the archive as a group of lazy
     // object files.
     if (!file->isEmpty() && !file->hasSymbolTable()) {
       for (const std::pair<MemoryBufferRef, uint64_t> &p :
            getArchiveMembers(mbref)) {
         auto magic = identify_magic(p.first.getBuffer());
         if (magic == file_magic::bitcode ||
             magic == file_magic::elf_relocatable)
           files.push_back(createLazyFile(p.first, path, p.second));
         else
           error(path + ": archive member '" + p.first.getBufferIdentifier() +
                 "' is neither ET_REL nor LLVM bitcode");
       }
-      return;
+      break;
     }
 
     // Handle the regular case.
     files.push_back(make<ArchiveFile>(std::move(file)));
-    return;
+    break;
   }
   case file_magic::elf_shared_object:
     if (config->isStatic || config->relocatable) {
       error("attempted static link of dynamic object " + path);
-      return;
+      break;
     }
 
     // Shared objects are identified by soname. soname is (if specified)
     // DT_SONAME and falls back to filename. If a file was specified by -lfoo,
     // the directory part is ignored. Note that path may be a temporary and
     // cannot be stored into SharedFile::soName.
     path = mbref.getBufferIdentifier();
     files.push_back(
         make<SharedFile>(mbref, withLOption ? path::filename(path) : path));
-    return;
+    break;
   case file_magic::bitcode:
   case file_magic::elf_relocatable:
     if (inLib)
       files.push_back(createLazyFile(mbref, "", 0));
     else
       files.push_back(createObjectFile(mbref));
     break;
   default:
     error(path + ": unknown file type");
+    break;
   }
+  return true;
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef name) {
-  if (Optional<std::string> path = searchLibrary(name))
-    addFile(*path, /*withLOption=*/true);
-  else
+  if (!searchLibrary(name, [&](StringRef path) {
+        return addFile(path, /*withLOption=*/true, /*skipDirectory=*/true);
+      }))
     error("unable to find library -l" + name, ErrorTag::LibNotFound, {name});
 }
 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.
 static void initLLVM() {
static void readConfigs(opt::InputArgList &args) {
   // like semantics.
   config->symbolic =
       config->bsymbolic == BsymbolicKind::All || args.hasArg(OPT_dynamic_list);
   for (auto *arg :
        args.filtered(OPT_dynamic_list, OPT_export_dynamic_symbol_list))
     if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
       readDynamicList(*buffer);
 
-  for (auto *arg : args.filtered(OPT_version_script))
-    if (Optional<std::string> path = searchScript(arg->getValue())) {
-      if (Optional<MemoryBufferRef> buffer = readFile(*path))
+  for (auto *arg : args.filtered(OPT_version_script)) {
+    if (!searchScript(arg->getValue(), [](StringRef path) {
+          if (Optional<MemoryBufferRef> buffer =
+                  readFile(path, /*skipDirectory=*/true)) {
             readVersionScript(*buffer);
-    } else {
+            return true;
+          }
+          return false;
+        }))
       error(Twine("cannot find version script ") + arg->getValue());
-    }
 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &args) {
   ELFKind k = config->ekind;
case OPT_defsym: {
       StringRef to;
       std::tie(from, to) = StringRef(arg->getValue()).split('=');
       if (from.empty() || to.empty())
         error("--defsym: syntax error: " + StringRef(arg->getValue()));
       else
         readDefsym(from, MemoryBufferRef(to, "--defsym"));
       break;
     }
-    case OPT_script:
-      if (Optional<std::string> path = searchScript(arg->getValue())) {
-        if (Optional<MemoryBufferRef> mb = readFile(*path))
+    case OPT_script: {
+      if (!searchScript(arg->getValue(), [](StringRef path) {
+            if (Optional<MemoryBufferRef> mb =
+                    readFile(path, /*skipDirectory=*/true)) {
               readLinkerScript(*mb);
-        break;
+              return true;
             }
+            return false;
+          }))
         error(Twine("cannot find linker script ") + arg->getValue());
       break;
+    }
     case OPT_as_needed:
       config->asNeeded = true;
       break;
     case OPT_format:
       config->formatBinary = isFormatBinary(arg->getValue());
       break;
     case OPT_no_as_needed:
       config->asNeeded = false;

lld/ELF/DriverUtils.cpp

default:
       os << toString(*arg) << "\n";
     }
   }
   return std::string(data.str());
 }
 
 // Find a file by concatenating given paths. If a resulting path
 // starts with "=", the character is replaced with a --sysroot value.
-static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
+static std::string findFile(StringRef path1, const Twine &path2) {
   SmallString<128> s;
   if (path1.startswith("="))
     path::append(s, config->sysroot, path1.substr(1), path2);
   else
     path::append(s, path1, path2);
-
-  if (fs::exists(s))
-    return std::string(s);
-  return None;
 }
 
-Optional<std::string> elf::findFromSearchPaths(StringRef path) {
+bool elf::findFromSearchPaths(StringRef path, HandlePath func) {
   for (StringRef dir : config->searchPaths)
-    if (Optional<std::string> s = findFile(dir, path))
-      return s;
-  return None;
+    if (func(findFile(dir, path)))
+      return true;
+  return false;
 }
 
-// This is for -l<basename>. We'll look for lib<basename>.so or lib<basename>.a from
-// search paths.
-Optional<std::string> elf::searchLibraryBaseName(StringRef name) {
+// This is for -l<basename>. We'll look for lib<basename>.so or lib<basename>.a
+// from search paths.
+bool elf::searchLibraryBaseName(StringRef name, HandlePath func) {
   for (StringRef dir : config->searchPaths) {
     if (!config->isStatic)
-      if (Optional<std::string> s = findFile(dir, "lib" + name + ".so"))
-        return s;
-    if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
-      return s;
+      if (func(findFile(dir, "lib" + name + ".so")))
+        return true;
+    if (func(findFile(dir, "lib" + name + ".a")))
+      return true;
   }
-  return None;
+  return false;
 }
 
 // This is for -l<namespec>.
-Optional<std::string> elf::searchLibrary(StringRef name) {
+bool elf::searchLibrary(StringRef name, HandlePath func) {
   llvm::TimeTraceScope timeScope("Locate library", name);
   if (name.startswith(":"))
-    return findFromSearchPaths(name.substr(1));
-  return searchLibraryBaseName(name);
+    return findFromSearchPaths(name.substr(1), func);
+  return searchLibraryBaseName(name, func);
 }
 
 // If a linker/version script doesn't exist in the current directory, we also
 // look for the script in the '-L' search paths. This matches the behaviour of
 // '-T', --version-script=, and linker script INPUT() command in ld.bfd.
-Optional<std::string> elf::searchScript(StringRef name) {
-  if (fs::exists(name))
-    return name.str();
-  return findFromSearchPaths(name);
+bool elf::searchScript(StringRef name, HandlePath func) {
+  return func(name) || findFromSearchPaths(name, func);
 }

lld/ELF/InputFiles.h

 
 class InputSection;
 class Symbol;
 
 // If --reproduce is specified, all input files are written to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> tar;
 
 // Opens a given file.
-llvm::Optional<MemoryBufferRef> readFile(StringRef path);
+llvm::Optional<MemoryBufferRef> readFile(StringRef path,
+                                         bool skipDirectory = false);
 
 // Add symbols in File to the symbol table.
 void parseFile(InputFile *file);
 
 // The root class of input files.
 class InputFile {
 private:
   // Cache for getNameForScript().

lld/ELF/InputFiles.cpp

 InputFile::InputFile(Kind k, MemoryBufferRef m)
     : mb(m), groupId(nextGroupId), fileKind(k) {
   // All files within the same --{start,end}-group get the same group ID.
   // Otherwise, a new file will get a new group ID.
   if (!isInGroup)
     ++nextGroupId;
 }
 
-Optional<MemoryBufferRef> elf::readFile(StringRef path) {
+Optional<MemoryBufferRef> elf::readFile(StringRef path, bool skipDirectory) {
   llvm::TimeTraceScope timeScope("Load input files", path);
 
   // The --chroot option changes our virtual root directory.
   // This is useful when you are dealing with files created by --reproduce.
   if (!config->chroot.empty() && path.startswith("/"))
     path = saver().save(config->chroot + path);
 
-  log(path);
-  config->dependencyFiles.insert(llvm::CachedHashString(path));
-
   auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
                                        /*RequiresNullTerminator=*/false);
   if (auto ec = mbOrErr.getError()) {
+    int val = ec.value();
+    if (!skipDirectory || (val != ENOENT && val != ENOTDIR && val != EISDIR))
       error("cannot open " + path + ": " + ec.message());
     return None;
   }
 
+  log(path);
+  config->dependencyFiles.insert(llvm::CachedHashString(path));
+
   MemoryBufferRef mbref = (*mbOrErr)->getMemBufferRef();
   memoryBuffers.push_back(std::move(*mbOrErr)); // take MB ownership
 
   if (tar)
     tar->append(relativeToRoot(path), mbref.getBuffer());
   return mbref;
 }
 

 // section contains a list of library specifiers such as `m` for libm. This
 // function resolves a given name by finding the first matching library checking
 // the various ways that a library can be specified to LLD. This ELF extension
 // is a form of autolinking and is called `dependent libraries`. It is currently
 // unique to LLVM and lld.
 static void addDependentLibrary(StringRef specifier, const InputFile *f) {
   if (!config->dependentLibraries)
     return;
-  if (fs::exists(specifier))
-    driver->addFile(specifier, /*withLOption=*/false);
-  else if (Optional<std::string> s = findFromSearchPaths(specifier))
-    driver->addFile(*s, /*withLOption=*/true);
-  else if (Optional<std::string> s = searchLibraryBaseName(specifier))
-    driver->addFile(*s, /*withLOption=*/true);
-  else
-    error(toString(f) +
-          ": unable to find library from dependent library specifier: " +
-          specifier);
+  if (driver->addFile(specifier, /*withLOption=*/false, /*skipDirectory=*/true))
+    return;
+  if (findFromSearchPaths(specifier, [](StringRef path) {
+        return driver->addFile(path, /*withLOption=*/true,
+                               /*skipDirectory=*/true);
+      }))
+    return;
+  if (searchLibraryBaseName(specifier, [](StringRef path) {
+        return driver->addFile(path, /*withLOption=*/true,
+                               /*skipDirectory=*/true);
+      }))
+    return;
 }
 
 // Record the membership of a section group so that in the garbage collection
 // pass, section group members are kept or discarded as a unit.
 template <class ELFT>
 static void handleSectionGroup(ArrayRef<InputSectionBase *> sections,
                                ArrayRef<typename ELFT::Word> entries) {
   bool hasAlloc = false;

lld/ELF/ScriptParser.cpp

if (s.startswith("/")) {
     driver->addLibrary(s.substr(2));
   } else {
     // Case 4: s is a relative path. Search in the directory of the script file.
     std::string filename = std::string(getCurrentMB().getBufferIdentifier());
     StringRef directory = sys::path::parent_path(filename);
     if (!directory.empty()) {
       SmallString<0> path(directory);
       sys::path::append(path, s);
-      if (sys::fs::exists(path)) {
-        driver->addFile(path, /*withLOption=*/false);
+      if (driver->addFile(path, /*withLOption=*/false, /*skipDirectory=*/true))
         return;
-      }
-    }
     // Then search in the current working directory.
-    if (sys::fs::exists(s)) {
-      driver->addFile(s, /*withLOption=*/false);
-    } else {
-      // Finally, search in the list of library paths.
-      if (Optional<std::string> path = findFromSearchPaths(s))
-        driver->addFile(saver().save(*path), /*withLOption=*/true);
-      else
-        setError("unable to find " + s);
-    }
-  }
-}
+    if (driver->addFile(s, /*withLOption=*/false, /*skipDirectory=*/true))
+      return;
+    if (findFromSearchPaths(s, [](StringRef path) {
+          return driver->addFile(path, /*withLOption=*/true,
+                                 /*skipDirectory=*/true);
+        }))
+      return;
 
 void ScriptParser::readAsNeeded() {
   expect("(");
   bool orig = config->asNeeded;
   config->asNeeded = true;
   while (!errorCount() && !consume(")"))
     addFile(unquote(next()));
   config->asNeeded = orig;

 void ScriptParser::readInclude() {
   StringRef tok = unquote(next());
 
   if (!seen.insert(tok).second) {
     setError("there is a cycle in linker script INCLUDEs");
     return;
   }
 
-  if (Optional<std::string> path = searchScript(tok)) {
-    if (Optional<MemoryBufferRef> mb = readFile(*path))
+  if (!searchScript(tok, [&](StringRef path) {
+        if (Optional<MemoryBufferRef> mb =
+                readFile(path, /*skipDirectory=*/true)) {
           tokenize(*mb);
-    return;
+          return true;
         }
+        return false;
+      }))
     setError("cannot find linker script " + tok);
 }
 
 void ScriptParser::readInput() {
   expect("(");
   while (!errorCount() && !consume(")")) {
     if (consume("AS_NEEDED"))
       readAsNeeded();
     else

lld/test/ELF/deplibs-dir.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: echo ".global foo; foo:" | \
+# RUN:   llvm-mc -filetype=obj -triple=x86_64 - -o %tfoo.o
+# RUN: rm -rf %t.dir
+# RUN: mkdir -p %t.dir
+# RUN: cd %t.dir
+# RUN: touch %t.dir/notdir
+# RUN: mkdir -p %t.dir/foo
+# RUN: mkdir -p %t.dir/bar/foo
+# RUN: mkdir -p %t.dir/baz
+# RUN: llvm-ar rc %t.dir/baz/libfoo.a %tfoo.o
+# RUN: ld.lld %t.o -o /dev/null -L%t.dir/notdir -L %t.dir/bar -L %t.dir/baz --trace 2>&1 | \
+# RUN:   FileCheck %s -DOBJ=%t.o -DDIR=%t.dir
+
+# CHECK:      [[OBJ]]
+# CHECK-NOT:  [[DIR]]{{[\\/]}}foo: Is a directory
+# CHECK-NOT:  [[DIR]]{{[\\/]}}bar{{[\\/]}}foo: Is a directory
+# CHECK-NEXT: [[DIR]]{{[\\/]}}baz{{[\\/]}}libfoo.a
+
+.global _start
+_start:
+    call foo
+.section ".deplibs","MS",@llvm_dependent_libraries,1
+    .asciz "foo"