Re-apply r337595 with fix for LLVM_ENABLE_THREADS=Off.

llvm-svn: 337626

llvm/include/llvm/ExecutionEngine/Orc/Core.h

@@ -69,8 +69,23 @@ raw_ostream &operator<<(raw_ostream &OS, const SymbolDependenceMap &Deps);
 /// A list of VSO pointers.
 using VSOList = std::vector<VSO *>;
 
+/// Render a VSOList.
 raw_ostream &operator<<(raw_ostream &OS, const VSOList &VSOs);
 
+/// Callback to notify client that symbols have been resolved.
+using SymbolsResolvedCallback = std::function<void(Expected<SymbolMap>)>;
+
+/// Callback to notify client that symbols are ready for execution.
+using SymbolsReadyCallback = std::function<void(Error)>;
+
+/// Callback to register the dependencies for a given query.
+using RegisterDependenciesFunction =
+    std::function<void(const SymbolDependenceMap &)>;
+
+/// This can be used as the value for a RegisterDependenciesFunction if there
+/// are no dependants to register with.
+extern RegisterDependenciesFunction NoDependenciesToRegister;
+
 /// Used to notify a VSO that the given set of symbols failed to materialize.
 class FailedToMaterialize : public ErrorInfo<FailedToMaterialize> {
 public:
@@ -122,6 +137,9 @@ public:
   ///        into.
   VSO &getTargetVSO() const { return V; }
 
+  /// Returns the symbol flags map for this responsibility instance.
+  SymbolFlagsMap getSymbols() { return SymbolFlags; }
+
   /// Returns the names of any symbols covered by this
   /// MaterializationResponsibility object that have queries pending. This
   /// information can be used to return responsibility for unrequested symbols
@@ -223,6 +241,9 @@ private:
   virtual void discard(const VSO &V, SymbolStringPtr Name) = 0;
 };
 
+using MaterializationUnitList =
+    std::vector<std::unique_ptr<MaterializationUnit>>;
+
 /// A MaterializationUnit implementation for pre-existing absolute symbols.
 ///
 /// All symbols will be resolved and marked ready as soon as the unit is
@@ -322,6 +343,9 @@ buildSimpleReexportsAliasMap(VSO &SourceV, const SymbolNameSet &Symbols);
 
 /// Base utilities for ExecutionSession.
 class ExecutionSessionBase {
+  // FIXME: Remove this when we remove the old ORC layers.
+  friend class VSO;
+
 public:
   /// For reporting errors.
   using ErrorReporter = std::function<void(Error)>;
@@ -372,11 +396,50 @@ public:
   void releaseVModule(VModuleKey Key) { /* FIXME: Recycle keys */
   }
 
-  /// Cause the given query to fail with the given Error.
+  void legacyFailQuery(AsynchronousSymbolQuery &Q, Error Err);
+
+  using LegacyAsyncLookupFunction = std::function<SymbolNameSet(
+      std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names)>;
+
+  /// A legacy lookup function for JITSymbolResolverAdapter.
+  /// Do not use -- this will be removed soon.
+  Expected<SymbolMap>
+  legacyLookup(ExecutionSessionBase &ES, LegacyAsyncLookupFunction AsyncLookup,
+               SymbolNameSet Names, bool WaiUntilReady,
+               RegisterDependenciesFunction RegisterDependencies);
+
+  /// Search the given VSO list for the given symbols.
   ///
-  /// This should only be used by legacy APIs and will be deprecated in the
+  ///
-  /// future.
+  /// The OnResolve callback will be called once all requested symbols are
-  void failQuery(AsynchronousSymbolQuery &Q, Error Err);
+  /// resolved, or if an error occurs prior to resolution.
+  ///
+  /// The OnReady callback will be called once all requested symbols are ready,
+  /// or if an error occurs after resolution but before all symbols are ready.
+  ///
+  /// If all symbols are found, the RegisterDependencies function will be called
+  /// while the session lock is held. This gives clients a chance to register
+  /// dependencies for on the queried symbols for any symbols they are
+  /// materializing (if a MaterializationResponsibility instance is present,
+  /// this can be implemented by calling
+  /// MaterializationResponsibility::addDependencies). If there are no
+  /// dependenant symbols for this query (e.g. it is being made by a top level
+  /// client to get an address to call) then the value NoDependenciesToRegister
+  /// can be used.
+  void lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,
+              SymbolsResolvedCallback OnResolve, SymbolsReadyCallback OnReady,
+              RegisterDependenciesFunction RegisterDependencies);
+
+  /// Blocking version of lookup above. Returns the resolved symbol map.
+  /// If WaitUntilReady is true (the default), will not return until all
+  /// requested symbols are ready (or an error occurs). If WaitUntilReady is
+  /// false, will return as soon as all requested symbols are resolved,
+  /// or an error occurs. If WaitUntilReady is false and an error occurs
+  /// after resolution, the function will return a success value, but the
+  /// error will be reported via reportErrors.
+  Expected<SymbolMap> lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,
+                             RegisterDependenciesFunction RegisterDependencies,
+                             bool WaitUntilReady = true);
 
   /// Materialize the given unit.
   void dispatchMaterialization(VSO &V,
@@ -394,12 +457,20 @@ private:
     MU->doMaterialize(V);
   }
 
+  void runOutstandingMUs();
+
   mutable std::recursive_mutex SessionMutex;
   std::shared_ptr<SymbolStringPool> SSP;
   VModuleKey LastKey = 0;
   ErrorReporter ReportError = logErrorsToStdErr;
   DispatchMaterializationFunction DispatchMaterialization =
       materializeOnCurrentThread;
+
+  // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
+  //        with callbacks from asynchronous queries.
+  mutable std::recursive_mutex OutstandingMUsMutex;
+  std::vector<std::pair<VSO *, std::unique_ptr<MaterializationUnit>>>
+      OutstandingMUs;
 };
 
 /// A symbol query that returns results via a callback when results are
