[ORC][COFF] Handle COFF import files of static archive.

[sunho]

Summary

Handles COFF import files of static archive. Changes static library genrator to build up object file map keyed by symbol name that excludes the symbols from dllimported symbols so that static generator will not be responsible for them. It exposes the list of dynamic libraries that need to be imported. Client should properly load the libraries in this list beforehand. Object file map is also an improvment from the past in terms of performance. Archive.findSym does a slow O(n) linear serach of symbol list to find the symbol. (we call findSym O(n) times, thus full time complexity is O(n^2); we were the only user of findSym function in fact)

There is a room for improvements in how to load the libraries in the list. We currently just hand the responsibility over to the clinet. A better way would be let ORC read this list and hand them over to JITLink side that would also help validation (e.g. not trying to generate stub for non dllimported targets) Nevertheless, we will have to exclude the symbols from COFF import object file list and need a way to access this list, which this patch offers.

[sunho]

Use symbolstringptr.

[lhames]

Does obj2yaml work for archives? If so it'd be cool to have a testcase for this. If obj2yaml doesn't support this I'm not sure we could count on having available tools that would produce an archive with COFF imports in it, could we?

llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h

290–295

Eventually I think we'll want this to be a separate structure returned by the Create, rather than a method on StaticLibraryDefinitionGenerator, but it's early days for this API -- I don't mind if it lands like this initially.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1675–1677

This is always going to load the library as a real dylib (via EPCDynamicLibrarySearchGenerator), right?

Could we have it treated as if it were a -L argument instead?

[sunho]

obj2yaml tries to dump the archive files but support for lib file is broken. I think we can use other tools to genrate test cases though. (we could just use raw lib file if we can't get anything working)

[sunho]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1675–1677

We want to search the dll file that is not inside specified -L serach directories as well. One way is extend existing -l flag to also look up system dynamic library if everything else fails in search directorires and print warning message. How does that sound to you?

[lhames]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1675–1677

How is MSVC / LINK.EXE handling this? Do they just have a fallback list of search paths to search on? I'd be fine with including those as if they were -L arguments by default (maybe with a switch to turn them off explicitly where they're not wanted)

[sunho]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1675–1677

It would just rely on windows kernel to do the dll search which is described in https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order. However, common use cases of llvm-jitlink wouldn't really want to look pathes other than MSVC installations and probably some windows system path. So, I think it's fine to go with adding some default path to -L way.

[sunho]

New approach in llvm-jitlink

[sunho]

Optimize code a bit. I don't think this part of code needs optimization but I couldn't help it.

[lhames]

See individual comments, but otherwise LGTM!

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

426

Following the usual error handling idioms you should add an ErrorAsOutParameter _(&Err); variable to the start of this function body -- this will clear the checked flag on exit from the constructor, forcing the caller to check it. (The original version did not need this, as Err was never modified in the body.)

In this case it's not necessary at the moment because the constructor is private and the only caller returns the Error (which will also clear the checked flag), but it would become important if we ever made the constructor public.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

97–98

"dynlib" isn't used anywhere else -- I think this should either be "dylib", or just plain "search-system-lib-paths".

1272–1276

Could you add an TODO to move this logic into ObjectFile::getTriple().

1536–1545

We probably want to add API to the ORC runtime to retrieve the remote environment, rather than grabbing the local one. Could you add a TODO for this too?

1595

What's the rationale behind the switch to a priority queue? Unless there's a good reason for the switch this should stay as a std::vector, just to minimize the differences introduced in this patch.

1681–1682

This should generate an llvm::Error rather than assert -- we can't assume that object contents are well-formed.

1803–1808

Rather than hoisting the loop into a lambda, you could use LLVM's handy concat-iterator utility to iterate over both sequences in one go:

for (StringRef SearchPath : concat<StringRef>(JDSearchPaths[&JD], SystemSearchPaths)) {
    ..
}

[sunho]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

1595

We still need another type of data structure to "push_front" We could reverse the order of sorting -- but that makes it more confusing in my opinion. I changed it to deque to keep it similar in terms of code and performance while enabling to push load job in the middle.

llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h

public:
 
   /// Try to create a StaticLibrarySearchGenerator from the given memory buffer.
   /// This call will succeed if the buffer contains a valid archive, otherwise
   /// it will return an error.
   static Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
   Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
          GetObjectFileInterface GetObjFileInterface = GetObjectFileInterface());
 
