[ORC] Preliminary support for removable code.

[lhames]

Summary

This patch adds support for removal of JITDylibs with notification to registered
clients to enable resources (including allocated memory) to be freed.

It is currently unsafe if any symbols in the module are currently being
materialized.

[dblaikie]

llvm/lib/ExecutionEngine/Orc/Core.cpp

1883

= default, maybe? (no functional difference, but I like that it at least has the potential to give the frontend a little more information it could use at some point)

[lhames]

Update for changes in 41379f1ec46.

Adds an 'Open' state flag to JITDylib.

Adds error plumbing for 'JITDylibDestroyed' errors to JITDylib and
MaterializationResponsibility.

[lhames]

This has been superseded by the removable code support added in 0aec49c8531.

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

public:
   void log(raw_ostream &OS) const override;
   const std::string &getModuleName() const { return ModuleName; }
   const SymbolNameVector &getSymbols() const { return Symbols; }
 private:
   std::string ModuleName;
   SymbolNameVector Symbols;
 };
 
+/// Returned from operations performed on closed JITDylibs and
+/// MaterializationResponsibilities.
+class JITDylibDestroyed : public ErrorInfo<JITDylibDestroyed> {
+public:
+  static char ID;
+
+  std::error_code convertToErrorCode() const override;
+  void log(raw_ostream &OS) const override;
+};
+
 /// Tracks responsibility for materialization, and mediates interactions between
 /// MaterializationUnits and JDs.
 ///
 /// An instance of this class is passed to MaterializationUnits when their
 /// materialize method is called. It allows MaterializationUnits to resolve and
 /// emit symbols, or abandon materialization by notifying any unmaterialized
 /// symbols of an error.
 class MaterializationResponsibility {
   friend class MaterializationUnit;
 public:
   MaterializationResponsibility(MaterializationResponsibility &&) = default;
   MaterializationResponsibility &
   operator=(MaterializationResponsibility &&) = delete;
 
   /// Destruct a MaterializationResponsibility instance. In debug mode
   ///        this asserts that all symbols being tracked have been either
   ///        emitted or notified of an error.
   ~MaterializationResponsibility();
 
+  /// Consume an Error from a MaterializationResponsibility operation and apply
+  /// the standard error handling rules (see below). Clients should abandon
+  /// materialization if this method returns true.
+  ///
+  /// (1) If the error is a MaterializationAbandoned error then return true (in
+  /// which case the client should bail out).
+  /// (2) If the error is any other failure value then call failMaterialization
+  /// then return true (in which case the client should bail out).
+  /// (3) If the error is a success value then return false.
+  bool shouldBailOut(Error Err);
+
   /// Returns the target JITDylib that these symbols are being materialized
   ///        into.
   JITDylib &getTargetJITDylib() const { return *JD; }
 
   /// Returns the symbol flags map for this responsibility instance.
   /// Note: The returned flags may have transient flags (Lazy, Materializing)
   /// set. These should be stripped with JITSymbolFlags::stripTransientFlags
   /// before using.
   const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
 
   /// Returns the initialization pseudo-symbol, if any. This symbol will also
   /// be present in the SymbolFlagsMap for this MaterializationResponsibility
   /// object.
   const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
 
   /// 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
   /// back to the JITDylib via the delegate method.
   ///
-  /// If this method returns None then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD Optional<SymbolNameSet> getRequestedSymbols() const;
+  /// This method may return the following error type(s):
+  ///
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  Expected<SymbolNameSet> getRequestedSymbols() const;
 
   /// Notifies the target JITDylib that the given symbols have been resolved.
   /// This will update the given symbols' addresses in the JITDylib, and notify
   /// any pending queries on the given symbols of their resolution. The given
   /// symbols must be ones covered by this MaterializationResponsibility
   /// instance. Individual calls to this method may resolve a subset of the
   /// symbols, but all symbols must have been resolved prior to calling emit.
   ///
-  /// If this method returns None then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case. If this method returns an
-  /// Error value other than Error success.
-  LLVM_NODISCARD Optional<Error> notifyResolved(const SymbolMap &Symbols);
+  /// This method may return the following error type(s):
+  ///
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  ///
+  /// - FailedToMaterialize: If any of the resolved symbols have been moved
+  ///   to the error state due to dependence on some other failed symbol.
+  ///   The client should report the error (via ExecutionSession::reportError),
+  ///   call failMaterialization, and then abandon materialization.
+  Error notifyResolved(const SymbolMap &Symbols);
 
   /// Notifies the target JITDylib (and any pending queries on that JITDylib)
   /// that all symbols covered by this MaterializationResponsibility instance
   /// have been emitted.
   ///
-  /// If this method returns None then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD Optional<Error> notifyEmitted();
+  /// This method may return the following error type(s):
+  ///
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  ///
+  /// - FailedToMaterialize: If any of the emitted symbols have been moved
+  ///   to the error state due to dependence on some other failed symbol.
+  ///   The client should report the error (via ExecutionSession::reportError),
+  ///   call failMaterialization, and then abandon materialization.
+  Error notifyEmitted();
 
   /// Attempt to claim responsibility for new definitions. This method can be
   /// used to claim responsibility for symbols that are added to a
   /// materialization unit during the compilation process (e.g. literal pool
   /// symbols). Symbol linkage rules are the same as for symbols that are
   /// defined up front: duplicate strong definitions will result in errors.
   /// Duplicate weak definitions will be discarded (in which case they will
   /// not be added to this responsibility instance).
   ///
   /// This method can be used by materialization units that want to add
   /// additional symbols at materialization time (e.g. stubs, compile
   /// callbacks, metadata).
   ///
-  /// If this method returns None then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD Optional<Error> defineMaterializing(SymbolFlagsMap SymbolFlags);
+  /// This method may return the following error type(s):
+  ///
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  ///
+  /// - DuplicateDefinition: If any of the new definitions clashes with an
+  ///   existing definition in the target JITDylib. The client should report
+  ///   the error (via ExecutionSession::reportError), call failMaterialization,
+  ///   and then abandon materialization.
+  Error defineMaterializing(SymbolFlagsMap SymbolFlags);
 
   /// Notify all not-yet-emitted covered by this MaterializationResponsibility
   /// instance that an error has occurred.
   /// This will remove all symbols covered by this MaterializationResponsibilty
   /// from the target JITDylib, and send an error to any queries waiting on
   /// these symbols.
   void failMaterialization();
 
   /// Transfers responsibility to the given MaterializationUnit for all
   /// symbols defined by that MaterializationUnit. This allows
   /// materializers to break up work based on run-time information (e.g.
   /// by introspecting which symbols have actually been looked up and
   /// materializing only those).
   ///
-  /// If this method returns false then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD bool replace(std::unique_ptr<MaterializationUnit> MU);
+  /// This method may return the following error type(s):
+  ///
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  Error replace(std::unique_ptr<MaterializationUnit> MU);
 
   /// Delegates responsibility for the given symbols to the returned
   /// materialization responsibility. Useful for breaking up work between
   /// threads, or different kinds of materialization processes.
   MaterializationResponsibility delegate(const SymbolNameSet &Symbols);
 
   /// Add dependencies that apply to symbol Name.
   ///
-  /// If this method returns false then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD bool addDependencies(const SymbolStringPtr &Name,
-                                      const SymbolDependenceMap &Dependencies);
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  Error addDependencies(const SymbolStringPtr &Name,
 
   /// Add dependencies that apply to all symbols covered by this instance.
   ///
-  /// If this method returns false then this MaterializationResponsibility has
-  /// been discarded and materialization should be abandoned. There is no
-  /// need to call failMaterialization in this case.
-  LLVM_NODISCARD bool addDependenciesForAll(const SymbolDependenceMap &Dependencies);
+  /// - JITDylibDestroyed: If the target JITDylib has been destroyed already.
+  ///   in this case the client need not call failMaterialization (if called
+  ///   it will be a no-op), but should abandon materialization.
+  Error addDependenciesForAll(const SymbolDependenceMap &Dependencies);
 
 private:
   /// Create a MaterializationResponsibility for the given JITDylib and
   ///        initial symbols.
   MaterializationResponsibility(std::shared_ptr<JITDylib> JD,
                                 SymbolFlagsMap SymbolFlags,
                                 SymbolStringPtr InitSymbol)
       : JD(std::move(JD)), SymbolFlags(std::move(SymbolFlags)),
private:
   void transferEmittedNodeDependencies(MaterializingInfo &DependantMI,
                                        const SymbolStringPtr &DependantName,
                                        MaterializingInfo &EmittedMI);
 
   Expected<SymbolFlagsMap> defineMaterializing(SymbolFlagsMap SymbolFlags);
 
   Error replace(std::unique_ptr<MaterializationUnit> MU);
 
-  Optional<SymbolNameSet>
+  Expected<SymbolNameSet>
   getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) const;
 