@@ -411,21 +482,6 @@ class AsynchronousSymbolQuery {
   friend class VSO;
 
 public:
-  class ResolutionResult {
-  public:
-    ResolutionResult(SymbolMap Symbols, const SymbolDependenceMap &Dependencies)
-        : Symbols(std::move(Symbols)), Dependencies(Dependencies) {}
-
-    SymbolMap Symbols;
-    const SymbolDependenceMap &Dependencies;
-  };
-
-  /// Callback to notify client that symbols have been resolved.
-  using SymbolsResolvedCallback =
-      std::function<void(Expected<ResolutionResult>)>;
-
-  /// Callback to notify client that symbols are ready for execution.
-  using SymbolsReadyCallback = std::function<void(Error)>;
 
   /// Create a query for the given symbols, notify-resolved and
   ///        notify-ready callbacks.
@@ -485,6 +541,7 @@ private:
 class VSO {
   friend class AsynchronousSymbolQuery;
   friend class ExecutionSession;
+  friend class ExecutionSessionBase;
   friend class MaterializationResponsibility;
 public:
   using FallbackDefinitionGeneratorFunction =
@@ -493,9 +550,6 @@ public:
   using AsynchronousSymbolQuerySet =
       std::set<std::shared_ptr<AsynchronousSymbolQuery>>;
 
-  using MaterializationUnitList =
-      std::vector<std::unique_ptr<MaterializationUnit>>;
-
   VSO(const VSO &) = delete;
   VSO &operator=(const VSO &) = delete;
   VSO(VSO &&) = delete;
@@ -547,8 +601,10 @@ public:
   void removeFromSearchOrder(VSO &V);
 
   /// Do something with the search order (run under the session lock).
-  template <typename Func> void withSearchOrderDo(Func F) {
+  template <typename Func>
-    ES.runSessionLocked([&]() { F(SearchOrder); });
+  auto withSearchOrderDo(Func &&F)
+      -> decltype(F(std::declval<const VSOList &>())) {
+    return ES.runSessionLocked([&]() { return F(SearchOrder); });
   }
 
   /// Define all symbols provided by the materialization unit to be part
@@ -579,6 +635,10 @@ public:
   ///        the flags for each symbol in Flags. Returns any unresolved symbols.
   SymbolFlagsMap lookupFlags(const SymbolNameSet &Names);
 
+  /// Dump current VSO state to OS.
+  void dump(raw_ostream &OS);
+
+  /// FIXME: Remove this when we remove the old ORC layers.
   /// Search the given VSOs in order for the symbols in Symbols. Results
   ///        (once they become available) will be returned via the given Query.
   ///
@@ -586,11 +646,8 @@ public:
   /// and the query will not be applied. The Query is not failed and can be
   /// re-used in a subsequent lookup once the symbols have been added, or
   /// manually failed.
-  SymbolNameSet lookup(std::shared_ptr<AsynchronousSymbolQuery> Q,
+  SymbolNameSet legacyLookup(std::shared_ptr<AsynchronousSymbolQuery> Q,
-                       SymbolNameSet Names);
+                             SymbolNameSet Names);
-
-  /// Dump current VSO state to OS.
-  void dump(raw_ostream &OS);
 
 private:
   using AsynchronousSymbolQueryList =
@@ -629,6 +686,12 @@ private:
   SymbolNameSet lookupFlagsImpl(SymbolFlagsMap &Flags,
                                 const SymbolNameSet &Names);
 
+  void lodgeQuery(std::shared_ptr<AsynchronousSymbolQuery> &Q,
+                  SymbolNameSet &Unresolved, MaterializationUnitList &MUs);
+
+  void lodgeQueryImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,
+                      SymbolNameSet &Unresolved, MaterializationUnitList &MUs);
+
   LookupImplActionFlags
   lookupImpl(std::shared_ptr<AsynchronousSymbolQuery> &Q,
              std::vector<std::unique_ptr<MaterializationUnit>> &MUs,
@@ -647,8 +710,8 @@ private:
 
   SymbolNameSet getRequestedSymbols(const SymbolFlagsMap &SymbolFlags);
 
-  void addDependencies(const SymbolFlagsMap &Dependents,
+  void addDependencies(const SymbolStringPtr &Name,
-                       const SymbolDependenceMap &Dependencies);
+                       const SymbolDependenceMap &Dependants);
 
   void resolve(const SymbolMap &Resolved);
 
@@ -656,8 +719,6 @@ private:
 
   void notifyFailed(const SymbolNameSet &FailedSymbols);
 
-  void runOutstandingMUs();
-
   ExecutionSessionBase &ES;
   std::string VSOName;
   SymbolMap Symbols;
@@ -665,11 +726,6 @@ private:
   MaterializingInfosMap MaterializingInfos;
   FallbackDefinitionGeneratorFunction FallbackDefinitionGenerator;
   VSOList SearchOrder;
-
-  // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
-  //        with callbacks from asynchronous queries.
-  mutable std::recursive_mutex OutstandingMUsMutex;
-  std::vector<std::unique_ptr<MaterializationUnit>> OutstandingMUs;
 };
 
 /// An ExecutionSession represents a running JIT program.
@@ -693,15 +749,6 @@ private:
   std::vector<std::unique_ptr<VSO>> VSOs;
 };
 
-using AsynchronousLookupFunction = std::function<SymbolNameSet(
-    std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Names)>;
-
-/// Perform a blocking lookup on the given symbols.
-Expected<SymbolMap> blockingLookup(ExecutionSessionBase &ES,
-                                   AsynchronousLookupFunction AsyncLookup,
-                                   SymbolNameSet Names, bool WaiUntilReady,
-                                   MaterializationResponsibility *MR = nullptr);
-
 /// Look up the given names in the given VSOs.
 /// VSOs will be searched in order and no VSO pointer may be null.
 /// All symbols must be found within the given VSOs or an error

llvm/include/llvm/ExecutionEngine/Orc/Legacy.h

@@ -146,11 +146,11 @@ lookupWithLegacyFn(ExecutionSession &ES, AsynchronousSymbolQuery &Query,
         Query.notifySymbolReady();
         NewSymbolsResolved = true;
       } else {
-        ES.failQuery(Query, Addr.takeError());
+        ES.legacyFailQuery(Query, Addr.takeError());
         return SymbolNameSet();
       }
     } else if (auto Err = Sym.takeError()) {
-      ES.failQuery(Query, std::move(Err));
+      ES.legacyFailQuery(Query, std::move(Err));
       return SymbolNameSet();
     } else
       SymbolsNotFound.insert(S);

llvm/lib/ExecutionEngine/Orc/Core.cpp