+  /// Returns a list of filenames of dynamic libraries that this archive has
+  /// imported. This class does not load these libraries by itself. User is
+  /// responsible for making sure these libraries are avaliable to the JITDylib.
+  const std::set<std::string> &getImportedDynamicLibraries() const {
+    return ImportedDynamicLibraries;
+  }
+
   Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                       JITDylibLookupFlags JDLookupFlags,
                       const SymbolLookupSet &Symbols) override;
 
 private:
   StaticLibraryDefinitionGenerator(ObjectLayer &L,
                                    std::unique_ptr<MemoryBuffer> ArchiveBuffer,
                                    GetObjectFileInterface GetObjFileInterface,
                                    Error &Err);
 
+  Error buildObjectFilesMap();
+
   ObjectLayer &L;
   GetObjectFileInterface GetObjFileInterface;
+  std::set<std::string> ImportedDynamicLibraries;
   std::unique_ptr<MemoryBuffer> ArchiveBuffer;
   std::unique_ptr<object::Archive> Archive;
+  DenseMap<SymbolStringPtr, MemoryBufferRef> ObjectFilesMap;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_EXECUTIONUTILS_H

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

Error StaticLibraryDefinitionGenerator::tryToGenerate(
   // Bail out early if we've already freed the archive.
   if (!Archive)
     return Error::success();
 
   DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos;
 
   for (const auto &KV : Symbols) {
     const auto &Name = KV.first;
-    auto Child = Archive->findSym(*Name);
-    if (!Child)
-      return Child.takeError();
-    if (*Child == None)
+    if (!ObjectFilesMap.count(Name))
       continue;
-    auto ChildBuffer = (*Child)->getMemoryBufferRef();
-    if (!ChildBuffer)
-      return ChildBuffer.takeError();
+    auto ChildBuffer = ObjectFilesMap[Name];
     ChildBufferInfos.insert(
-        {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()});
+        {ChildBuffer.getBuffer(), ChildBuffer.getBufferIdentifier()});
   }
 
   for (auto ChildBufferInfo : ChildBufferInfos) {
     MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
                                    ChildBufferInfo.second);
 
     auto I = GetObjFileInterface(L.getExecutionSession(), ChildBufferRef);
     if (!I)
       return I.takeError();
 
     if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false),
                          std::move(*I)))
       return Err;
   }
 
   return Error::success();
 }
 
+Error StaticLibraryDefinitionGenerator::buildObjectFilesMap() {
+  DenseMap<uint64_t, MemoryBufferRef> MemoryBuffers;
+  DenseSet<uint64_t> Visited;
+  DenseSet<uint64_t> Excluded;
+  for (auto &S : Archive->symbols()) {
+    StringRef SymName = S.getName();
+    auto Member = S.getMember();
+    if (!Member)
+      return Member.takeError();
+    auto DataOffset = Member->getDataOffset();
+    if (!Visited.count(DataOffset)) {
+      Visited.insert(DataOffset);
+      auto Child = Member->getAsBinary();
+      if (!Child)
+        return Child.takeError();
+      if ((*Child)->isCOFFImportFile()) {
+        ImportedDynamicLibraries.insert((*Child)->getFileName().str());
+        Excluded.insert(DataOffset);
+        continue;
+      }
+      MemoryBuffers[DataOffset] = (*Child)->getMemoryBufferRef();
+    }
+    if (!Excluded.count(DataOffset))
+      ObjectFilesMap[L.getExecutionSession().intern(SymName)] =
+          MemoryBuffers[DataOffset];
+  }
+
+  return Error::success();
+}
+
 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer,
     GetObjectFileInterface GetObjFileInterface, Error &Err)
     : L(L), GetObjFileInterface(std::move(GetObjFileInterface)),
       ArchiveBuffer(std::move(ArchiveBuffer)),
       Archive(std::make_unique<object::Archive>(*this->ArchiveBuffer, Err)) {
 
   if (!this->GetObjFileInterface)
     this->GetObjFileInterface = getObjectFileInterface;
+  if (!Err)
+    Err = buildObjectFilesMap();
 }
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/tools/llvm-jitlink/llvm-jitlink.h

struct Session {
   FileInfoMap FileInfos;
   uint64_t SizeBeforePruning = 0;
   uint64_t SizeAfterFixups = 0;
 
   StringSet<> HarnessFiles;
   StringSet<> HarnessExternals;
   StringSet<> HarnessDefinitions;
   DenseMap<StringRef, StringRef> CanonicalWeakDefs;
+  DenseSet<StringRef> LoadedLibraries;
 