-  bool addDependencies(const SymbolStringPtr &Name,
+  Error addDependencies(const SymbolStringPtr &Name,
                         const SymbolDependenceMap &Dependants);
 
-  bool resolve(const SymbolMap &Resolved);
+  Error resolve(const SymbolMap &Resolved);
 
-  bool emit(const SymbolFlagsMap &Emitted);
+  Error emit(const SymbolFlagsMap &Emitted);
 
   using FailedSymbolsWorklist =
       std::vector<std::pair<JITDylib *, SymbolStringPtr>>;
   struct NotifyFailedResult {
     std::shared_ptr<SymbolDependenceMap> FailedSymbolsMap;
     AsynchronousSymbolQuerySet FailedQueries;
   };
   static NotifyFailedResult notifyFailed(FailedSymbolsWorklist FailedSymbols);
 
-  void prepareForRemoval();
+  NotifyFailedResult prepareForRemoval();
 
   ExecutionSession &ES;
   std::string JITDylibName;
   bool Open = true;
   SymbolTable Symbols;
   UnmaterializedInfosMap UnmaterializedInfos;
   MaterializingInfosMap MaterializingInfos;
   std::vector<std::unique_ptr<DefinitionGenerator>> DefGenerators;
template <typename Func> decltype(auto) runSessionLocked(Func &&F) {
     return F();
   }
 
   /// Register a JITDylibDestructionListener.
   void registerJITDylibDestructionListener(JITDylibDestructionListener &L) {
     runSessionLocked([&]() { JITDylibDestructionListeners.push_back(&L); });
   }
 
+  /// Deregister a JITDylibDestructionListener.
+  void deregisterJITDylibDestructionListener(JITDylibDestructionListener &L);
+
   /// Return a pointer to the "name" JITDylib.
   /// Ownership of JITDylib remains within Execution Session
   JITDylib *getJITDylibByName(StringRef Name);
 
   /// Add a new bare JITDylib to this ExecutionSession.
   ///
   /// The JITDylib Name is required to be unique. Clients should verify that
   /// names are not being re-used (E.g. by calling getJITDylibByName) if names
public:
   ///
   /// If a Platform is attached then Platform::setupJITDylib will be called to
   /// install standard platform symbols (e.g. standard library interposes).
   /// If no Platform is attached this call is equivalent to createBareJITDylib.
   Expected<JITDylib &> createJITDylib(std::string Name);
 
   /// Close a JITDylib.
   ///
-  /// This will delete the JITDylib and release any resources associated with
-  /// it. This method does *not* run static destructors: If supported they must
-  /// be run by the Platform prior to calling this method.
+  /// This will delete the JITDylib, release any resources associated with
+  /// it, and remove it from the link order of any JITDylibs that depend on it.
+  /// This method does not run static destructors, nor attempt to remove any
+  /// other JITDylibs
   Error destroyJITDylib(JITDylib &JD);
 
+  /// Returns a vector of current JITDylib pointers in reverse-preorder
+  /// according to their linkage relationships.
+  ///
+  /// This list is invalidated if any JITDylibs are created or removed, or
+  /// any new linakge relationships are added or removed from any JITDylib.
+  std::vector<JITDylib *> getJITDylibsInReverseLinkOrder();
+
   /// Allocate a module key for a new module to add to the JIT.
   VModuleKey allocateVModule() {
     return runSessionLocked([this]() { return ++LastKey; });
   }
 
   /// Return a module key to the ExecutionSession so that it can be
   ///        re-used. This should only be done once all resources associated
   ///        with the original key have been released.
public:
   Expected<SymbolMap>
   legacyLookup(LegacyAsyncLookupFunction AsyncLookup, SymbolNameSet Names,
                SymbolState RequiredState,
                RegisterDependenciesFunction RegisterDependencies);
 
   /// Search the given JITDylib list for the given symbols.
   ///
   /// SearchOrder lists the JITDylibs to search. For each dylib, the associated
-  /// boolean indicates whether the search should match against non-exported
-  /// (hidden visibility) symbols in that dylib (true means match against
-  /// non-exported symbols, false means do not match).
+  /// flags indicate whether the search should match against non-exported
+  /// (hidden visibility) symbols in that dylib, or all symbols. All JITDylibs
+  /// in the order must be valid (i.e. not destroyed yet).
   ///
   /// The NotifyComplete callback will be called once all requested symbols
   /// reach the required state.
   ///
   /// 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,

llvm/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

public:
   using ReturnObjectBufferFunction =
       std::function<void(std::unique_ptr<MemoryBuffer>)>;
 
   /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
   /// and NotifyEmitted functors.
   ObjectLinkingLayer(ExecutionSession &ES,
                      std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
 
+  /// Destroy an ObjectLinkingLayer.
+  ~ObjectLinkingLayer();
+
   /// Set an object buffer return function. By default object buffers are
   /// deleted once the JIT has linked them. If a return function is set then
   /// it will be called to transfer ownership of the buffer instead.
   void setReturnObjectBuffer(ReturnObjectBufferFunction ReturnObjectBuffer) {
     this->ReturnObjectBuffer = std::move(ReturnObjectBuffer);
   }
 
   /// Add a pass-config modifier.

llvm/include/llvm/ExecutionEngine/Orc/OrcError.h

enum class OrcErrorCode : int {
   RPCCouldNotNegotiateFunction,
   RPCResponseAbandoned,
   UnexpectedRPCCall,
   UnexpectedRPCResponse,
   UnknownErrorCodeFromRemote,
   UnknownResourceHandle,
   MissingSymbolDefinitions,
   UnexpectedSymbolDefinitions,
+  JITDylibDestroyed
 };
 
 std::error_code orcError(OrcErrorCode ErrCode);
 
 class DuplicateDefinition : public ErrorInfo<DuplicateDefinition> {
 public:
   static char ID;
 

llvm/include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 namespace orc {
 
-class RTDyldObjectLinkingLayer : public ObjectLayer {
+class RTDyldObjectLinkingLayer : public ObjectLayer,
+                                 public JITDylibDestructionListener {
 public:
   /// Functor for receiving object-loaded notifications.
   using NotifyLoadedFunction = std::function<void(
       const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &)>;
 
   /// Functor for receiving finalization notifications.
   using NotifyEmittedFunction =
       std::function<void(std::unique_ptr<MemoryBuffer>)>;
 
   using GetMemoryManagerFunction =
       std::function<std::unique_ptr<RuntimeDyld::MemoryManager>()>;
 
   /// Construct an ObjectLinkingLayer with the given NotifyLoaded,
   ///        and NotifyEmitted functors.
   RTDyldObjectLinkingLayer(ExecutionSession &ES,
                            GetMemoryManagerFunction GetMemoryManager);
 
   ~RTDyldObjectLinkingLayer();
 
   /// Emit the object.
   void emit(MaterializationResponsibility R,
             std::unique_ptr<MemoryBuffer> O) override;
 
+  /// Handle JITDylib teardown notifications.
+  Error notifyDestroyingJITDylib(JITDylib &JD) override;
+
   /// Set the NotifyLoaded callback.
   RTDyldObjectLinkingLayer &setNotifyLoaded(NotifyLoadedFunction NotifyLoaded) {
     this->NotifyLoaded = std::move(NotifyLoaded);
     return *this;
   }
 
   /// Set the NotifyEmitted callback.
   RTDyldObjectLinkingLayer &
private:
 
   mutable std::mutex RTDyldLayerMutex;
   GetMemoryManagerFunction GetMemoryManager;
   NotifyLoadedFunction NotifyLoaded;
   NotifyEmittedFunction NotifyEmitted;
   bool ProcessAllSections = false;
   bool OverrideObjectFlags = false;
   bool AutoClaimObjectSymbols = false;
-  std::vector<std::unique_ptr<RuntimeDyld::MemoryManager>> MemMgrs;
+  DenseMap<JITDylib *, std::vector<std::unique_ptr<RuntimeDyld::MemoryManager>>>
+      MemMgrs;
   std::vector<JITEventListener *> EventListeners;
   DenseMap<RuntimeDyld::MemoryManager *,
            std::unique_ptr<RuntimeDyld::LoadedObjectInfo>>
       LoadedObjInfos;
 };
 
 class LegacyRTDyldObjectLinkingLayerBase {
 public:

llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp

void CompileOnDemandLayer::emit(MaterializationResponsibility R,
   if (auto Err = PDR.getImplDylib().define(
           std::make_unique<PartitioningIRMaterializationUnit>(
               ES, *getManglingOptions(), std::move(TSM), *this))) {
     ES.reportError(std::move(Err));
     R.failMaterialization();
     return;
   }
 
-  if (!NonCallables.empty())
+  if (!NonCallables.empty()) {
+    if (R.shouldBailOut(
             R.replace(reexports(PDR.getImplDylib(), std::move(NonCallables),
-                        JITDylibLookupFlags::MatchAllSymbols));
-  if (!Callables.empty())
-    R.replace(lazyReexports(LCTMgr, PDR.getISManager(), PDR.getImplDylib(),
-                            std::move(Callables), AliaseeImpls));
+                                JITDylibLookupFlags::MatchAllSymbols))))
+      return;
+  }
+  if (!Callables.empty()) {
+    if (R.shouldBailOut(R.replace(
+            lazyReexports(LCTMgr, PDR.getISManager(), PDR.getImplDylib(),
+                          std::move(Callables), AliaseeImpls))))
+      return;
+  }
 }
 
 CompileOnDemandLayer::PerDylibResources &
 CompileOnDemandLayer::getPerDylibResources(JITDylib &TargetD) {
   auto I = DylibResources.find(&TargetD);
   if (I == DylibResources.end()) {
     auto &ImplD =
         getExecutionSession().createBareJITDylib(TargetD.getName() + ".impl");
void CompileOnDemandLayer::emitPartition(
 
   // FIXME: Need a 'notify lazy-extracting/emitting' callback to tie the
   //        extracted module key, extracted module, and source module key
   //        together. This could be used, for example, to provide a specific
   //        memory manager instance to the linking layer.
 
   auto &ES = getExecutionSession();
   GlobalValueSet RequestedGVs;
-  for (auto &Name : R.getRequestedSymbols()) {
+
+  auto RequestedSymbols = R.getRequestedSymbols();
+  if (R.shouldBailOut(RequestedSymbols.takeError()))
+    return;
+
+  for (auto &Name : *RequestedSymbols) {
     if (Name == R.getInitializerSymbol())
       TSM.withModuleDo([&](Module &M) {
         for (auto &GV : getStaticInitGVs(M))
           RequestedGVs.insert(&GV);
       });
     else {
       assert(Defs.count(Name) && "No definition for symbol");
       RequestedGVs.insert(Defs[Name]);
void CompileOnDemandLayer::emitPartition(
   if (GVsToExtract == None) {
     Defs.clear();
     BaseLayer.emit(std::move(R), std::move(TSM));
     return;
   }
 
   // If the partition is empty, return the whole module to the symbol table.
   if (GVsToExtract->empty()) {
+    // We're going to bail out either way here, but we use shouldBailOut for
+    // the standard error handling.
+    R.shouldBailOut(
         R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
             std::move(TSM), R.getSymbols(), R.getInitializerSymbol(),
-        std::move(Defs), *this));
+            std::move(Defs), *this)));
     return;
   }
 
   // Ok -- we actually need to partition the symbols. Promote the symbol
   // linkages/names, expand the partition to include any required symbols
   // (i.e. symbols that can't be separated from our partition), and
   // then extract the partition.
   //
auto ExtractedTSM =
       });
 
   if (!ExtractedTSM) {
     ES.reportError(ExtractedTSM.takeError());
     R.failMaterialization();
     return;
   }
 
+  if (R.shouldBailOut(
           R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
-      ES, *getManglingOptions(), std::move(TSM), *this));
+              ES, *getManglingOptions(), std::move(TSM), *this))))
+    return;
   BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/Core.cpp

 namespace llvm {
 namespace orc {
 
 char FailedToMaterialize::ID = 0;
 char SymbolsNotFound::ID = 0;
 char SymbolsCouldNotBeRemoved::ID = 0;
 char MissingSymbolDefinitions::ID = 0;
 char UnexpectedSymbolDefinitions::ID = 0;
+char JITDylibDestroyed::ID = 0;
 
 RegisterDependenciesFunction NoDependenciesToRegister =
     RegisterDependenciesFunction();
 
 void MaterializationUnit::anchor() {}
 
 FailedToMaterialize::FailedToMaterialize(
     std::shared_ptr<SymbolDependenceMap> Symbols)
std::error_code UnexpectedSymbolDefinitions::convertToErrorCode() const {
   return orcError(OrcErrorCode::UnexpectedSymbolDefinitions);
 }
 
 void UnexpectedSymbolDefinitions::log(raw_ostream &OS) const {
   OS << "Unexpected definitions in module " << ModuleName
      << ": " << Symbols;
 }
 
+std::error_code JITDylibDestroyed::convertToErrorCode() const {
+  return orcError(OrcErrorCode::JITDylibDestroyed);
+}
+
+void JITDylibDestroyed::log(raw_ostream &OS) const {
+  OS << "JITDylib already destroyed";
+}
+
 AsynchronousSymbolQuery::AsynchronousSymbolQuery(
     const SymbolLookupSet &Symbols, SymbolState RequiredState,
     SymbolsResolvedCallback NotifyComplete)
     : NotifyComplete(std::move(NotifyComplete)), RequiredState(RequiredState) {
   assert(RequiredState >= SymbolState::Resolved &&
          "Cannot query for a symbols that have not reached the resolve state "
          "yet");
 
void AsynchronousSymbolQuery::detach() {
   QueryRegistrations.clear();
 }
 
 MaterializationResponsibility::~MaterializationResponsibility() {
   assert(SymbolFlags.empty() &&
          "All symbols should have been explicitly materialized or failed");
 }
 
-  Optional<SymbolNameSet>
+bool MaterializationResponsibility::shouldBailOut(Error Err) {
+  if (!Err)
+    return false;
+
+  handleAllErrors(
+      std::move(Err),
+      [](const JITDylibDestroyed &) {
+        // If this is a JITDylibDestroyed error then we don't need to fail
+        // materialization.
+      },
+      [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
+        JD->ES.reportError(Error(std::move(EIB)));
+        failMaterialization();
+        return Error::success();
+      });
+  return true;
+}
+
+Expected<SymbolNameSet>
 MaterializationResponsibility::getRequestedSymbols() const {
   return JD->getRequestedSymbols(SymbolFlags);
 }
 
-bool MaterializationResponsibility::notifyResolved(const SymbolMap &Symbols) {
+Error MaterializationResponsibility::notifyResolved(const SymbolMap &Symbols) {
   LLVM_DEBUG({
     dbgs() << "In " << JD->getName() << " resolving " << Symbols << "\n";
   });
 #ifndef NDEBUG
   for (auto &KV : Symbols) {
     auto WeakFlags = JITSymbolFlags::Weak | JITSymbolFlags::Common;
     auto I = SymbolFlags.find(KV.first);
     assert(I != SymbolFlags.end() &&
ES.runSessionLocked([&]() {
       dbgs() << "materializing reexports: target = " << TgtJD.getName()
              << ", source = " << SrcJD.getName() << " " << RequestedAliases
              << "\n";
     });
   });
 
   if (!Aliases.empty()) {
     if (SourceJD) {
-      if (!R.replace(reexports(*SourceJD, std::move(Aliases), SourceJDLookupFlags)))
+      if (R.shouldBailOut(R.replace(
+              reexports(*SourceJD, std::move(Aliases), SourceJDLookupFlags))))
         return;
     } else {
-      if (!R.replace(symbolAliases(std::move(Aliases))))
+      if (R.shouldBailOut(R.replace(symbolAliases(std::move(Aliases)))))
         return;
     }
+  }
 
   // The OnResolveInfo struct will hold the aliases and responsibilty for each
   // query in the list.
   struct OnResolveInfo {
     OnResolveInfo(MaterializationResponsibility R, SymbolAliasMap Aliases)
         : R(std::move(R)), Aliases(std::move(Aliases)) {}
 
     MaterializationResponsibility R;
auto RegisterDependencies = [QueryInfo,
 
       auto &SrcJDDeps = Deps.find(&SrcJD)->second;
       SymbolDependenceMap PerAliasDepsMap;
       auto &PerAliasDeps = PerAliasDepsMap[&SrcJD];
 
       for (auto &KV : QueryInfo->Aliases)
         if (SrcJDDeps.count(KV.second.Aliasee)) {
           PerAliasDeps = {KV.second.Aliasee};
-          QueryInfo->R.addDependencies(KV.first, PerAliasDepsMap);
+          if (QueryInfo->R.shouldBailOut(
+                  QueryInfo->R.addDependencies(KV.first, PerAliasDepsMap)))
+            return;
         }
     };
 
     auto OnComplete = [QueryInfo](Expected<SymbolMap> Result) {
       auto &ES = QueryInfo->R.getTargetJITDylib().getExecutionSession();
       if (Result) {
         SymbolMap ResolutionMap;
         for (auto &KV : QueryInfo->Aliases) {

 
 Expected<SymbolFlagsMap>
 JITDylib::defineMaterializing(SymbolFlagsMap SymbolFlags) {
 
   return ES.runSessionLocked([&]() -> Expected<SymbolFlagsMap> {
 
     // If this JITDylib has been closed then error out immediately.
     if (!Open)
-      return make_error<TargetJITDylibDestroyed>();
+      return make_error<JITDylibDestroyed>();
 
     std::vector<SymbolTable::iterator> AddedSyms;
     std::vector<SymbolFlagsMap::iterator> RejectedWeakDefs;
 
     for (auto SFItr = SymbolFlags.begin(), SFEnd = SymbolFlags.end();
          SFItr != SFEnd; ++SFItr) {
 
       auto &Name = SFItr->first;
return ES.runSessionLocked([&]() -> Expected<SymbolFlagsMap> {
 
     return SymbolFlags;
   });
 }
 
 Error JITDylib::replace(std::unique_ptr<MaterializationUnit> MU) {
   assert(MU != nullptr && "Can not replace with a null MaterializationUnit");
 
-  auto MustRunMU =
-    ES.runSessionLocked([&, this]() -> Expected<std::unique_ptr<MaterializationUnit>> {
-
+  auto MustRunMU = ES.runSessionLocked(
+      [&, this]() -> Expected<std::unique_ptr<MaterializationUnit>> {
         if (!Open)
-          return make_error<TargetJITDylibDestroyed>();
+          return make_error<JITDylibDestroyed>();
 
 #ifndef NDEBUG
         for (auto &KV : MU->getSymbols()) {
           auto SymI = Symbols.find(KV.first);
           assert(SymI != Symbols.end() && "Replacing unknown symbol");
           assert(SymI->second.getState() == SymbolState::Materializing &&
                  "Can not replace a symbol that ha is not materializing");
           assert(!SymI->second.hasMaterializerAttached() &&
#endif // NDEBUG
       });
 
   if (!MustRunMU)
     return MustRunMU.takeError();
 
   if (*MustRunMU) {
     auto MR =
       (*MustRunMU)->createMaterializationResponsibility(shared_from_this());
-    ES.dispatchMaterialization(std::move(MustRunMU), std::move(MR));
+    ES.dispatchMaterialization(std::move(*MustRunMU), std::move(MR));
   }
 
   return Error::success();
 }
 
-Optional<SymbolNameSet>
+Expected<SymbolNameSet>
 JITDylib::getRequestedSymbols(const SymbolFlagsMap &SymbolFlags) const {
-  return ES.runSessionLocked([&]() {
-
+  return ES.runSessionLocked([&]() -> Expected<SymbolNameSet> {
     if (!Open)
-      return None;
+      return make_error<JITDylibDestroyed>();
 
     SymbolNameSet RequestedSymbols;
 
     for (auto &KV : SymbolFlags) {
       assert(Symbols.count(KV.first) && "JITDylib does not cover this symbol?");
       assert(Symbols.find(KV.first)->second.getState() !=
                  SymbolState::NeverSearched &&
              Symbols.find(KV.first)->second.getState() != SymbolState::Ready &&
              "getRequestedSymbols can only be called for symbols that have "
              "started materializing");
       auto I = MaterializingInfos.find(KV.first);
       if (I == MaterializingInfos.end())
         continue;
 
       if (I->second.hasQueriesPending())
         RequestedSymbols.insert(KV.first);
     }
 
-    return RequestedSymbols;
+    return std::move(RequestedSymbols);
   });
 }
 
 Error JITDylib::addDependencies(const SymbolStringPtr &Name,
                                 const SymbolDependenceMap &Dependencies) {
-  return runSessionLocked([&]() -> Error {
-
-      if (!Open)
-        return make_error<TargetJITDylibDestroyed>();
+  return ES.runSessionLocked([&]() -> Error {
+      return make_error<JITDylibDestroyed>();
 
-      assert(Symbols.count(Name) && "Name not in symbol table");
-      assert(Symbols[Name].getState() < SymbolState::Emitted &&
-             "Can not add dependencies for a symbol that is not materializing");
 
-      LLVM_DEBUG({
-          dbgs() << "In " << getName() << " adding dependencies for "
-                 << *Name << ": " << Dependencies << "\n";
-        });
+      dbgs() << "In " << getName() << " adding dependencies for " << *Name
+             << ": " << Dependencies << "\n";
 
-      // If Name is already in an error state then just bail out.
-      if (Symbols[Name].getFlags().hasError())
-        return;
+      return Error::success();
 
-      auto &MI = MaterializingInfos[Name];
-      assert(Symbols[Name].getState() != SymbolState::Emitted &&
-             "Can not add dependencies to an emitted symbol");
 
-      bool DependsOnSymbolInErrorState = false;
 
-      // Register dependencies, record whether any depenendency is in the error
-      // state.
-      for (auto &KV : Dependencies) {
-        assert(KV.first && "Null JITDylib in dependency?");
-        auto &OtherJITDylib = *KV.first;
-        auto &DepsOnOtherJITDylib = MI.UnemittedDependencies[&OtherJITDylib];
 
-        for (auto &OtherSymbol : KV.second) {
 
-          // Check the sym entry for the dependency.
-          auto OtherSymI = OtherJITDylib.Symbols.find(OtherSymbol);
 
-          // Assert that this symbol exists and has not reached the ready state
-          // already.
-          assert(OtherSymI != OtherJITDylib.Symbols.end() &&
-                 "Dependency on unknown symbol");
 
-          auto &OtherSymEntry = OtherSymI->second;
 
-          // If the other symbol is already in the Ready state then there's no
-          // dependency to add.
-          if (OtherSymEntry.getState() == SymbolState::Ready)
-            continue;
 
-          // If the dependency is in an error state then note this and continue,
-          // we will move this symbol to the error state below.
-          if (OtherSymEntry.getFlags().hasError()) {
-            DependsOnSymbolInErrorState = true;
-            continue;
-          }
 
-          // If the dependency was not in the error state then add it to
-          // our list of dependencies.
-          auto &OtherMI = OtherJITDylib.MaterializingInfos[OtherSymbol];
 
-          if (OtherSymEntry.getState() == SymbolState::Emitted)
-            transferEmittedNodeDependencies(MI, Name, OtherMI);
-          else if (&OtherJITDylib != this || OtherSymbol != Name) {
-            OtherMI.Dependants[this].insert(Name);
-            DepsOnOtherJITDylib.insert(OtherSymbol);
-          }
-        }
 
-        if (DepsOnOtherJITDylib.empty())
-          MI.UnemittedDependencies.erase(&OtherJITDylib);
-      }
 
-      // If this symbol dependended on any symbols in the error state then move
-      // this symbol to the error state too.
-      if (DependsOnSymbolInErrorState)
-        Symbols[Name].setFlags(Symbols[Name].getFlags() | JITSymbolFlags::HasError);
+      Symbols[Name].setFlags(Symbols[Name].getFlags() |
+                             JITSymbolFlags::HasError);
 
-      return Error::success();
-    });
 }
 
-bool JITDylib::resolve(const SymbolMap &Resolved) {
-  SymbolNameSet SymbolsInErrorState;
+Error JITDylib::resolve(const SymbolMap &Resolved) {
   AsynchronousSymbolQuerySet CompletedQueries;
 
-  ES.runSessionLocked([&, this]() {
-
+  auto SymbolsInErrorState = ES.runSessionLocked([&, this]()
+                                                     -> Expected<
+                                                         SymbolNameSet> {
     if (!Open)
-      false;
+      return make_error<JITDylibDestroyed>();
 
     struct WorklistEntry {
       SymbolTable::iterator SymI;
       JITEvaluatedSymbol ResolvedSym;
     };
 
+    SymbolNameSet SymbolsInErrorState;
     std::vector<WorklistEntry> Worklist;
     Worklist.reserve(Resolved.size());
 
     // Build worklist and check for any symbols in the error state.
     for (const auto &KV : Resolved) {
 
       assert(!KV.second.getFlags().hasError() &&
              "Resolution result can not have error flag set");
for (const auto &KV : Resolved) {
 
         Worklist.push_back(
             {SymI, JITEvaluatedSymbol(KV.second.getAddress(), Flags)});
       }
     }
 
     // If any symbols were in the error state then bail out.
     if (!SymbolsInErrorState.empty())
-      return;
+      return SymbolsInErrorState;
 
     while (!Worklist.empty()) {
       auto SymI = Worklist.back().SymI;
       auto ResolvedSym = Worklist.back().ResolvedSym;
       Worklist.pop_back();
 
       auto &Name = SymI->first;
 
while (!Worklist.empty()) {
       auto &MI = MII->second;
       for (auto &Q : MI.takeQueriesMeeting(SymbolState::Resolved)) {
         Q->notifySymbolMetRequiredState(Name, ResolvedSym);
         Q->removeQueryDependence(*this, Name);
         if (Q->isComplete())
           CompletedQueries.insert(std::move(Q));
       }
     }
+
+    return SymbolNameSet();
   });
 
-  assert((SymbolsInErrorState.empty() || CompletedQueries.empty()) &&
+  if (!SymbolsInErrorState)
+    return SymbolsInErrorState.takeError();
+
+  assert((SymbolsInErrorState->empty() || CompletedQueries.empty()) &&
          "Can't fail symbols and completed queries at the same time");
 
   // If we failed any symbols then return an error.
-  if (!SymbolsInErrorState.empty()) {
+  if (!SymbolsInErrorState->empty()) {
     auto FailedSymbolsDepMap = std::make_shared<SymbolDependenceMap>();
-    (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
+    (*FailedSymbolsDepMap)[this] = std::move(*SymbolsInErrorState);
     return make_error<FailedToMaterialize>(std::move(FailedSymbolsDepMap));
   }
 
   // Otherwise notify all the completed queries.
   for (auto &Q : CompletedQueries) {
     assert(Q->isComplete() && "Q not completed");
     Q->handleComplete();
   }
 
   return Error::success();
 }
 
 Error JITDylib::emit(const SymbolFlagsMap &Emitted) {
   AsynchronousSymbolQuerySet CompletedQueries;
-  SymbolNameSet SymbolsInErrorState;
   DenseMap<JITDylib *, SymbolNameVector> ReadySymbols;
 
-  ES.runSessionLocked([&, this]() {
-
+  auto SymbolsInErrorState = ES.runSessionLocked([&, this]()
+                                                     -> Expected<
+                                                         SymbolNameSet> {
     if (!Open)
-      return make_error<TargetJITDylibDestroyed>();
+      return make_error<JITDylibDestroyed>();
 
+    SymbolNameSet SymbolsInErrorState;
     std::vector<SymbolTable::iterator> Worklist;
 
     // Scan to build worklist, record any symbols in the erorr state.
     for (const auto &KV : Emitted) {
       auto &Name = KV.first;
 
       auto SymI = Symbols.find(Name);
       assert(SymI != Symbols.end() && "No symbol table entry for Name");
 
       if (SymI->second.getFlags().hasError())
         SymbolsInErrorState.insert(Name);
       else
         Worklist.push_back(SymI);
     }
 
     // If any symbols were in the error state then bail out.
     if (!SymbolsInErrorState.empty())
-      return;
+      return SymbolsInErrorState;
 
     // Otherwise update dependencies and move to the emitted state.
     while (!Worklist.empty()) {
       auto SymI = Worklist.back();
       Worklist.pop_back();
 
       auto &Name = SymI->first;
       auto &SymEntry = SymI->second;
while (!Worklist.empty()) {
         for (auto &Q : MI.takeQueriesMeeting(SymbolState::Ready)) {
           Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
           if (Q->isComplete())
             CompletedQueries.insert(Q);
           Q->removeQueryDependence(*this, Name);
         }
       }
     }
+
+    return SymbolNameSet();
   });
 
-  assert((SymbolsInErrorState.empty() || CompletedQueries.empty()) &&
+  if (!SymbolsInErrorState)
+    return SymbolsInErrorState.takeError();
+
+  assert((SymbolsInErrorState->empty() || CompletedQueries.empty()) &&
          "Can't fail symbols and completed queries at the same time");
 
   // If we failed any symbols then return an error.
-  if (!SymbolsInErrorState.empty()) {
+  if (!SymbolsInErrorState->empty()) {
     auto FailedSymbolsDepMap = std::make_shared<SymbolDependenceMap>();
-    (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
+    (*FailedSymbolsDepMap)[this] = std::move(*SymbolsInErrorState);
     return make_error<FailedToMaterialize>(std::move(FailedSymbolsDepMap));
   }
 
   // Otherwise notify all the completed queries.
   for (auto &Q : CompletedQueries) {
     assert(Q->isComplete() && "Q is not complete");
     Q->handleComplete();
   }
 
   return Error::success();
 }
 
-NotifyFailedResult JITDylib::notifyFailed(FailedSymbolsWorklist Worklist) {
-  NotifyFailedResult NFR;
-  NFR.FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
+JITDylib::NotifyFailedResult
+JITDylib::notifyFailed(FailedSymbolsWorklist Worklist) {
 
   // Failing no symbols is a no-op.
   if (Worklist.empty())
-    return;
+    return NotifyFailedResult();
+
+  NotifyFailedResult NFR;
+  NFR.FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
 
   auto &ES = Worklist.front().first->getExecutionSession();
 
   ES.runSessionLocked([&]() {
 
     // If the JITDylib for the first entry is closed then just bail out:
     // all symbols in this JITDylib have already been failed.
     if (!Worklist.front().first->Open)
while (!Worklist.empty()) {
              "Can not delete MaterializingInfo with queries pending");
       JD.MaterializingInfos.erase(MII);
     }
   });
 
   return NFR;
 }
 
-NotifyFailedResult JITDylib::prepareForRemoval() {
+JITDylib::NotifyFailedResult JITDylib::prepareForRemoval() {
   // Order is important here:
   // 1. Notify materializing symbols that they've failed (collect queries to
   //    fail but don't execute them).
   // 2. Move the JITDylib to a closed state.
   // 3. Clean up other members (except the JITDylib name).
 
-  FailSymbolsWorklist FSW;
-  for (auto &KV : MaterializingInfosMap)
+  FailedSymbolsWorklist FSW;
+  for (auto &KV : MaterializingInfos)
     FSW.push_back(std::make_pair(this, KV.first));
   auto NFR = notifyFailed(std::move(FSW));
   Open = false;
 
   // Now we can erase all other members (except the JITDylib name).
   Symbols.clear();
   DefGenerators.clear();
   UnmaterializedInfos.clear();
   MaterializingInfos.clear();
   LinkOrder.clear();
+
+  return NFR;
 }
 
 void JITDylib::setLinkOrder(JITDylibSearchOrder NewLinkOrder,
                             bool LinkAgainstThisJITDylibFirst) {
   ES.runSessionLocked([&]() {
     if (LinkAgainstThisJITDylibFirst) {
       LinkOrder.clear();
       if (NewLinkOrder.empty() || NewLinkOrder.front().first != this)
Expected<DenseMap<JITDylib *, SymbolMap>> Platform::lookupInitSymbols(
   CV.wait(Lock, [&] { return Count == 0 || CompoundErr; });
 
   if (CompoundErr)
     return std::move(CompoundErr);
 
   return std::move(CompoundResult);
 }
 
 JITDylibDestructionListener::~JITDylibDestructionListener() {}
 
 ExecutionSession::ExecutionSession(std::shared_ptr<SymbolStringPool> SSP)
     : SSP(SSP ? std::move(SSP) : std::make_shared<SymbolStringPool>()) {
 }
 
+void ExecutionSession::deregisterJITDylibDestructionListener(
+    JITDylibDestructionListener &L) {
+  runSessionLocked([&]() {
+    auto JDI = JITDylibDestructionListeners.rbegin();
+    auto JDE = JITDylibDestructionListeners.rend();
+    for (; JDI != JDE; ++JDI) {
+      if (*JDI == &L) {
+        JITDylibDestructionListeners.erase(JDI.base() - 1);
+        break;
+      }
+    }
+    assert(JDI != JDE && "No such listener registered");
+  });
+}
+
 JITDylib *ExecutionSession::getJITDylibByName(StringRef Name) {
   return runSessionLocked([&, this]() -> JITDylib * {
     for (auto &JD : JDs)
       if (JD->getName() == Name)
         return JD.get();
     return nullptr;
   });
 }
 
 JITDylib &ExecutionSession::createBareJITDylib(std::string Name) {
   assert(!getJITDylibByName(Name) && "JITDylib with that name already exists");
   return runSessionLocked([&, this]() -> JITDylib & {
+    LLVM_DEBUG(dbgs() << "Creating JITDylib \"" << Name << "\"\n");
     JDs.push_back(
         std::shared_ptr<JITDylib>(new JITDylib(*this, std::move(Name))));
     return *JDs.back();
   });
 }
 
 Expected<JITDylib &> ExecutionSession::createJITDylib(std::string Name) {
   auto &JD = createBareJITDylib(Name);
   if (P)
     if (auto Err = P->setupJITDylib(JD))
       return std::move(Err);
   return JD;
 }
 
 Error ExecutionSession::destroyJITDylib(JITDylib &JD) {
   std::shared_ptr<JITDylib> OwnedJD;
 
   auto NFR = runSessionLocked([&]() {
     // Remove JD from JDs list, and unlink it from all other JITDylibs.
+
+    assert(JD.Open && "Duplicate call to destroyJITDylib?");
+
+    LLVM_DEBUG(dbgs() << "Destroying JITDylib \"" << JD.getName() << "\"\n");
     for (auto JDI = JDs.begin(); JDI != JDs.end();) {
       if (JDI->get() == &JD) {
         OwnedJD = std::move(*JDI);
         JDI = JDs.erase(JDI);
       } else {
-        (*JDI)->removeFromSearchOrder(JD);
+        (*JDI)->removeFromLinkOrder(JD);
         ++JDI;
       }
     }
 
     // Prepare JD for removal.
     return JD.prepareForRemoval();
   });
 
   // Run any failed queries.
   for (auto &Q : NFR.FailedQueries)
     Q->handleFailed(make_error<FailedToMaterialize>(NFR.FailedSymbolsMap));
 
   // Notify all JITDylib destruction listeners.
   Error Err = Error::success();
   for (auto *L : reverse(JITDylibDestructionListeners))
     Err = joinErrors(std::move(Err), L->notifyDestroyingJITDylib(JD));
 
   return Err;
 }
 
+std::vector<JITDylib *> ExecutionSession::getJITDylibsInReverseLinkOrder() {
+  return runSessionLocked([&]() {
+    std::vector<JITDylib *> Result;
+    Result.reserve(JDs.size());
+
+    std::vector<JITDylib *> Worklist;
+    Worklist.reserve(JDs.size());
+    DenseSet<JITDylib *> Visited;
+
+    for (auto &TopLevelJD : JDs) {
+
+      Worklist.push_back(TopLevelJD.get());
+
+      while (!Worklist.empty()) {
+        auto &JD = *Worklist.back();
+        Worklist.pop_back();
+        if (Visited.count(&JD))
+          continue;
+        Visited.insert(&JD);
+
+        JD.withLinkOrderDo([&](const JITDylibSearchOrder &LinkOrder) {
+          for (auto &KV : reverse(LinkOrder))
+            Worklist.push_back(KV.first);
+        });
+        Result.push_back(&JD);
+      }
+    }
+
+    std::reverse(Result.begin(), Result.end());
+    return Result;
+  });
+}
+
 void ExecutionSession::legacyFailQuery(AsynchronousSymbolQuery &Q, Error Err) {
   assert(!!Err && "Error should be in failure state");
 
   bool SendErrorToQuery;
   runSessionLocked([&]() {
     Q.detach();
     SendErrorToQuery = Q.canStillFail();
   });
auto LodgingErr = runSessionLocked([&]() -> Error {
 
     if (auto Err = LodgeQuery()) {
       // Query failed.
 
       // Disconnect the query from its dependencies.
       Q->detach();
 
       // Replace the MUs.
+      //
+      // We can 'cantFail' this replace operation because lookup's contract
+      // requires all JITDylibs in the search order to be valid, and the
+      // only way replace can fail is if the target has been destroyed
+      // already.
       for (auto &KV : CollectedMUsMap)
         for (auto &MU : KV.second)
-          KV.first->replace(std::move(MU));
+          cantFail(KV.first->replace(std::move(MU)));
 
       return Err;
     }
 
     // Query lodged successfully.
 
     // Record whether this query is fully ready / resolved. We will use
     // this to call handleFullyResolved/handleFullyReady outside the session

llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp

 StringRef LazyReexportsMaterializationUnit::getName() const {
   return "<Lazy Reexports>";
 }
 
 void LazyReexportsMaterializationUnit::materialize(
     MaterializationResponsibility R) {
   auto RequestedSymbols = R.getRequestedSymbols();
 
+  if (R.shouldBailOut(RequestedSymbols.takeError()))
+    return;
+
   SymbolAliasMap RequestedAliases;
-  for (auto &RequestedSymbol : RequestedSymbols) {
+  for (auto &RequestedSymbol : *RequestedSymbols) {
     auto I = CallableAliases.find(RequestedSymbol);
     assert(I != CallableAliases.end() && "Symbol not found in alias map?");
     RequestedAliases[I->first] = std::move(I->second);
     CallableAliases.erase(I);
   }
 
   if (!CallableAliases.empty())
+    if (R.shouldBailOut(
             R.replace(lazyReexports(LCTManager, ISManager, SourceJD,
-                            std::move(CallableAliases), AliaseeTable));
+                                    std::move(CallableAliases), AliaseeTable))))
+      return;
 
   IndirectStubsManager::StubInitsMap StubInits;
   for (auto &Alias : RequestedAliases) {
 
     auto CallThroughTrampoline = LCTManager.getCallThroughTrampoline(
         SourceJD, Alias.second.Aliasee,
         [&ISManager = this->ISManager,
          StubSym = Alias.first](JITTargetAddress ResolvedAddr) -> Error {

llvm/lib/ExecutionEngine/Orc/Legacy.cpp

void JITSymbolResolverAdapter::lookup(const LookupSet &Symbols,
 
   auto Q = std::make_shared<AsynchronousSymbolQuery>(
       SymbolLookupSet(InternedSymbols), SymbolState::Resolved,
       std::move(OnResolvedWithUnwrap));
 
   auto Unresolved = R.lookup(Q, InternedSymbols);
   if (Unresolved.empty()) {
     if (MR)
-      MR->addDependenciesForAll(Q->QueryRegistrations);
+      consumeError(MR->addDependenciesForAll(Q->QueryRegistrations));
   } else
     ES.legacyFailQuery(*Q, make_error<SymbolsNotFound>(std::move(Unresolved)));
 }
 
 Expected<JITSymbolResolverAdapter::LookupSet>
 JITSymbolResolverAdapter::getResponsibilitySet(const LookupSet &Symbols) {
   SymbolNameSet InternedSymbols;
   for (auto &S : Symbols)

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

for (auto &KV : Symbols) {
         break;
       case jitlink::SymbolLookupFlags::WeaklyReferencedSymbol:
         LookupFlags = orc::SymbolLookupFlags::WeaklyReferencedSymbol;
         break;
       }
       LookupSet.add(ES.intern(KV.first), LookupFlags);
     }
 
+    for (auto &KV : InternalNamedSymbolDeps) {
+      SymbolDependenceMap InternalDeps;
+      InternalDeps[&MR.getTargetJITDylib()] = std::move(KV.second);
+      if (auto Err = MR.addDependencies(KV.first, InternalDeps)) {
+        LC->run(std::move(Err));
+        return;
+      }
+    }
+
     // OnResolve -- De-intern the symbols and pass the result to the linker.
     auto OnResolve = [this, LookupContinuation = std::move(LC)](
                          Expected<SymbolMap> Result) mutable {
       auto Main = Layer.getExecutionSession().intern("_main");
       if (!Result)
         LookupContinuation->run(Result.takeError());
       else {
         AsyncLookupResult LR;
         for (auto &KV : *Result)
           LR[*KV.first] = KV.second;
         LookupContinuation->run(std::move(LR));
       }
     };
 
-    for (auto &KV : InternalNamedSymbolDeps) {
-      SymbolDependenceMap InternalDeps;
-      InternalDeps[&MR.getTargetJITDylib()] = std::move(KV.second);
-      MR.addDependencies(KV.first, InternalDeps);
-    }
-
     ES.lookup(LookupKind::Static, LinkOrder, std::move(LookupSet),
               SymbolState::Resolved, std::move(OnResolve),
               [this](const SymbolDependenceMap &Deps) {
                 registerDependencies(Deps);
               });
   }
 
   void notifyResolved(LinkGraph &G) override {
for (auto &NamedDepsEntry : ExternalNamedSymbolDeps) {
         for (const auto &S : Symbols)
           if (NameDeps.count(S))
             DepsForJD.insert(S);
 
         if (DepsForJD.empty())
           SymbolDeps.erase(&SourceJD);
       }
 
-      MR.addDependencies(Name, SymbolDeps);
+      if (MR.shouldBailOut(MR.addDependencies(Name, SymbolDeps)))
+        return;
     }
   }
 
   ObjectLinkingLayer &Layer;
   MaterializationResponsibility MR;
   std::unique_ptr<MemoryBuffer> ObjBuffer;
   DenseMap<SymbolStringPtr, SymbolNameSet> ExternalNamedSymbolDeps;
   DenseMap<SymbolStringPtr, SymbolNameSet> InternalNamedSymbolDeps;
 };
 
 ObjectLinkingLayer::Plugin::~Plugin() {}
 
 ObjectLinkingLayer::ObjectLinkingLayer(
     ExecutionSession &ES, std::unique_ptr<JITLinkMemoryManager> MemMgr)
     : ObjectLayer(ES), MemMgr(std::move(MemMgr)) {
   ES.registerJITDylibDestructionListener(*this);
 }
 
+ObjectLinkingLayer::~ObjectLinkingLayer() {
+  getExecutionSession().deregisterJITDylibDestructionListener(*this);
+}
+
 void ObjectLinkingLayer::emit(MaterializationResponsibility R,
                               std::unique_ptr<MemoryBuffer> O) {
   assert(O && "Object must not be null");
   jitLink(std::make_unique<ObjectLinkingLayerJITLinkContext>(
       *this, std::move(R), std::move(O)));
 }
 
 Error ObjectLinkingLayer::notifyDestroyingJITDylib(JITDylib &JD) {

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

auto OnResolvedWithUnwrap =
           LookupResult Result;
           for (auto &KV : *InternedResult)
             Result[*KV.first] = std::move(KV.second);
           OnResolved(Result);
         };
 
     // Register dependencies for all symbols contained in this set.
     auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
-      MR.addDependenciesForAll(Deps);
+      consumeError(MR.addDependenciesForAll(Deps));
     };
 
     JITDylibSearchOrder LinkOrder;
     MR.getTargetJITDylib().withLinkOrderDo(
         [&](const JITDylibSearchOrder &LO) { LinkOrder = LO; });
     ES.lookup(LookupKind::Static, LinkOrder, InternedSymbols,
               SymbolState::Resolved, std::move(OnResolvedWithUnwrap),
               RegisterDependencies);

 
 } // end anonymous namespace
 
 namespace llvm {
 namespace orc {
 
 RTDyldObjectLinkingLayer::RTDyldObjectLinkingLayer(
     ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager)
-    : ObjectLayer(ES), GetMemoryManager(GetMemoryManager) {}
+    : ObjectLayer(ES), GetMemoryManager(GetMemoryManager) {
+  ES.registerJITDylibDestructionListener(*this);
+}
 
 RTDyldObjectLinkingLayer::~RTDyldObjectLinkingLayer() {
+  {
     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
-  for (auto &MemMgr : MemMgrs) {
+    assert(LoadedObjInfos.empty() && "LoadedObjInfos still attached");
+    for (auto &KV : MemMgrs) {
+      for (auto &MemMgr : KV.second) {
         for (auto *L : EventListeners)
           L->notifyFreeingObject(
               static_cast<uint64_t>(reinterpret_cast<uintptr_t>(MemMgr.get())));
         MemMgr->deregisterEHFrames();
       }
     }
+  }
+  getExecutionSession().deregisterJITDylibDestructionListener(*this);
+}
 
 void RTDyldObjectLinkingLayer::emit(MaterializationResponsibility R,
                                     std::unique_ptr<MemoryBuffer> O) {
   assert(O && "Object must not be null");
 
   // This method launches an asynchronous link step that will fulfill our
   // materialization responsibility. We need to switch R to be heap
   // allocated before that happens so it can live as long as the asynchronous
auto InternalSymbols = std::make_shared<std::set<StringRef>>();
     for (auto &Sym : (*Obj)->symbols()) {
 
       // Skip file symbols.
       if (auto SymType = Sym.getType()) {
         if (*SymType == object::SymbolRef::ST_File)
           continue;
       } else {
         ES.reportError(SymType.takeError());
-        R.failMaterialization();
+        SharedR->failMaterialization();
         return;
       }
 
       Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
       if (!SymFlagsOrErr) {
         // TODO: Test this error.
         ES.reportError(SymFlagsOrErr.takeError());
-        R.failMaterialization();
+        SharedR->failMaterialization();
         return;
       }
 
       // Don't include symbols that aren't global.
       if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) {
         if (auto SymName = Sym.getName())
           InternalSymbols->insert(*SymName);
         else {
           ES.reportError(SymName.takeError());
-          R.failMaterialization();
+          SharedR->failMaterialization();
           return;
         }
       }
     }
   }
 
   RuntimeDyld::MemoryManager *MemMgr = nullptr;
   // Create a record a memory manager for this object.
   {
     auto Tmp = GetMemoryManager();
     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
-    MemMgrs.push_back(std::move(Tmp));
-    MemMgr = MemMgrs.back().get();
+    auto &JDMemMgrs = MemMgrs[&SharedR->getTargetJITDylib()];
+    JDMemMgrs.push_back(std::move(Tmp));
+    MemMgr = JDMemMgrs.back().get();
   }
 
   JITDylibSearchOrderResolver Resolver(*SharedR);
 
   jitLinkForORC(
       object::OwningBinary<object::ObjectFile>(std::move(*Obj), std::move(O)),
       *MemMgr, Resolver, ProcessAllSections,
       [this, SharedR, MemMgr, InternalSymbols](
           const object::ObjectFile &Obj,
           std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
           std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
         return onObjLoad(*SharedR, Obj, MemMgr, std::move(LoadedObjInfo),
                          ResolvedSymbols, *InternalSymbols);
       },
       [this, SharedR, MemMgr](object::OwningBinary<object::ObjectFile> Obj,
                               Error Err) mutable {
         onObjEmit(*SharedR, std::move(Obj), MemMgr, std::move(Err));
       });
 }
 
+Error RTDyldObjectLinkingLayer::notifyDestroyingJITDylib(JITDylib &JD) {
+  std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
+  auto JDI = MemMgrs.find(&JD);
+  if (JDI != MemMgrs.end()) {
+    auto &JDMemMgrs = JDI->second;
+    for (auto &MemMgr : JDMemMgrs) {
+      for (auto *L : EventListeners)
+        L->notifyFreeingObject(
+            static_cast<uint64_t>(reinterpret_cast<uintptr_t>(MemMgr.get())));
+      MemMgr->deregisterEHFrames();
+    }
+    MemMgrs.erase(JDI);
+  }
+  return Error::success();
+}
+
 void RTDyldObjectLinkingLayer::registerJITEventListener(JITEventListener &L) {
   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
   assert(llvm::none_of(EventListeners,
                        [&](JITEventListener *O) { return O == &L; }) &&
          "Listener has already been registered");
   EventListeners.push_back(&L);
 }
 

llvm/lib/ExecutionEngine/OrcError/OrcError.cpp

case OrcErrorCode::UnknownErrorCodeFromRemote:
       return "Unknown error returned from remote RPC function "
              "(Use StringError to get error message)";
     case OrcErrorCode::UnknownResourceHandle:
       return "Unknown resource handle";
     case OrcErrorCode::MissingSymbolDefinitions:
       return "MissingSymbolsDefinitions";
     case OrcErrorCode::UnexpectedSymbolDefinitions:
       return "UnexpectedSymbolDefinitions";
+    case OrcErrorCode::JITDylibDestroyed:
+      return "JITDylib already destroyed";
     }
     llvm_unreachable("Unhandled error code");
   }
 };
 
 static ManagedStatic<OrcErrorCategory> OrcErrCat;
 }
 

llvm/unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp

auto OnCompletion = [&](Expected<SymbolMap> Result) {
     cantFail(std::move(Result));
     FooReady = true;
   };
 
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet({Foo}), SymbolState::Ready, OnCompletion,
             NoDependenciesToRegister);
 
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}}));
   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
       << "No symbols marked failed, but Foo failed to resolve";
   EXPECT_THAT_ERROR(FooR->notifyEmitted(), Succeeded())
       << "No symbols marked failed, but Foo failed to emit";
 
   EXPECT_TRUE(FooReady)
     << "Self-dependency prevented symbol from being marked ready";
 }
ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Baz), SymbolState::Resolved,
             std::move(OnBazResolution), NoDependenciesToRegister);
 
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Baz), SymbolState::Ready, std::move(OnBazReady),
             NoDependenciesToRegister);
 
   // Add a circular dependency: Foo -> Bar, Bar -> Baz, Baz -> Foo.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
-  BarR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
-  BazR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
+  cantFail(BarR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}}));
+  cantFail(BazR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}}));
 
   // Add self-dependencies for good measure. This tests that the implementation
   // of addDependencies filters these out.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
-  BarR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
-  BazR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}}));
+  cantFail(BarR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
+  cantFail(BazR->addDependenciesForAll({{&JD, SymbolNameSet({Baz})}}));
 
   // Check that nothing has been resolved yet.
   EXPECT_FALSE(FooResolved) << "\"Foo\" should not be resolved yet";
   EXPECT_FALSE(BarResolved) << "\"Bar\" should not be resolved yet";
   EXPECT_FALSE(BazResolved) << "\"Baz\" should not be resolved yet";
 
   // Resolve the symbols (but do not emit them).
   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
auto OnBarReady = [&](Expected<SymbolMap> Result) {
     OnBarReadyRun = true;
   };
 
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Bar), SymbolState::Ready, std::move(OnBarReady),
             NoDependenciesToRegister);
 
   // Add a dependency by Foo on Bar.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
 
   // Fail bar.
   BarR->failMaterialization();
 
   // Verify that queries on Bar failed, but queries on Foo have not yet.
   EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
   EXPECT_FALSE(OnFooReadyRun) << "Query for \"Foo\" was run unexpectedly";
 
auto OnBarReady = [&](Expected<SymbolMap> Result) {
     OnBarReadyRun = true;
   };
 
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Bar), SymbolState::Ready, std::move(OnBarReady),
             NoDependenciesToRegister);
 
   // Add a dependency by Foo on Bar and vice-versa.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
-  BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
+  cantFail(BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}}));
 
   // Fail bar.
   BarR->failMaterialization();
 
   // Verify that queries on Bar failed, but queries on Foo have not yet.
   EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
   EXPECT_FALSE(OnFooReadyRun) << "Query for \"Foo\" was run unexpectedly";
 
TEST_F(CoreAPIsStandardTest, AddDependencyOnFailedSymbol) {
   BarR->failMaterialization();
 
   // We expect Bar's query to fail immediately, but Foo's query not to have run
   // yet.
   EXPECT_TRUE(OnBarReadyRun) << "Query for \"Bar\" was not run";
   EXPECT_FALSE(OnFooReadyRun) << "Query for \"Foo\" should not have run yet";
 
   // Add dependency of Foo on Bar.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
 
   // Check that we can still resolve Foo (even though it has been failed).
   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Failed())
       << "Expected resolution for \"Foo\" to fail.";
 
   FooR->failMaterialization();
 
   // Foo's query should have failed before we return from addDependencies.
auto OnBarReady = [&](Expected<SymbolMap> Result) {
     OnBarReadyRun = true;
   };
 
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Bar), SymbolState::Ready, std::move(OnBarReady),
             NoDependenciesToRegister);
 
   // Add a dependency by Foo on Bar and vice-versa.
-  FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}});
-  BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}});
+  cantFail(FooR->addDependenciesForAll({{&JD, SymbolNameSet({Bar})}}));
+  cantFail(BarR->addDependenciesForAll({{&JD, SymbolNameSet({Foo})}}));
 
   // Materialize Foo.
   EXPECT_THAT_ERROR(FooR->notifyResolved({{Foo, FooSym}}), Succeeded())
       << "Expected resolution for \"Foo\" to succeed.";
   EXPECT_THAT_ERROR(FooR->notifyEmitted(), Succeeded())
       << "Expected emission for \"Foo\" to succeed.";
 
   // Fail bar.
auto MU = std::make_unique<SimpleMaterializationUnit>(
               // on or care about baz, but use it to trigger failure of
               // this materialization before Baz has been finalized in
               // order to test that error propagation is correct in this
               // scenario.
               cantFail(std::move(Result));
               R.failMaterialization();
             },
             [&](const SymbolDependenceMap &Deps) {
-              R.addDependenciesForAll(Deps);
+              cantFail(R.addDependenciesForAll(Deps));
             });
       });
 
   cantFail(JD.define(MU));
 
   auto Result =
       ES.lookup(makeJITDylibSearchOrder(&JD), SymbolLookupSet({Foo, Bar}));
 