@@ -23,6 +23,9 @@ namespace orc {
 char FailedToMaterialize::ID = 0;
 char SymbolsNotFound::ID = 0;
 
+RegisterDependenciesFunction NoDependenciesToRegister =
+    RegisterDependenciesFunction();
+
 void MaterializationUnit::anchor() {}
 
 raw_ostream &operator<<(raw_ostream &OS, const JITSymbolFlags &Flags) {
@@ -138,20 +141,361 @@ void SymbolsNotFound::log(raw_ostream &OS) const {
   OS << "Symbols not found: " << Symbols;
 }
 
-void ExecutionSessionBase::failQuery(AsynchronousSymbolQuery &Q, Error Err) {
+void ExecutionSessionBase::legacyFailQuery(AsynchronousSymbolQuery &Q,
-  bool DeliveredError = true;
+                                           Error Err) {
-  runSessionLocked([&]() -> void {
+  assert(!!Err && "Error should be in failure state");
+
+  bool SendErrorToQuery;
+  runSessionLocked([&]() {
     Q.detach();
-    if (Q.canStillFail())
+    SendErrorToQuery = Q.canStillFail();
-      Q.handleFailed(std::move(Err));
-    else
-      DeliveredError = false;
   });
 
-  if (!DeliveredError)
+  if (SendErrorToQuery)
+    Q.handleFailed(std::move(Err));
+  else
     reportError(std::move(Err));
 }
 
+Expected<SymbolMap> ExecutionSessionBase::legacyLookup(
+    ExecutionSessionBase &ES, LegacyAsyncLookupFunction AsyncLookup,
+    SymbolNameSet Names, bool WaitUntilReady,
+    RegisterDependenciesFunction RegisterDependencies) {
+#if LLVM_ENABLE_THREADS
+  // In the threaded case we use promises to return the results.
+  std::promise<SymbolMap> PromisedResult;
+  std::mutex ErrMutex;
+  Error ResolutionError = Error::success();
+  std::promise<void> PromisedReady;
+  Error ReadyError = Error::success();
+  auto OnResolve = [&](Expected<SymbolMap> R) {
+    if (R)
+      PromisedResult.set_value(std::move(*R));
+    else {
+      {
+        ErrorAsOutParameter _(&ResolutionError);
+        std::lock_guard<std::mutex> Lock(ErrMutex);
+        ResolutionError = R.takeError();
+      }
+      PromisedResult.set_value(SymbolMap());
+    }
+  };
+
+  std::function<void(Error)> OnReady;
+  if (WaitUntilReady) {
+    OnReady = [&](Error Err) {
+      if (Err) {
+        ErrorAsOutParameter _(&ReadyError);
+        std::lock_guard<std::mutex> Lock(ErrMutex);
+        ReadyError = std::move(Err);
+      }
+      PromisedReady.set_value();
+    };
+  } else {
+    OnReady = [&](Error Err) {
+      if (Err)
+        ES.reportError(std::move(Err));
+    };
+  }
+
+#else
+  SymbolMap Result;
+  Error ResolutionError = Error::success();
+  Error ReadyError = Error::success();
+
+  auto OnResolve = [&](Expected<SymbolMap> R) {
+    ErrorAsOutParameter _(&ResolutionError);
+    if (R)
+      Result = std::move(*R);
+    else
+      ResolutionError = R.takeError();
+  };
+
+  std::function<void(Error)> OnReady;
+  if (WaitUntilReady) {
+    OnReady = [&](Error Err) {
+      ErrorAsOutParameter _(&ReadyError);
+      if (Err)
+        ReadyError = std::move(Err);
+    };
+  } else {
+    OnReady = [&](Error Err) {
+      if (Err)
+        ES.reportError(std::move(Err));
+    };
+  }
+#endif
+
+  auto Query = std::make_shared<AsynchronousSymbolQuery>(
+      Names, std::move(OnResolve), std::move(OnReady));
+  // FIXME: This should be run session locked along with the registration code
+  // and error reporting below.
+  SymbolNameSet UnresolvedSymbols = AsyncLookup(Query, std::move(Names));
+
+  // If the query was lodged successfully then register the dependencies,
+  // otherwise fail it with an error.
+  if (UnresolvedSymbols.empty())
+    RegisterDependencies(Query->QueryRegistrations);
+  else {
+    bool DeliverError = runSessionLocked([&]() {
+      Query->detach();
+      return Query->canStillFail();
+    });
+    auto Err = make_error<SymbolsNotFound>(std::move(UnresolvedSymbols));
+    if (DeliverError)
+      Query->handleFailed(std::move(Err));
+    else
+      ES.reportError(std::move(Err));
+  }
+
+#if LLVM_ENABLE_THREADS
+  auto ResultFuture = PromisedResult.get_future();
+  auto Result = ResultFuture.get();
+
+  {
+    std::lock_guard<std::mutex> Lock(ErrMutex);
+    if (ResolutionError) {
+      // ReadyError will never be assigned. Consume the success value.
+      cantFail(std::move(ReadyError));
+      return std::move(ResolutionError);
+    }
+  }
+
+  if (WaitUntilReady) {
+    auto ReadyFuture = PromisedReady.get_future();
+    ReadyFuture.get();
+
+    {
+      std::lock_guard<std::mutex> Lock(ErrMutex);
+      if (ReadyError)
+        return std::move(ReadyError);
+    }
+  } else
+    cantFail(std::move(ReadyError));
+
+  return std::move(Result);
+
+#else
+  if (ResolutionError) {
+    // ReadyError will never be assigned. Consume the success value.
+    cantFail(std::move(ReadyError));
+    return std::move(ResolutionError);
+  }
+
+  if (ReadyError)
+    return std::move(ReadyError);
+
+  return Result;
+#endif
+}
+
+void ExecutionSessionBase::lookup(
+    const VSOList &VSOs, const SymbolNameSet &Symbols,
+    SymbolsResolvedCallback OnResolve, SymbolsReadyCallback OnReady,
+    RegisterDependenciesFunction RegisterDependencies) {
+
+  // lookup can be re-entered recursively if running on a single thread. Run any
+  // outstanding MUs in case this query depends on them, otherwise the main
+  // thread will starve waiting for a result from an MU that it failed to run.
+  runOutstandingMUs();
+
+  auto Unresolved = std::move(Symbols);
+  std::map<VSO *, MaterializationUnitList> MUsMap;
+  auto Q = std::make_shared<AsynchronousSymbolQuery>(
+      Symbols, std::move(OnResolve), std::move(OnReady));
+  bool QueryIsFullyResolved = false;
+  bool QueryIsFullyReady = false;
+  bool QueryFailed = false;
+
+  runSessionLocked([&]() {
+    for (auto *V : VSOs) {
+      assert(V && "VSOList entries must not be null");
+      assert(!MUsMap.count(V) &&
+             "VSOList should not contain duplicate entries");
+      V->lodgeQuery(Q, Unresolved, MUsMap[V]);
+    }
+
+    if (Unresolved.empty()) {
+      // Query lodged successfully.
+
+      // Record whether this query is fully ready / resolved. We will use
+      // this to call handleFullyResolved/handleFullyReady outside the session
+      // lock.
+      QueryIsFullyResolved = Q->isFullyResolved();
+      QueryIsFullyReady = Q->isFullyReady();
+
+      // Call the register dependencies function.
+      if (RegisterDependencies && !Q->QueryRegistrations.empty())
+        RegisterDependencies(Q->QueryRegistrations);
+    } else {
+      // Query failed due to unresolved symbols.
+      QueryFailed = true;
+
+      // Disconnect the query from its dependencies.
+      Q->detach();
+
+      // Replace the MUs.
+      for (auto &KV : MUsMap)
+        for (auto &MU : KV.second)
+          KV.first->replace(std::move(MU));
+    }
+  });
+
+  if (QueryFailed) {
+    Q->handleFailed(make_error<SymbolsNotFound>(std::move(Unresolved)));
+    return;
+  } else {
+    if (QueryIsFullyResolved)
+      Q->handleFullyResolved();
+    if (QueryIsFullyReady)
+      Q->handleFullyReady();
+  }
+
+  // Move the MUs to the OutstandingMUs list, then materialize.
+  {
+    std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
+
+    for (auto &KV : MUsMap)
+      for (auto &MU : KV.second)
+        OutstandingMUs.push_back(std::make_pair(KV.first, std::move(MU)));
+  }
+
+  runOutstandingMUs();
+}
+
+Expected<SymbolMap>
+ExecutionSessionBase::lookup(const VSOList &VSOs, const SymbolNameSet &Symbols,
+                             RegisterDependenciesFunction RegisterDependencies,
+                             bool WaitUntilReady) {
+#if LLVM_ENABLE_THREADS
+  // In the threaded case we use promises to return the results.
+  std::promise<SymbolMap> PromisedResult;
+  std::mutex ErrMutex;
+  Error ResolutionError = Error::success();
+  std::promise<void> PromisedReady;
+  Error ReadyError = Error::success();
+  auto OnResolve = [&](Expected<SymbolMap> R) {
+    if (R)
+      PromisedResult.set_value(std::move(*R));
+    else {
+      {
+        ErrorAsOutParameter _(&ResolutionError);
+        std::lock_guard<std::mutex> Lock(ErrMutex);
+        ResolutionError = R.takeError();
+      }
+      PromisedResult.set_value(SymbolMap());
+    }
+  };
+
+  std::function<void(Error)> OnReady;
+  if (WaitUntilReady) {
+    OnReady = [&](Error Err) {
+      if (Err) {
+        ErrorAsOutParameter _(&ReadyError);
+        std::lock_guard<std::mutex> Lock(ErrMutex);
+        ReadyError = std::move(Err);
+      }
+      PromisedReady.set_value();
+    };
+  } else {
+    OnReady = [&](Error Err) {
+      if (Err)
+        reportError(std::move(Err));
+    };
+  }
+
+#else
+  SymbolMap Result;
+  Error ResolutionError = Error::success();
+  Error ReadyError = Error::success();
+
+  auto OnResolve = [&](Expected<SymbolMap> R) {
+    ErrorAsOutParameter _(&ResolutionError);
+    if (R)
+      Result = std::move(*R);
+    else
+      ResolutionError = R.takeError();
+  };
+
+  std::function<void(Error)> OnReady;
+  if (WaitUntilReady) {
+    OnReady = [&](Error Err) {
+      ErrorAsOutParameter _(&ReadyError);
+      if (Err)
+        ReadyError = std::move(Err);
+    };
+  } else {
+    OnReady = [&](Error Err) {
+      if (Err)
+        reportError(std::move(Err));
+    };
+  }
+#endif
+
+  // Perform the asynchronous lookup.
+  lookup(VSOs, Symbols, OnResolve, OnReady, RegisterDependencies);
+
+#if LLVM_ENABLE_THREADS
+  auto ResultFuture = PromisedResult.get_future();
+  auto Result = ResultFuture.get();
+
+  {
+    std::lock_guard<std::mutex> Lock(ErrMutex);
+    if (ResolutionError) {
+      // ReadyError will never be assigned. Consume the success value.
+      cantFail(std::move(ReadyError));
+      return std::move(ResolutionError);
+    }
+  }
+
+  if (WaitUntilReady) {
+    auto ReadyFuture = PromisedReady.get_future();
+    ReadyFuture.get();
+
+    {
+      std::lock_guard<std::mutex> Lock(ErrMutex);
+      if (ReadyError)
+        return std::move(ReadyError);
+    }
+  } else
+    cantFail(std::move(ReadyError));
+
+  return std::move(Result);
+
+#else
+  if (ResolutionError) {
+    // ReadyError will never be assigned. Consume the success value.
+    cantFail(std::move(ReadyError));
+    return std::move(ResolutionError);
+  }
+
+  if (ReadyError)
+    return std::move(ReadyError);
+
+  return Result;
+#endif
+}
+
+void ExecutionSessionBase::runOutstandingMUs() {
+  while (1) {
+    std::pair<VSO *, std::unique_ptr<MaterializationUnit>> VSOAndMU;
+
+    {
+      std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
+      if (!OutstandingMUs.empty()) {
+        VSOAndMU = std::move(OutstandingMUs.back());
+        OutstandingMUs.pop_back();
+      }
+    }
+
+    if (VSOAndMU.first) {
+      assert(VSOAndMU.second && "VSO, but no MU?");
+      dispatchMaterialization(*VSOAndMU.first, std::move(VSOAndMU.second));
+    } else
+      break;
+  }
+}
+
 AsynchronousSymbolQuery::AsynchronousSymbolQuery(
     const SymbolNameSet &Symbols, SymbolsResolvedCallback NotifySymbolsResolved,
     SymbolsReadyCallback NotifySymbolsReady)
@@ -161,12 +505,6 @@ AsynchronousSymbolQuery::AsynchronousSymbolQuery(
 
   for (auto &S : Symbols)
     ResolvedSymbols[S] = nullptr;
-
-  // If the query is empty it is trivially resolved/ready.
-  if (Symbols.empty()) {
-    handleFullyResolved();
-    handleFullyReady();
-  }
 }
 
 void AsynchronousSymbolQuery::resolve(const SymbolStringPtr &Name,
@@ -183,8 +521,7 @@ void AsynchronousSymbolQuery::handleFullyResolved() {
   assert(NotYetResolvedCount == 0 && "Not fully resolved?");
   assert(NotifySymbolsResolved &&
          "NotifySymbolsResolved already called or error occurred");
-  NotifySymbolsResolved(
+  NotifySymbolsResolved(std::move(ResolvedSymbols));
-      ResolutionResult(std::move(ResolvedSymbols), QueryRegistrations));
   NotifySymbolsResolved = SymbolsResolvedCallback();
 }
 
@@ -349,7 +686,8 @@ MaterializationResponsibility::delegate(const SymbolNameSet &Symbols) {
 
 void MaterializationResponsibility::addDependencies(
     const SymbolDependenceMap &Dependencies) {
-  V.addDependencies(SymbolFlags, Dependencies);
+  for (auto &KV : SymbolFlags)
+    V.addDependencies(KV.first, Dependencies);
 }
 
 AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit(
@@ -384,8 +722,9 @@ ReExportsMaterializationUnit::ReExportsMaterializationUnit(
 void ReExportsMaterializationUnit::materialize(
     MaterializationResponsibility R) {
 
-  VSO &SrcV = SourceVSO ? *SourceVSO : R.getTargetVSO();
+  auto &ES = R.getTargetVSO().getExecutionSession();
-  auto &ES = SrcV.getExecutionSession();
+  VSO &TgtV = R.getTargetVSO();
+  VSO &SrcV = SourceVSO ? *SourceVSO : TgtV;
 
   // Find the set of requested aliases and aliasees. Return any unrequested
   // aliases back to the VSO so as to not prematurely materialize any aliasees.
@@ -434,9 +773,8 @@ void ReExportsMaterializationUnit::materialize(
       auto Tmp = I++;
 
       // Chain detected. Skip this symbol for this round.
-      if (&SrcV == &R.getTargetVSO() &&
+      if (&SrcV == &TgtV && (QueryAliases.count(Tmp->second.Aliasee) ||
-          (QueryAliases.count(Tmp->second.Aliasee) ||
+                             RequestedAliases.count(Tmp->second.Aliasee)))
-           RequestedAliases.count(Tmp->second.Aliasee)))
         continue;
 
       ResponsibilitySymbols.insert(Tmp->first);
@@ -459,49 +797,32 @@ void ReExportsMaterializationUnit::materialize(
 
     QueryInfos.pop_back();
 
-    auto OnResolve =
+    auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
-        [QueryInfo,
+      R.addDependencies(Deps);
-         &SrcV](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+    };
-          if (RR) {
-            SymbolMap ResolutionMap;
-            SymbolNameSet Resolved;
-            for (auto &KV : QueryInfo->Aliases) {
-              assert(RR->Symbols.count(KV.second.Aliasee) &&
-                     "Result map missing entry?");
-              ResolutionMap[KV.first] = JITEvaluatedSymbol(
-                  RR->Symbols[KV.second.Aliasee].getAddress(),
-                  KV.second.AliasFlags);
 
-              // FIXME: We're creating a SymbolFlagsMap and a std::map of
+    auto OnResolve = [QueryInfo](Expected<SymbolMap> Result) {
-              // std::sets just to add one dependency here. This needs a
+      if (Result) {
-              // re-think.
+        SymbolMap ResolutionMap;
-              Resolved.insert(KV.first);
+        for (auto &KV : QueryInfo->Aliases) {
-            }
+          assert(Result->count(KV.second.Aliasee) &&
-            QueryInfo->R.resolve(ResolutionMap);
+                 "Result map missing entry?");
-
+          ResolutionMap[KV.first] = JITEvaluatedSymbol(
-            SymbolDependenceMap Deps;
+              (*Result)[KV.second.Aliasee].getAddress(), KV.second.AliasFlags);
-            Deps[&SrcV] = std::move(Resolved);
+        }
-            QueryInfo->R.addDependencies(Deps);
+        QueryInfo->R.resolve(ResolutionMap);
-
+        QueryInfo->R.finalize();
-            QueryInfo->R.finalize();
+      } else {
-          } else {
+        auto &ES = QueryInfo->R.getTargetVSO().getExecutionSession();
-            auto &ES = QueryInfo->R.getTargetVSO().getExecutionSession();
+        ES.reportError(Result.takeError());
-            ES.reportError(RR.takeError());
+        QueryInfo->R.failMaterialization();
-            QueryInfo->R.failMaterialization();
+      }
-          }
+    };
-        };
 
     auto OnReady = [&ES](Error Err) { ES.reportError(std::move(Err)); };
 
-    auto Q = std::make_shared<AsynchronousSymbolQuery>(
+    ES.lookup({&SrcV}, QuerySymbols, std::move(OnResolve), std::move(OnReady),
-        QuerySymbols, std::move(OnResolve), std::move(OnReady));
+              std::move(RegisterDependencies));
-
-    auto Unresolved = SrcV.lookup(Q, std::move(QuerySymbols));
-
-    if (!Unresolved.empty()) {
-      ES.failQuery(*Q, make_error<SymbolsNotFound>(std::move(Unresolved)));
-      return;
-    }
   }
 }
 
@@ -642,40 +963,35 @@ SymbolNameSet VSO::getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) {
   });
 }
 
-void VSO::addDependencies(const SymbolFlagsMap &Dependants,
+void VSO::addDependencies(const SymbolStringPtr &Name,
                           const SymbolDependenceMap &Dependencies) {
-  ES.runSessionLocked([&, this]() {
+  assert(Symbols.count(Name) && "Name not in symbol table");
-    for (auto &KV : Dependants) {
+  assert((Symbols[Name].getFlags().isLazy() ||
-      const auto &Name = KV.first;
+          Symbols[Name].getFlags().isMaterializing()) &&
-      assert(Symbols.count(Name) && "Name not in symbol table");
+         "Symbol is not lazy or materializing");
-      assert((Symbols[Name].getFlags().isLazy() ||
-              Symbols[Name].getFlags().isMaterializing()) &&
-             "Symbol is not lazy or materializing");
 
-      auto &MI = MaterializingInfos[Name];
+  auto &MI = MaterializingInfos[Name];
-      assert(!MI.IsFinalized && "Can not add dependencies to finalized symbol");
+  assert(!MI.IsFinalized && "Can not add dependencies to finalized symbol");
 
-      for (auto &KV : Dependencies) {
+  for (auto &KV : Dependencies) {
-        assert(KV.first && "Null VSO in dependency?");
+    assert(KV.first && "Null VSO in dependency?");
-        auto &OtherVSO = *KV.first;
+    auto &OtherVSO = *KV.first;
-        auto &DepsOnOtherVSO = MI.UnfinalizedDependencies[&OtherVSO];
+    auto &DepsOnOtherVSO = MI.UnfinalizedDependencies[&OtherVSO];
 
-        for (auto &OtherSymbol : KV.second) {
+    for (auto &OtherSymbol : KV.second) {
-          auto &OtherMI = OtherVSO.MaterializingInfos[OtherSymbol];
+      auto &OtherMI = OtherVSO.MaterializingInfos[OtherSymbol];
 
-          if (OtherMI.IsFinalized)
+      if (OtherMI.IsFinalized)
-            transferFinalizedNodeDependencies(MI, Name, OtherMI);
+        transferFinalizedNodeDependencies(MI, Name, OtherMI);
-          else if (&OtherVSO != this || OtherSymbol != Name) {
+      else if (&OtherVSO != this || OtherSymbol != Name) {
-            OtherMI.Dependants[this].insert(Name);
+        OtherMI.Dependants[this].insert(Name);
-            DepsOnOtherVSO.insert(OtherSymbol);
+        DepsOnOtherVSO.insert(OtherSymbol);
-          }
-        }
-
-        if (DepsOnOtherVSO.empty())
-          MI.UnfinalizedDependencies.erase(&OtherVSO);
       }
     }
-  });
+
+    if (DepsOnOtherVSO.empty())
+      MI.UnfinalizedDependencies.erase(&OtherVSO);
+  }
 }
 
 void VSO::resolve(const SymbolMap &Resolved) {
@@ -856,25 +1172,6 @@ void VSO::notifyFailed(const SymbolNameSet &FailedSymbols) {
     Q->handleFailed(make_error<FailedToMaterialize>(FailedSymbols));
 }
 
-void VSO::runOutstandingMUs() {
-  while (1) {
-    std::unique_ptr<MaterializationUnit> MU;
-
-    {
-      std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
-      if (!OutstandingMUs.empty()) {
-        MU = std::move(OutstandingMUs.back());
-        OutstandingMUs.pop_back();
-      }
-    }
-
-    if (MU)
-      ES.dispatchMaterialization(*this, std::move(MU));
-    else
-      break;
-  }
-}
-
 void VSO::setSearchOrder(VSOList NewSearchOrder, bool SearchThisVSOFirst) {
   if (SearchThisVSOFirst && NewSearchOrder.front() != this)
     NewSearchOrder.insert(NewSearchOrder.begin(), this);
@@ -939,11 +1236,89 @@ SymbolNameSet VSO::lookupFlagsImpl(SymbolFlagsMap &Flags,
   return Unresolved;
 }
 
-SymbolNameSet VSO::lookup(std::shared_ptr<AsynchronousSymbolQuery> Q,
+void VSO::lodgeQuery(std::shared_ptr<AsynchronousSymbolQuery> &Q,
-                          SymbolNameSet Names) {
+                     SymbolNameSet &Unresolved, MaterializationUnitList &MUs) {
   assert(Q && "Query can not be null");
 
-  runOutstandingMUs();
+  lodgeQueryImpl(Q, Unresolved, MUs);
+  if (FallbackDefinitionGenerator && !Unresolved.empty()) {
+    auto FallbackDefs = FallbackDefinitionGenerator(*this, Unresolved);
+    if (!FallbackDefs.empty()) {
+      for (auto &D : FallbackDefs)
+        Unresolved.erase(D);
+      lodgeQueryImpl(Q, FallbackDefs, MUs);
+      assert(FallbackDefs.empty() &&
+             "All fallback defs should have been found by lookupImpl");
+    }
+  }
+}
+
+void VSO::lodgeQueryImpl(
+    std::shared_ptr<AsynchronousSymbolQuery> &Q, SymbolNameSet &Unresolved,
+    std::vector<std::unique_ptr<MaterializationUnit>> &MUs) {
+  for (auto I = Unresolved.begin(), E = Unresolved.end(); I != E;) {
+    auto TmpI = I++;
+    auto Name = *TmpI;
+
+    // Search for the name in Symbols. Skip it if not found.
+    auto SymI = Symbols.find(Name);
+    if (SymI == Symbols.end())
+      continue;
+
+    // If we found Name in V, remove it frome the Unresolved set and add it
+    // to the added set.
+    Unresolved.erase(TmpI);
+
+    // If the symbol has an address then resolve it.
+    if (SymI->second.getAddress() != 0)
+      Q->resolve(Name, SymI->second);
+
+    // If the symbol is lazy, get the MaterialiaztionUnit for it.
+    if (SymI->second.getFlags().isLazy()) {
+      assert(SymI->second.getAddress() == 0 &&
+             "Lazy symbol should not have a resolved address");
+      assert(!SymI->second.getFlags().isMaterializing() &&
+             "Materializing and lazy should not both be set");
+      auto UMII = UnmaterializedInfos.find(Name);
+      assert(UMII != UnmaterializedInfos.end() &&
+             "Lazy symbol should have UnmaterializedInfo");
+      auto MU = std::move(UMII->second->MU);
+      assert(MU != nullptr && "Materializer should not be null");
+
+      // Move all symbols associated with this MaterializationUnit into
+      // materializing state.
+      for (auto &KV : MU->getSymbols()) {
+        auto SymK = Symbols.find(KV.first);
+        auto Flags = SymK->second.getFlags();
+        Flags &= ~JITSymbolFlags::Lazy;
+        Flags |= JITSymbolFlags::Materializing;
+        SymK->second.setFlags(Flags);
+        UnmaterializedInfos.erase(KV.first);
+      }
+
+      // Add MU to the list of MaterializationUnits to be materialized.
+      MUs.push_back(std::move(MU));
+    } else if (!SymI->second.getFlags().isMaterializing()) {
+      // The symbol is neither lazy nor materializing. Finalize it and
+      // continue.
+      Q->notifySymbolReady();
+      continue;
+    }
+
+    // Add the query to the PendingQueries list.
+    assert(SymI->second.getFlags().isMaterializing() &&
+           "By this line the symbol should be materializing");
+    auto &MI = MaterializingInfos[Name];
+    MI.PendingQueries.push_back(Q);
+    Q->addQueryDependence(*this, Name);
+  }
+}
+
+SymbolNameSet VSO::legacyLookup(std::shared_ptr<AsynchronousSymbolQuery> Q,
+                                SymbolNameSet Names) {
+  assert(Q && "Query can not be null");
+
+  ES.runOutstandingMUs();
 
   LookupImplActionFlags ActionFlags = None;
   std::vector<std::unique_ptr<MaterializationUnit>> MUs;
@@ -978,11 +1353,11 @@ SymbolNameSet VSO::lookup(std::shared_ptr<AsynchronousSymbolQuery> Q,
   //        callbacks from asynchronous queries.
   // Add MUs to the OutstandingMUs list.
   {
-    std::lock_guard<std::recursive_mutex> Lock(OutstandingMUsMutex);
+    std::lock_guard<std::recursive_mutex> Lock(ES.OutstandingMUsMutex);
     for (auto &MU : MUs)
-      OutstandingMUs.push_back(std::move(MU));
+      ES.OutstandingMUs.push_back(make_pair(this, std::move(MU)));
   }
-  runOutstandingMUs();
+  ES.runOutstandingMUs();
 
   // Dispatch any required MaterializationUnits for materialization.
   // for (auto &MU : MUs)
@@ -1243,133 +1618,6 @@ VSO &ExecutionSession::createVSO(std::string Name) {
   });
 }
 
-Expected<SymbolMap> blockingLookup(ExecutionSessionBase &ES,
-                                   AsynchronousLookupFunction AsyncLookup,
-                                   SymbolNameSet Names, bool WaitUntilReady,
-                                   MaterializationResponsibility *MR) {
-
-#if LLVM_ENABLE_THREADS
-  // In the threaded case we use promises to return the results.
-  std::promise<SymbolMap> PromisedResult;
-  std::mutex ErrMutex;
-  Error ResolutionError = Error::success();
-  std::promise<void> PromisedReady;
-  Error ReadyError = Error::success();
-  auto OnResolve =
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
-        if (Result) {
-          if (MR)
-            MR->addDependencies(Result->Dependencies);
-          PromisedResult.set_value(std::move(Result->Symbols));
-        } else {
-          {
-            ErrorAsOutParameter _(&ResolutionError);
-            std::lock_guard<std::mutex> Lock(ErrMutex);
-            ResolutionError = Result.takeError();
-          }
-          PromisedResult.set_value(SymbolMap());
-        }
-      };
-
-  std::function<void(Error)> OnReady;
-  if (WaitUntilReady) {
-    OnReady = [&](Error Err) {
-      if (Err) {
-        ErrorAsOutParameter _(&ReadyError);
-        std::lock_guard<std::mutex> Lock(ErrMutex);
-        ReadyError = std::move(Err);
-      }
-      PromisedReady.set_value();
-    };
-  } else {
-    OnReady = [&](Error Err) {
-      if (Err)
-        ES.reportError(std::move(Err));
-    };
-  }
-
-#else
-  SymbolMap Result;
-  Error ResolutionError = Error::success();
-  Error ReadyError = Error::success();
-
-  auto OnResolve = [&](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
-    ErrorAsOutParameter _(&ResolutionError);
-    if (R) {
-      if (MR)
-        MR->addDependencies(R->Dependencies);
-      Result = std::move(R->Symbols);
-    } else
-      ResolutionError = R.takeError();
-  };
-
-  std::function<void(Error)> OnReady;
-  if (WaitUntilReady) {
-    OnReady = [&](Error Err) {
-      ErrorAsOutParameter _(&ReadyError);
-      if (Err)
-        ReadyError = std::move(Err);
-    };
-  } else {
-    OnReady = [&](Error Err) {
-      if (Err)
-        ES.reportError(std::move(Err));
-    };
-  }
-#endif
-
-  auto Query = std::make_shared<AsynchronousSymbolQuery>(
-      Names, std::move(OnResolve), std::move(OnReady));
-
-  SymbolNameSet UnresolvedSymbols = AsyncLookup(Query, std::move(Names));
-
-  // If there are unresolved symbols then the query will never return.
-  // Fail it with ES.failQuery.
-  if (!UnresolvedSymbols.empty())
-    ES.failQuery(*Query,
-                 make_error<SymbolsNotFound>(std::move(UnresolvedSymbols)));
-
-#if LLVM_ENABLE_THREADS
-  auto ResultFuture = PromisedResult.get_future();
-  auto Result = ResultFuture.get();
-
-  {
-    std::lock_guard<std::mutex> Lock(ErrMutex);
-    if (ResolutionError) {
-      // ReadyError will never be assigned. Consume the success value.
-      cantFail(std::move(ReadyError));
-      return std::move(ResolutionError);
-    }
-  }
-
-  if (WaitUntilReady) {
-    auto ReadyFuture = PromisedReady.get_future();
-    ReadyFuture.get();
-
-    {
-      std::lock_guard<std::mutex> Lock(ErrMutex);
-      if (ReadyError)
-        return std::move(ReadyError);
-    }
-  } else
-    cantFail(std::move(ReadyError));
-
-  return std::move(Result);
-
-#else
-  if (ResolutionError) {
-    // ReadyError will never be assigned. Consume the success value.
-    cantFail(std::move(ReadyError));
-    return std::move(ResolutionError);
-  }
-
-  if (ReadyError)
-    return std::move(ReadyError);
-
-  return Result;
-#endif
-}
-
 Expected<SymbolMap> lookup(const VSOList &VSOs, SymbolNameSet Names) {
 
   if (VSOs.empty())
@@ -1377,18 +1625,7 @@ Expected<SymbolMap> lookup(const VSOList &VSOs, SymbolNameSet Names) {
 
   auto &ES = (*VSOs.begin())->getExecutionSession();
 
-  auto LookupFn = [&](std::shared_ptr<AsynchronousSymbolQuery> Q,
+  return ES.lookup(VSOs, Names, NoDependenciesToRegister, true);
-                      SymbolNameSet Unresolved) {
-    for (auto *V : VSOs) {
-      assert(V && "VSOs entries must not be null");
-      if (Unresolved.empty())
-        break;
-      Unresolved = V->lookup(Q, std::move(Unresolved));
-    }
-    return Unresolved;
-  };
-
-  return blockingLookup(ES, std::move(LookupFn), Names, true);
 }
 
 /// Look up a symbol by searching a list of VSOs.

llvm/lib/ExecutionEngine/Orc/Legacy.cpp

@@ -29,8 +29,14 @@ JITSymbolResolverAdapter::lookup(const LookupSet &Symbols) {
     return R.lookup(std::move(Q), std::move(Unresolved));
   };
 
-  auto InternedResult = blockingLookup(ES, std::move(LookupFn),
+  auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
-                                       std::move(InternedSymbols), false, MR);
+    if (MR)
+      MR->addDependencies(Deps);
+  };
+
+  auto InternedResult =
+      ES.legacyLookup(ES, std::move(LookupFn), std::move(InternedSymbols),
+                      false, RegisterDependencies);
 
   if (!InternedResult)
     return InternedResult.takeError();

llvm/lib/ExecutionEngine/Orc/OrcCBindingsStack.h

@@ -156,11 +156,11 @@ private:
             Query->resolve(S, JITEvaluatedSymbol(*Addr, Sym.getFlags()));
             Query->notifySymbolReady();
           } else {
-            Stack.ES.failQuery(*Query, Addr.takeError());
+            Stack.ES.legacyFailQuery(*Query, Addr.takeError());
             return orc::SymbolNameSet();
           }
         } else if (auto Err = Sym.takeError()) {
-          Stack.ES.failQuery(*Query, std::move(Err));
+          Stack.ES.legacyFailQuery(*Query, std::move(Err));
           return orc::SymbolNameSet();
         } else
           UnresolvedSymbols.insert(S);

llvm/lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

@@ -178,11 +178,11 @@ class OrcMCJITReplacement : public ExecutionEngine {
             Query->notifySymbolReady();
             NewSymbolsResolved = true;
           } else {
-            M.ES.failQuery(*Query, Addr.takeError());
+            M.ES.legacyFailQuery(*Query, Addr.takeError());
             return SymbolNameSet();
           }
         } else if (auto Err = Sym.takeError()) {
-          M.ES.failQuery(*Query, std::move(Err));
+          M.ES.legacyFailQuery(*Query, std::move(Err));
           return SymbolNameSet();
         } else {
           if (auto Sym2 = M.ClientResolver->findSymbol(*S)) {
@@ -191,11 +191,11 @@ class OrcMCJITReplacement : public ExecutionEngine {
               Query->notifySymbolReady();
               NewSymbolsResolved = true;
             } else {
-              M.ES.failQuery(*Query, Addr.takeError());
+              M.ES.legacyFailQuery(*Query, Addr.takeError());
               return SymbolNameSet();
             }
           } else if (auto Err = Sym2.takeError()) {
-            M.ES.failQuery(*Query, std::move(Err));
+            M.ES.legacyFailQuery(*Query, std::move(Err));
             return SymbolNameSet();
           } else
             UnresolvedSymbols.insert(S);

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

@@ -16,30 +16,23 @@ using namespace llvm::orc;
 
 class VSOSearchOrderResolver : public JITSymbolResolver {
 public:
-  VSOSearchOrderResolver(ExecutionSession &ES,
+  VSOSearchOrderResolver(MaterializationResponsibility &MR) : MR(MR) {}
-                         MaterializationResponsibility &MR)
-      : ES(ES), MR(MR) {}
 
   Expected<LookupResult> lookup(const LookupSet &Symbols) {
+    auto &ES = MR.getTargetVSO().getExecutionSession();
     SymbolNameSet InternedSymbols;
 
     for (auto &S : Symbols)
       InternedSymbols.insert(ES.getSymbolStringPool().intern(S));
 
-    auto AsyncLookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Q,
+    auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
-                           SymbolNameSet Names) {
+      MR.addDependencies(Deps);
-      SymbolNameSet Unresolved = std::move(Names);
-      MR.getTargetVSO().withSearchOrderDo([&](const VSOList &SearchOrder) {
-        for (auto *V : SearchOrder) {
-          assert(V && "VSOList entry can not be null");
-          Unresolved = V->lookup(Q, std::move(Unresolved));
-        }
-      });
-      return Unresolved;
     };
 
-    auto InternedResult = blockingLookup(
+    auto InternedResult =
-        ES, std::move(AsyncLookup), std::move(InternedSymbols), false, &MR);
+        MR.getTargetVSO().withSearchOrderDo([&](const VSOList &VSOs) {
+          return ES.lookup(VSOs, InternedSymbols, RegisterDependencies, false);
+        });
 
     if (!InternedResult)
       return InternedResult.takeError();
@@ -52,6 +45,8 @@ public:
   }
 
   Expected<LookupFlagsResult> lookupFlags(const LookupSet &Symbols) {
+    auto &ES = MR.getTargetVSO().getExecutionSession();
+
     SymbolNameSet InternedSymbols;
 
     for (auto &S : Symbols)
@@ -75,7 +70,6 @@ public:
   }
 
 private:
-  ExecutionSession &ES;
   MaterializationResponsibility &MR;
 };
 
@@ -106,7 +100,7 @@ void RTDyldObjectLinkingLayer2::emit(MaterializationResponsibility R,
 
   auto MemoryManager = GetMemoryManager(K);
 
-  VSOSearchOrderResolver Resolver(ES, R);
+  VSOSearchOrderResolver Resolver(R);
   auto RTDyld = llvm::make_unique<RuntimeDyld>(*MemoryManager, Resolver);
   RTDyld->setProcessAllSections(ProcessAllSections);
 

llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

@@ -59,51 +59,57 @@ private:
   DestructorFunction Destructor;
 };
 
-
+TEST_F(CoreAPIsStandardTest, BasicSuccessfulLookup) {
-TEST_F(CoreAPIsStandardTest, AsynchronousSymbolQuerySuccessfulResolutionOnly) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
-  auto OnResolution =
+
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
-        EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
+    EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
-        auto &Resolved = Result->Symbols;
+    auto &Resolved = *Result;
-        auto I = Resolved.find(Foo);
+    auto I = Resolved.find(Foo);
-        EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
+    EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
-        EXPECT_EQ(I->second.getAddress(), FooAddr)
+    EXPECT_EQ(I->second.getAddress(), FooAddr)
-            << "Resolution returned incorrect result";
+        << "Resolution returned incorrect result";
-        OnResolutionRun = true;
+    OnResolutionRun = true;
-      };
+  };
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
+  std::shared_ptr<MaterializationResponsibility> FooMR;
 
-  Q.resolve(Foo, FooSym);
+  cantFail(V.define(llvm::make_unique<SimpleMaterializationUnit>(
+      SymbolFlagsMap({{Foo, FooSym.getFlags()}}),
+      [&](MaterializationResponsibility R) {
+        FooMR = std::make_shared<MaterializationResponsibility>(std::move(R));
+      })));
 
-  EXPECT_TRUE(Q.isFullyResolved()) << "Expected query to be fully resolved";
+  ES.lookup({&V}, {Foo}, OnResolution, OnReady, NoDependenciesToRegister);
 
-  if (!Q.isFullyResolved())
+  EXPECT_FALSE(OnResolutionRun) << "Should not have been resolved yet";
-    return;
+  EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
 
-  Q.handleFullyResolved();
+  FooMR->resolve({{Foo, FooSym}});
 
-  EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
+  EXPECT_TRUE(OnResolutionRun) << "Should have been resolved";
-  EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
+  EXPECT_FALSE(OnReadyRun) << "Should not have been marked ready yet";
+
+  FooMR->finalize();
+
+  EXPECT_TRUE(OnReadyRun) << "Should have been marked ready";
 }
 
 TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+    EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
-        EXPECT_FALSE(!!Result) << "Resolution unexpectedly returned success";
+    auto Msg = toString(Result.takeError());
-        auto Msg = toString(Result.takeError());
+    EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
-        EXPECT_EQ(Msg, "xyz") << "Resolution returned incorrect result";
+    OnResolutionRun = true;
-        OnResolutionRun = true;
+  };
-      };
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
@@ -111,62 +117,28 @@ TEST_F(CoreAPIsStandardTest, ExecutionSessionFailQuery) {
 
   AsynchronousSymbolQuery Q(SymbolNameSet({Foo}), OnResolution, OnReady);
 
-  ES.failQuery(Q, make_error<StringError>("xyz", inconvertibleErrorCode()));
+  ES.legacyFailQuery(Q,
+                     make_error<StringError>("xyz", inconvertibleErrorCode()));
 
   EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
   EXPECT_FALSE(OnReadyRun) << "OnReady unexpectedly run";
 }
 
-TEST_F(CoreAPIsStandardTest, SimpleAsynchronousSymbolQueryAgainstVSO) {
+TEST_F(CoreAPIsStandardTest, EmptyLookup) {
-  bool OnResolutionRun = false;
+  bool OnResolvedRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+    cantFail(std::move(Result));
-        EXPECT_TRUE(!!Result) << "Query unexpectedly returned error";
+    OnResolvedRun = true;
-        auto &Resolved = Result->Symbols;
+  };
-        auto I = Resolved.find(Foo);
-        EXPECT_NE(I, Resolved.end()) << "Could not find symbol definition";
-        EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
-            << "Resolution returned incorrect result";
-        OnResolutionRun = true;
-      };
 
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  SymbolNameSet Names({Foo});
+  ES.lookup({&V}, {}, OnResolution, OnReady, NoDependenciesToRegister);
-
-  auto Q =
-      std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
-
-  auto Defs = absoluteSymbols({{Foo, FooSym}});
-  cantFail(V.define(Defs));
-  assert(Defs == nullptr && "Defs should have been accepted");
-  V.lookup(Q, Names);
-
-  EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
-  EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
-}
-
-TEST_F(CoreAPIsStandardTest, EmptyVSOAndQueryLookup) {
-  bool OnResolvedRun = false;
-  bool OnReadyRun = false;
-
-  auto Q = std::make_shared<AsynchronousSymbolQuery>(
-      SymbolNameSet(),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
-        cantFail(std::move(RR));
-        OnResolvedRun = true;
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        OnReadyRun = true;
-      });
-
-  V.lookup(std::move(Q), {});
 
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
   EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -182,8 +154,8 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOLookup) {
 
   auto Q = std::make_shared<AsynchronousSymbolQuery>(
       SymbolNameSet({Foo}),
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+      [&](Expected<SymbolMap> Result) {
-        cantFail(std::move(RR));
+        cantFail(std::move(Result));
         OnResolvedRun = true;
       },
       [&](Error Err) {
@@ -191,7 +163,7 @@ TEST_F(CoreAPIsStandardTest, ChainedVSOLookup) {
         OnReadyRun = true;
       });
 
-  V2.lookup(Q, V.lookup(Q, {Foo}));
+  V2.legacyLookup(Q, V.legacyLookup(Q, {Foo}));
 
   EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run for empty query";
   EXPECT_TRUE(OnReadyRun) << "OnReady was not run for empty query";
@@ -268,20 +240,15 @@ TEST_F(CoreAPIsStandardTest, TestTrivialCircularDependency) {
   cantFail(V.define(FooMU));
 
   bool FooReady = false;
-  auto Q =
+  auto OnResolution = [](Expected<SymbolMap> R) { cantFail(std::move(R)); };
-    std::make_shared<AsynchronousSymbolQuery>(
+  auto OnReady = [&](Error Err) {
-      SymbolNameSet({ Foo }),
+    cantFail(std::move(Err));
-      [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
+    FooReady = true;
-        cantFail(std::move(R));
+  };
-      },
-      [&](Error Err) {
-        cantFail(std::move(Err));
-        FooReady = true;
-      });
 
-  V.lookup(std::move(Q), { Foo });
+  ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
+            NoDependenciesToRegister);
 
-  FooR->addDependencies({{&V, {Foo}}});
   FooR->resolve({{Foo, FooSym}});
   FooR->finalize();
 
@@ -323,54 +290,52 @@ TEST_F(CoreAPIsStandardTest, TestCircularDependenceInOneVSO) {
   // Query each of the symbols to trigger materialization.
   bool FooResolved = false;
   bool FooReady = false;
-  auto FooQ = std::make_shared<AsynchronousSymbolQuery>(
+
-      SymbolNameSet({Foo}),
+  auto OnFooResolution = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+    cantFail(std::move(Result));
-        cantFail(std::move(RR));
+    FooResolved = true;
-        FooResolved = true;
+  };
-      },
+
-      [&](Error Err) {
+  auto OnFooReady = [&](Error Err) {
-        cantFail(std::move(Err));
+    cantFail(std::move(Err));
-        FooReady = true;
+    FooReady = true;
-      });
+  };
-  {
+
-    auto Unresolved = V.lookup(FooQ, {Foo});
+  // Issue a lookup for Foo. Use NoDependenciesToRegister: We're going to add
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Foo\"";
+  // the dependencies manually below.
-  }
+  ES.lookup({&V}, {Foo}, std::move(OnFooResolution), std::move(OnFooReady),
+            NoDependenciesToRegister);
 
   bool BarResolved = false;
   bool BarReady = false;
-  auto BarQ = std::make_shared<AsynchronousSymbolQuery>(
+  auto OnBarResolution = [&](Expected<SymbolMap> Result) {
-      SymbolNameSet({Bar}),
+    cantFail(std::move(Result));
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+    BarResolved = true;
-        cantFail(std::move(RR));
+  };
-        BarResolved = true;
+
-      },
+  auto OnBarReady = [&](Error Err) {
-      [&](Error Err) {
+    cantFail(std::move(Err));
-        cantFail(std::move(Err));
+    BarReady = true;
-        BarReady = true;
+  };
-      });
+
-  {
+  ES.lookup({&V}, {Bar}, std::move(OnBarResolution), std::move(OnBarReady),
-    auto Unresolved = V.lookup(BarQ, {Bar});
+            NoDependenciesToRegister);
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Bar\"";
-  }
 
   bool BazResolved = false;
   bool BazReady = false;
-  auto BazQ = std::make_shared<AsynchronousSymbolQuery>(
+
-      SymbolNameSet({Baz}),
+  auto OnBazResolution = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> RR) {
+    cantFail(std::move(Result));
-        cantFail(std::move(RR));
+    BazResolved = true;
-        BazResolved = true;
+  };
-      },
+
-      [&](Error Err) {
+  auto OnBazReady = [&](Error Err) {
-        cantFail(std::move(Err));
+    cantFail(std::move(Err));
-        BazReady = true;
+    BazReady = true;
-      });
+  };
-  {
+
-    auto Unresolved = V.lookup(BazQ, {Baz});
+  ES.lookup({&V}, {Baz}, std::move(OnBazResolution), std::move(OnBazReady),
-    EXPECT_TRUE(Unresolved.empty()) << "Failed to resolve \"Baz\"";
+            NoDependenciesToRegister);
-  }
 
   // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
   FooR->addDependencies({{&V, SymbolNameSet({Bar})}});