 private:
   Session(std::unique_ptr<orc::ExecutorProcessControl> EPC, Error &Err);
 };
 
 /// Record symbols, GOT entries, stubs, and sections for ELF file.
 Error registerELFGraphInfo(Session &S, jitlink::LinkGraph &G);
 

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 //===- llvm-jitlink.cpp -- Command line interface/tester for llvm-jitlink -===//
 //
 // 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 utility provides a simple command line interface to the llvm jitlink
 // library, which makes relocatable object files executable in memory. Its
 // primary function is as a testing utility for the jitlink library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-jitlink.h"
 
+#include "llvm/ADT/PriorityQueue.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
 #include "llvm/ExecutionEngine/Orc/DebuggerSupportPlugin.h"
 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h"
 #include "llvm/ExecutionEngine/Orc/EPCDebugObjectRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
 #include "llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
LibrariesHidden("hidden-l",
                              "paths with hidden visibility"),
                     cl::Prefix, cl::cat(JITLinkCategory));
 
 static cl::list<std::string>
     LoadHidden("load_hidden",
                cl::desc("Link against library X with hidden visibility"),
                cl::cat(JITLinkCategory));
 
+static cl::opt<bool> SearchSystemDynLibrary(
+    "search-sys-dynlib",
+    cl::desc("Add system library paths to dynamic library search paths"),
+    cl::init(false), cl::cat(JITLinkCategory));
+
 static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"),
                             cl::init(false), cl::cat(JITLinkCategory));
 
 static cl::list<std::string>
     CheckFiles("check", cl::desc("File containing verifier checks"),
                cl::cat(JITLinkCategory));
 
 static cl::opt<std::string>
if (!CheckFiles.empty())
     PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) {
       auto &EPC = ES.getExecutorProcessControl();
       if (EPC.getTargetTriple().getObjectFormat() == Triple::ELF)
         return registerELFGraphInfo(*this, G);
 
       if (EPC.getTargetTriple().getObjectFormat() == Triple::MachO)
         return registerMachOGraphInfo(*this, G);
 
-      if (EPC.getTargetTriple().isOSWindows())
+      if (EPC.getTargetTriple().getObjectFormat() == Triple::COFF)
         return registerCOFFGraphInfo(*this, G);
 
       return make_error<StringError>("Unsupported object format for GOT/stub "
                                      "registration",
                                      inconvertibleErrorCode());
     });
 
   if (ShowLinkGraph)
for (auto InputFile : InputFiles) {
       file_magic Magic = identify_magic(ObjBuffer->getBuffer());
       switch (Magic) {
       case file_magic::coff_object:
       case file_magic::elf_relocatable:
       case file_magic::macho_object: {
         auto Obj = ExitOnErr(
             object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
         Triple TT = Obj->makeTriple();
-        if (Magic == file_magic::coff_object)
+        if (Magic == file_magic::coff_object) {
+          TT.setObjectFormat(Triple::COFF);
           TT.setOS(Triple::OSType::Win32);
+        }
         return TT;
       }
       default:
         break;
       }
     }
     return Triple();
   }();
 
getObjectFileInterfaceHidden(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
   auto I = getObjectFileInterface(ES, ObjBuffer);
   if (I) {
     for (auto &KV : I->SymbolFlags)
       KV.second &= ~JITSymbolFlags::Exported;
   }
   return I;
 }
 
+static SmallVector<StringRef, 5> getSearchPathsFromEnvVar(Session &S) {
+  SmallVector<StringRef, 5> PathVec;
+  auto TT = S.ES.getExecutorProcessControl().getTargetTriple();
+  if (TT.isOSBinFormatCOFF())
+    StringRef(getenv("PATH")).split(PathVec, ";");
+  else if (TT.isOSBinFormatELF())
+    StringRef(getenv("LD_LIBRARY_PATH")).split(PathVec, ":");
+
+  return PathVec;
+}
+
 static Error addLibraries(Session &S,
                           const std::map<unsigned, JITDylib *> &IdxToJD) {
 
   // 1. Collect search paths for each JITDylib.
   DenseMap<const JITDylib *, SmallVector<StringRef, 2>> JDSearchPaths;
 
   for (auto LSPItr = LibrarySearchPaths.begin(),
             LSPEnd = LibrarySearchPaths.end();
for (auto &KV : JDSearchPaths) {
       for (auto &LibSearchPath : KV.second)
         dbgs() << " \"" << LibSearchPath << "\"";
       dbgs() << " ]\n";
     }
   });
 
   // 2. Collect library loads
   struct LibraryLoad {
-    StringRef LibName;
+    std::string LibName;
     bool IsPath = false;
     unsigned Position;
     StringRef *CandidateExtensions;
     enum { Standard, Hidden } Modifier;
   };