TEST_F(CoreAPIsStandardTest, TestGetRequestedSymbolsAndReplace) {
   SymbolNameSet Names({Foo, Bar});
 
   bool FooMaterialized = false;
   bool BarMaterialized = false;
 
   auto MU = std::make_unique<SimpleMaterializationUnit>(
       SymbolFlagsMap({{Foo, FooSym.getFlags()}, {Bar, BarSym.getFlags()}}),
       [&](MaterializationResponsibility R) {
-        auto Requested = R.getRequestedSymbols();
+        auto Requested = cantFail(R.getRequestedSymbols());
         EXPECT_EQ(Requested.size(), 1U) << "Expected one symbol requested";
         EXPECT_EQ(*Requested.begin(), Foo) << "Expected \"Foo\" requested";
 
         auto NewMU = std::make_unique<SimpleMaterializationUnit>(
             SymbolFlagsMap({{Bar, BarSym.getFlags()}}),
             [&](MaterializationResponsibility R2) {
               cantFail(R2.notifyResolved(SymbolMap({{Bar, BarSym}})));
               cantFail(R2.notifyEmitted());
               BarMaterialized = true;
             });
 
-        R.replace(std::move(NewMU));
+        cantFail(R.replace(std::move(NewMU)));
 
         cantFail(R.notifyResolved(SymbolMap({{Foo, FooSym}})));
         cantFail(R.notifyEmitted());
 
         FooMaterialized = true;
       });
 
   cantFail(JD.define(MU));