@@ -478,28 +443,23 @@ TEST_F(CoreAPIsStandardTest, AddAndMaterializeLazySymbol) {
   bool OnResolutionRun = false;
   bool OnReadyRun = false;
 
-  auto OnResolution =
+  auto OnResolution = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+    EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
-        EXPECT_TRUE(!!Result) << "Resolution unexpectedly returned error";
+    auto I = Result->find(Foo);
-        auto I = Result->Symbols.find(Foo);
+    EXPECT_NE(I, Result->end()) << "Could not find symbol definition";
-        EXPECT_NE(I, Result->Symbols.end())
+    EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
-            << "Could not find symbol definition";
+        << "Resolution returned incorrect result";
-        EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
+    OnResolutionRun = true;
-            << "Resolution returned incorrect result";
+  };
-        OnResolutionRun = true;
-      };
 
   auto OnReady = [&](Error Err) {
     cantFail(std::move(Err));
     OnReadyRun = true;
   };
 
-  auto Q =
+  ES.lookup({&V}, Names, std::move(OnResolution), std::move(OnReady),
-      std::make_shared<AsynchronousSymbolQuery>(Names, OnResolution, OnReady);
+            NoDependenciesToRegister);
 
-  auto Unresolved = V.lookup(std::move(Q), Names);
-
-  EXPECT_TRUE(Unresolved.empty()) << "Could not find Foo in dylib";
   EXPECT_TRUE(FooMaterialized) << "Foo was not materialized";
   EXPECT_TRUE(BarDiscarded) << "Bar was not discarded";
   EXPECT_TRUE(OnResolutionRun) << "OnResolutionCallback was not run";