-  std::vector<LibraryLoad> LibraryLoads;
+
+  // Queue to load library as in the order as it appears in the argument list.
+  auto Comp = [](const LibraryLoad &LHS, const LibraryLoad &RHS) -> bool {
+    return LHS.Position > RHS.Position;
+  };
+  llvm::PriorityQueue<LibraryLoad, SmallVector<LibraryLoad, 2>, decltype(Comp)>
+      LibraryLoadQueue(Comp);
   // Add archive files from the inputs to LibraryLoads.
   for (auto InputFileItr = InputFiles.begin(), InputFileEnd = InputFiles.end();
        InputFileItr != InputFileEnd; ++InputFileItr) {
     StringRef InputFile = *InputFileItr;
     if (!InputFile.endswith(".a") && !InputFile.endswith(".lib"))
       continue;
     LibraryLoad LL;
-    LL.LibName = InputFile;
+    LL.LibName = InputFile.str();
     LL.IsPath = true;
     LL.Position = InputFiles.getPosition(InputFileItr - InputFiles.begin());
     LL.CandidateExtensions = nullptr;
     LL.Modifier = LibraryLoad::Standard;
-    LibraryLoads.push_back(std::move(LL));
+    LibraryLoadQueue.push(std::move(LL));
   }
 
   // Add -load_hidden arguments to LibraryLoads.
   for (auto LibItr = LoadHidden.begin(), LibEnd = LoadHidden.end();
        LibItr != LibEnd; ++LibItr) {
     LibraryLoad LL;
     LL.LibName = *LibItr;
     LL.IsPath = true;
     LL.Position = LoadHidden.getPosition(LibItr - LoadHidden.begin());
     LL.CandidateExtensions = nullptr;
     LL.Modifier = LibraryLoad::Hidden;
-    LibraryLoads.push_back(std::move(LL));
+    LibraryLoadQueue.push(std::move(LL));
   }
   StringRef StandardExtensions[] = {".so", ".dylib", ".dll", ".a", ".lib"};
+  StringRef DynLibExtensionsOnly[] = {".so", ".dylib", ".dll"};
   StringRef ArchiveExtensionsOnly[] = {".a", ".lib"};
 
   // Add -lx arguments to LibraryLoads.
   for (auto LibItr = Libraries.begin(), LibEnd = Libraries.end();
        LibItr != LibEnd; ++LibItr) {
     LibraryLoad LL;
     LL.LibName = *LibItr;
     LL.Position = Libraries.getPosition(LibItr - Libraries.begin());
     LL.CandidateExtensions = StandardExtensions;
     LL.Modifier = LibraryLoad::Standard;
-    LibraryLoads.push_back(std::move(LL));
+    LibraryLoadQueue.push(std::move(LL));
   }
 
   // Add -hidden-lx arguments to LibraryLoads.
   for (auto LibHiddenItr = LibrariesHidden.begin(),
             LibHiddenEnd = LibrariesHidden.end();
        LibHiddenItr != LibHiddenEnd; ++LibHiddenItr) {
     LibraryLoad LL;
     LL.LibName = *LibHiddenItr;
     LL.Position =
         LibrariesHidden.getPosition(LibHiddenItr - LibrariesHidden.begin());
     LL.CandidateExtensions = ArchiveExtensionsOnly;
     LL.Modifier = LibraryLoad::Hidden;
-    LibraryLoads.push_back(std::move(LL));
+    LibraryLoadQueue.push(std::move(LL));
   }
 
   // If there are any load-<modified> options then turn on flag overrides
   // to avoid flag mismatch errors.
   if (!LibrariesHidden.empty() || !LoadHidden.empty())
     S.ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
 