@@ -714,13 +674,14 @@ TEST_F(CoreAPIsStandardTest, TestMaterializeWeakSymbol) {
       });
 
   cantFail(V.define(MU));
-  auto Q = std::make_shared<AsynchronousSymbolQuery>(
+  auto OnResolution = [](Expected<SymbolMap> Result) {
-      SymbolNameSet({Foo}),
+    cantFail(std::move(Result));
-      [](Expected<AsynchronousSymbolQuery::ResolutionResult> R) {
+  };
-        cantFail(std::move(R));
+
-      },
+  auto OnReady = [](Error Err) { cantFail(std::move(Err)); };
-      [](Error Err) { cantFail(std::move(Err)); });
+
-  V.lookup(std::move(Q), SymbolNameSet({Foo}));
+  ES.lookup({&V}, {Foo}, std::move(OnResolution), std::move(OnReady),
+            NoDependenciesToRegister);
 
   auto MU2 = llvm::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, JITSymbolFlags::Exported}}),

llvm/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp

@@ -24,7 +24,7 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
   auto Resolver = createSymbolResolver(
       [&](const SymbolNameSet &Symbols) { return V.lookupFlags(Symbols); },
       [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
-        return V.lookup(std::move(Q), Symbols);
+        return V.legacyLookup(std::move(Q), Symbols);
       });
 
   SymbolNameSet Symbols({Foo, Bar, Baz});
@@ -42,21 +42,17 @@ TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
 
   bool OnResolvedRun = false;
 
-  auto OnResolved =
+  auto OnResolved = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+    OnResolvedRun = true;
-        OnResolvedRun = true;
+    EXPECT_TRUE(!!Result) << "Unexpected error";
-        EXPECT_TRUE(!!Result) << "Unexpected error";
+    EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
-        EXPECT_EQ(Result->Symbols.size(), 2U)
+    EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
-            << "Unexpected number of resolved symbols";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
-        EXPECT_EQ(Result->Symbols.count(Foo), 1U)
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
-            << "Missing lookup result for foo";
+        << "Incorrect address for foo";
-        EXPECT_EQ(Result->Symbols.count(Bar), 1U)
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
-            << "Missing lookup result for bar";
+        << "Incorrect address for bar";
-        EXPECT_EQ(Result->Symbols[Foo].getAddress(), FooSym.getAddress())
+  };
-            << "Incorrect address for foo";
-        EXPECT_EQ(Result->Symbols[Bar].getAddress(), BarSym.getAddress())
-            << "Incorrect address for bar";
-      };
   auto OnReady = [&](Error Err) {
     EXPECT_FALSE(!!Err) << "Finalization should never fail in this test";
   };
@@ -85,7 +81,7 @@ TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
 
   auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
                     SymbolNameSet Symbols) {
-    return V.lookup(std::move(Query), Symbols);
+    return V.legacyLookup(std::move(Query), Symbols);
   };
 
   auto UnderlyingResolver =
@@ -158,22 +154,18 @@ TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
 
   bool OnResolvedRun = false;
   bool OnReadyRun = false;
-  auto OnResolved =
+  auto OnResolved = [&](Expected<SymbolMap> Result) {
-      [&](Expected<AsynchronousSymbolQuery::ResolutionResult> Result) {
+    OnResolvedRun = true;
-        OnResolvedRun = true;
+    EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
-        EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
 
-        auto &Resolved = Result->Symbols;
+    EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
-        EXPECT_EQ(Resolved.size(), 2U) << "Wrong number of symbols resolved";
+    EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
-        EXPECT_EQ(Resolved.count(Foo), 1U) << "Result for foo missing";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
-        EXPECT_EQ(Resolved.count(Bar), 1U) << "Result for bar missing";
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
-        EXPECT_EQ(Resolved[Foo].getAddress(), FooAddr)
+    EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
-            << "Wrong address for foo";
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
-        EXPECT_EQ(Resolved[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
+    EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
-        EXPECT_EQ(Resolved[Bar].getAddress(), BarAddr)
+  };
-            << "Wrong address for bar";
-        EXPECT_EQ(Resolved[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
-      };
   auto OnReady = [&](Error Err) {
     EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
     OnReadyRun = true;