-  // Sort library loads by position in the argument list.
-  llvm::sort(LibraryLoads, [](const LibraryLoad &LHS, const LibraryLoad &RHS) {
-    return LHS.Position < RHS.Position;
-  });
-
   // 3. Process library loads.
   auto AddArchive = [&](const char *Path, const LibraryLoad &LL)
       -> Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> {
     unique_function<Expected<MaterializationUnit::Interface>(
         ExecutionSession & ES, MemoryBufferRef ObjBuffer)>
         GetObjFileInterface;
     switch (LL.Modifier) {
     case LibraryLoad::Standard:
       GetObjFileInterface = getObjectFileInterface;
       break;
     case LibraryLoad::Hidden:
       GetObjFileInterface = getObjectFileInterfaceHidden;
       break;
     }
-    return StaticLibraryDefinitionGenerator::Load(
+    auto G = StaticLibraryDefinitionGenerator::Load(
         S.ObjLayer, Path, S.ES.getExecutorProcessControl().getTargetTriple(),
         std::move(GetObjFileInterface));
+    if (!G)
+      return G.takeError();
+
+    // Push additional dynamic libraries to search.
+    // Note that this mechanism only happens in COFF.
+    for (auto FileName : (*G)->getImportedDynamicLibraries()) {
+      LibraryLoad NewLL;
+      auto FileNameRef = StringRef(FileName);
+      assert(FileNameRef.endswith_insensitive(".dll") &&
+             "COFF Imported library not ending with dll extension?");
+      NewLL.LibName = FileNameRef.drop_back(strlen(".dll")).str();
+      NewLL.Position = LL.Position;
+      NewLL.CandidateExtensions = DynLibExtensionsOnly;
+      NewLL.Modifier = LibraryLoad::Standard;
+      LibraryLoadQueue.push(std::move(NewLL));
+    }
+    return G;
   };
 
-  for (auto &LL : LibraryLoads) {
+  SmallVector<StringRef, 5> SystemSearchPaths;
+  if (SearchSystemDynLibrary.getValue())
+    SystemSearchPaths = getSearchPathsFromEnvVar(S);
+  while (!LibraryLoadQueue.empty()) {
     bool LibFound = false;
+    auto LL = LibraryLoadQueue.top();
+    LibraryLoadQueue.pop();
     auto &JD = *std::prev(IdxToJD.lower_bound(LL.Position))->second;
 
     // If this is the name of a JITDylib then link against that.
     if (auto *LJD = S.ES.getJITDylibByName(LL.LibName)) {
       JD.addToLinkOrder(*LJD);
       continue;
     }
 
     if (LL.IsPath) {
-      auto G = AddArchive(LL.LibName.str().c_str(), LL);
+      auto G = AddArchive(LL.LibName.c_str(), LL);
       if (!G)
         return createFileError(LL.LibName, G.takeError());
       JD.addGenerator(std::move(*G));
       LLVM_DEBUG({
         dbgs() << "Adding generator for static library " << LL.LibName << " to "
                << JD.getName() << "\n";
       });
       continue;
     }
 
     // Otherwise look through the search paths.
-    auto JDSearchPathsItr = JDSearchPaths.find(&JD);
-    if (JDSearchPathsItr != JDSearchPaths.end()) {
-      for (StringRef SearchPath : JDSearchPathsItr->second) {
+    auto TraverseSearchPathList =
+        [&](ArrayRef<StringRef> SearchPaths) -> Error {
+      for (StringRef SearchPath : SearchPaths) {
         for (const char *LibExt : {".dylib", ".so", ".dll", ".a", ".lib"}) {
           SmallVector<char, 256> LibPath;
           LibPath.reserve(SearchPath.size() + strlen("lib") +
                           LL.LibName.size() + strlen(LibExt) +
                           2); // +2 for pathsep, null term.
           llvm::copy(SearchPath, std::back_inserter(LibPath));
           if (StringRef(LibExt) != ".lib" && StringRef(LibExt) != ".dll")
             sys::path::append(LibPath, "lib" + LL.LibName + LibExt);
auto TraverseSearchPathList =
             });
             continue;
           }
 
           // We identified the magic. Assume that we can load it -- we'll reset
           // in the default case.
           LibFound = true;
           switch (Magic) {
+          case file_magic::pecoff_executable:
           case file_magic::elf_shared_object:
           case file_magic::macho_dynamically_linked_shared_lib: {
             // TODO: On first reference to LibPath this should create a JITDylib
             // with a generator and add it to JD's links-against list. Subsquent
             // references should use the JITDylib created on the first
             // reference.
             auto G =
                 EPCDynamicLibrarySearchGenerator::Load(S.ES, LibPath.data());
auto TraverseSearchPathList =
             break;
           }
           if (LibFound)
             break;
         }
         if (LibFound)
           break;
       }
-    }
 
       if (!LibFound)
         return make_error<StringError>("While linking " + JD.getName() +
                                            ", could not find library for -l" +
                                            LL.LibName,
                                        inconvertibleErrorCode());
+      return Error::success();
+    };
+    if (auto Err = TraverseSearchPathList(JDSearchPaths[&JD]))
+      return Err;
+    if (auto Err = TraverseSearchPathList(SystemSearchPaths))
+      return Err;
   }
 
   return Error::success();
 }
 
 static Error addSessionInputs(Session &S) {
   std::map<unsigned, JITDylib *> IdxToJD;