[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

1763

= 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/examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h

public:
 
   JITSymbol findSymbol(const std::string Name) {
     std::string MangledName;
     raw_string_ostream MangledNameStream(MangledName);
     Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
     return CODLayer.findSymbol(MangledNameStream.str(), true);
   }
 
-  void removeModule(VModuleKey K) {
-    cantFail(CODLayer.removeModule(K));
-  }
+  void removeModule(VModuleKey K) { cantFail(CODLayer.removeModule(K)); }
 
 private:
   std::unique_ptr<Module> optimizeModule(std::unique_ptr<Module> M) {
     // Create a function pass manager.
     auto FPM = std::make_unique<legacy::FunctionPassManager>(M.get());
 
     // Add some optimizations.
     FPM->add(createInstructionCombiningPass());

llvm/examples/OrcV2Examples/CMakeLists.txt

 add_subdirectory(LLJITDumpObjects)
+add_subdirectory(LLJITRemoveCode)
 add_subdirectory(LLJITWithCustomObjectLinkingLayer)
 add_subdirectory(LLJITWithGDBRegistrationListener)
 add_subdirectory(LLJITWithInitializers)
 add_subdirectory(LLJITWithLazyReexports)
 add_subdirectory(LLJITWithObjectCache)
 add_subdirectory(LLJITWithObjectLinkingLayerPlugin)
 add_subdirectory(OrcV2CBindingsAddObjectFile)
 add_subdirectory(OrcV2CBindingsBasicUsage)
 add_subdirectory(OrcV2CBindingsReflectProcessSymbols)

llvm/examples/OrcV2Examples/ExampleModules.h

const llvm::StringRef Add1Example =
     R"(
   define i32 @add1(i32 %x) {
   entry:
     %r = add nsw i32 %x, 1
     ret i32 %r
   }
 )";
 
+const llvm::StringRef NoopEntryPointExample =
+    R"(
+  define void @entry() {
+  entry:
+    ret void
+  }
+)";
+
 inline llvm::Expected<llvm::orc::ThreadSafeModule>
 parseExampleModule(llvm::StringRef Source, llvm::StringRef Name) {
   using namespace llvm;
   using namespace llvm::orc;
 
   auto Ctx = std::make_unique<LLVMContext>();
   SMDiagnostic Err;
   auto M = parseIR(MemoryBufferRef(Source, Name), Err, *Ctx);

llvm/examples/OrcV2Examples/LLJITRemoveCode/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Core
+  ExecutionEngine
+  IRReader
+  JITLink
+  OrcJIT
+  Support
+  nativecodegen
+  )
+
+add_llvm_example(LLJITRemoveCode
+  LLJITRemoveCode.cpp
+  )

llvm/examples/OrcV2Examples/LLJITRemoveCode/LLJITRemoveCode.cpp

+//===--------------- LLJITWithCustomObjectLinkingLayer.cpp ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file shows how to switch LLJIT to use a custom object linking layer (we
+// use ObjectLinkingLayer, which is backed by JITLink, as an example).
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "../ExampleModules.h"
+
+using namespace llvm;
+using namespace llvm::orc;
+
+ExitOnError ExitOnErr;
+
+class MyPlugin : public ObjectLinkingLayer::Plugin {
+public:
+  Error notifyRemoving(JITDylib &JD) override {
+    dbgs() << "Removing resources for JITDylib " << JD.getName() << "\n";
+    return Error::success();
+  }
+};
+
+int main(int argc, char *argv[]) {
+  // Initialize LLVM.
+  InitLLVM X(argc, argv);
+
+  InitializeNativeTarget();
+  InitializeNativeTargetAsmPrinter();
+
+  cl::ParseCommandLineOptions(argc, argv, "LLJITWithObjectLinkingLayerPlugin");
+  ExitOnErr.setBanner(std::string(argv[0]) + ": ");
+
+  // Detect the host and set code model to small.
+  auto JTMB = ExitOnErr(JITTargetMachineBuilder::detectHost());
+  JTMB.setCodeModel(CodeModel::Small);
+
+  // Create an LLJIT instance with an ObjectLinkingLayer as the base layer.
+  // We attach our plugin in to the newly created ObjectLinkingLayer before
+  // returning it.
+  auto J = ExitOnErr(
+      LLJITBuilder()
+          .setJITTargetMachineBuilder(std::move(JTMB))
+          .setObjectLinkingLayerCreator(
+              [&](ExecutionSession &ES, const Triple &TT) {
+                // Create ObjectLinkingLayer.
+                auto ObjLinkingLayer = std::make_unique<ObjectLinkingLayer>(
+                    ES, std::make_unique<jitlink::InProcessMemoryManager>());
+                // Add an instance of our plugin.
+                ObjLinkingLayer->addPlugin(std::make_unique<MyPlugin>());
+                return ObjLinkingLayer;
+              })
+          .create());
+
+  auto M = ExitOnErr(parseExampleModule(NoopEntryPointExample, "test-module"));
+
+  auto &MyJD = ExitOnErr(J->getExecutionSession().createJITDylib("MyJD"));
+  ExitOnErr(J->addIRModule(MyJD, std::move(M)));
+
+  // Look up the JIT'd function, cast it to a function pointer, then call it.
+  auto EntrySym = ExitOnErr(J->lookup(MyJD, "entry"));
+  auto *Entry = (void (*)())EntrySym.getAddress();
+
+  // Call the entry point to make sure it executes successfully.
+  Entry();
+
+  // Now close the JITDylib.
+  ExitOnErr(J->getExecutionSession().destroyJITDylib(MyJD));
+
+  return 0;
+}

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

public:
   ///        this asserts that all symbols being tracked have been either
   ///        emitted or notified of an error.
   ~MaterializationResponsibility();
 
   /// Returns the target JITDylib that these symbols are being materialized
   ///        into.
   JITDylib &getTargetJITDylib() const { return JD; }
 
-  /// Returns the VModuleKey for this instance.
-  VModuleKey getVModuleKey() const { return K; }
-
   /// 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
public:
   /// 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).
   void 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,
-                                         VModuleKey NewKey = VModuleKey());
+  MaterializationResponsibility delegate(const SymbolNameSet &Symbols);
 
   void addDependencies(const SymbolStringPtr &Name,
                        const SymbolDependenceMap &Dependencies);
 
   /// Add dependencies that apply to all symbols covered by this instance.
   void addDependenciesForAll(const SymbolDependenceMap &Dependencies);
 
 private:
   /// Create a MaterializationResponsibility for the given JITDylib and
   ///        initial symbols.
   MaterializationResponsibility(JITDylib &JD, SymbolFlagsMap SymbolFlags,
-                                SymbolStringPtr InitSymbol, VModuleKey K)
+                                SymbolStringPtr InitSymbol)
       : JD(JD), SymbolFlags(std::move(SymbolFlags)),
-        InitSymbol(std::move(InitSymbol)), K(std::move(K)) {
+        InitSymbol(std::move(InitSymbol)) {
     assert(!this->SymbolFlags.empty() && "Materializing nothing?");
   }
 
   JITDylib &JD;
   SymbolFlagsMap SymbolFlags;
   SymbolStringPtr InitSymbol;
-  VModuleKey K;
 };
 
 /// A MaterializationUnit represents a set of symbol definitions that can
 ///        be materialized as a group, or individually discarded (when
 ///        overriding definitions are encountered).
 ///
 /// MaterializationUnits are used when providing lazy definitions of symbols to
 /// JITDylibs. The JITDylib will call materialize when the address of a symbol
 /// is requested via the lookup method. The JITDylib will call discard if a
 /// stronger definition is added or already present.
 class MaterializationUnit {
 public:
   MaterializationUnit(SymbolFlagsMap InitalSymbolFlags,
-                      SymbolStringPtr InitSymbol, VModuleKey K)
+                      SymbolStringPtr InitSymbol)
       : SymbolFlags(std::move(InitalSymbolFlags)),
-        InitSymbol(std::move(InitSymbol)), K(std::move(K)) {
+        InitSymbol(std::move(InitSymbol)) {
     assert((!this->InitSymbol || this->SymbolFlags.count(this->InitSymbol)) &&
            "If set, InitSymbol should appear in InitialSymbolFlags map");
   }
 
   virtual ~MaterializationUnit() {}
 
   /// Return the name of this materialization unit. Useful for debugging
   /// output.
   virtual StringRef getName() const = 0;
 
   /// Return the set of symbols that this source provides.
   const SymbolFlagsMap &getSymbols() const { return SymbolFlags; }
 
   /// Returns the initialization symbol for this MaterializationUnit (if any).
   const SymbolStringPtr &getInitializerSymbol() const { return InitSymbol; }
 
   /// Called by materialization dispatchers (see
   /// ExecutionSession::DispatchMaterializationFunction) to trigger
   /// materialization of this MaterializationUnit.
   void doMaterialize(JITDylib &JD) {
-    materialize(MaterializationResponsibility(
-        JD, std::move(SymbolFlags), std::move(InitSymbol), std::move(K)));
+    materialize(MaterializationResponsibility(JD, std::move(SymbolFlags),
+                                              std::move(InitSymbol)));
   }
 
   /// Called by JITDylibs to notify MaterializationUnits that the given symbol
   /// has been overridden.
   void doDiscard(const JITDylib &JD, const SymbolStringPtr &Name) {
     SymbolFlags.erase(Name);
     discard(JD, std::move(Name));
   }
 
 protected:
   SymbolFlagsMap SymbolFlags;
   SymbolStringPtr InitSymbol;
-  VModuleKey K;
 
 private:
   virtual void anchor();
 
   /// Implementations of this method should materialize all symbols
   ///        in the materialzation unit, except for those that have been
   ///        previously discarded.
   virtual void materialize(MaterializationResponsibility R) = 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
 /// materialized.
 class AbsoluteSymbolsMaterializationUnit : public MaterializationUnit {
 public:
-  AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols, VModuleKey K);
+  AbsoluteSymbolsMaterializationUnit(SymbolMap Symbols);
 
   StringRef getName() const override;
 
 private:
   void materialize(MaterializationResponsibility R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolMap &Symbols);
 
   SymbolMap Symbols;
 };
 
 /// Create an AbsoluteSymbolsMaterializationUnit with the given symbols.
 /// Useful for inserting absolute symbols into a JITDylib. E.g.:
 /// \code{.cpp}
 ///   JITDylib &JD = ...;
 ///   SymbolStringPtr Foo = ...;
 ///   JITEvaluatedSymbol FooSym = ...;
 ///   if (auto Err = JD.define(absoluteSymbols({{Foo, FooSym}})))
 ///     return Err;
 /// \endcode
 ///
 inline std::unique_ptr<AbsoluteSymbolsMaterializationUnit>
-absoluteSymbols(SymbolMap Symbols, VModuleKey K = VModuleKey()) {
+absoluteSymbols(SymbolMap Symbols) {
   return std::make_unique<AbsoluteSymbolsMaterializationUnit>(
-      std::move(Symbols), std::move(K));
+      std::move(Symbols));
 }
 
 /// A materialization unit for symbol aliases. Allows existing symbols to be
 /// aliased with alternate flags.
 class ReExportsMaterializationUnit : public MaterializationUnit {
 public:
   /// SourceJD is allowed to be nullptr, in which case the source JITDylib is
   /// taken to be whatever JITDylib these definitions are materialized in (and
   /// MatchNonExported has no effect). This is useful for defining aliases
   /// within a JITDylib.
   ///
   /// Note: Care must be taken that no sets of aliases form a cycle, as such
   ///       a cycle will result in a deadlock when any symbol in the cycle is
   ///       resolved.
   ReExportsMaterializationUnit(JITDylib *SourceJD,
                                JITDylibLookupFlags SourceJDLookupFlags,
-                               SymbolAliasMap Aliases, VModuleKey K);
+                               SymbolAliasMap Aliases);
 
   StringRef getName() const override;
 
 private:
   void materialize(MaterializationResponsibility R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);
 

 ///   SymbolStringPtr Baz = ...;
 ///   SymbolStringPtr Qux = ...;
 ///   if (auto Err = JD.define(symbolAliases({
 ///       {Baz, { Foo, JITSymbolFlags::Exported }},
 ///       {Qux, { Bar, JITSymbolFlags::Weak }}}))
 ///     return Err;
 /// \endcode
 inline std::unique_ptr<ReExportsMaterializationUnit>
-symbolAliases(SymbolAliasMap Aliases, VModuleKey K = VModuleKey()) {
+symbolAliases(SymbolAliasMap Aliases) {
   return std::make_unique<ReExportsMaterializationUnit>(
-      nullptr, JITDylibLookupFlags::MatchAllSymbols, std::move(Aliases),
-      std::move(K));
+      nullptr, JITDylibLookupFlags::MatchAllSymbols, std::move(Aliases));
 }
 
 /// Create a materialization unit for re-exporting symbols from another JITDylib
 /// with alternative names/flags.
 /// SourceJD will be searched using the given JITDylibLookupFlags.
 inline std::unique_ptr<ReExportsMaterializationUnit>
 reexports(JITDylib &SourceJD, SymbolAliasMap Aliases,
           JITDylibLookupFlags SourceJDLookupFlags =
-              JITDylibLookupFlags::MatchExportedSymbolsOnly,
-          VModuleKey K = VModuleKey()) {
+              JITDylibLookupFlags::MatchExportedSymbolsOnly) {
   return std::make_unique<ReExportsMaterializationUnit>(
-      &SourceJD, SourceJDLookupFlags, std::move(Aliases), std::move(K));
+      &SourceJD, SourceJDLookupFlags, std::move(Aliases));
 }
 
 /// Build a SymbolAliasMap for the common case where you want to re-export
 /// symbols from another JITDylib with the same linkage/flags.
 Expected<SymbolAliasMap>
 buildSimpleReexportsAAliasMap(JITDylib &SourceJD, const SymbolNameSet &Symbols);
 
 /// Represents the state that a symbol has reached during materialization.
public:
   /// Platform to install any JITDylib specific standard symbols (e.g
   /// __dso_handle).
   virtual Error setupJITDylib(JITDylib &JD) = 0;
 
   /// This method will be called under the ExecutionSession lock each time a
   /// MaterializationUnit is added to a JITDylib.
   virtual Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU) = 0;
 
-  /// This method will be called under the ExecutionSession lock when a
-  /// VModuleKey is removed.
-  virtual Error notifyRemoving(JITDylib &JD, VModuleKey K) = 0;
-
   /// A utility function for looking up initializer symbols. Performs a blocking
   /// lookup for the given symbols in each of the given JITDylibs.
   static Expected<DenseMap<JITDylib *, SymbolMap>>
   lookupInitSymbols(ExecutionSession &ES,
                     const DenseMap<JITDylib *, SymbolLookupSet> &InitSyms);
 };
 
+/// For objects that want to track JITDylib teardowns, in particular resource
+/// managers.
+class JITDylibDestructionListener {
+public:
+  JITDylibDestructionListener() = default;
+  JITDylibDestructionListener(const JITDylib &) = delete;
+  JITDylibDestructionListener &operator=(const JITDylib &) = delete;
+  virtual ~JITDylibDestructionListener();
+
+  virtual Error notifyDestroyingJITDylib(JITDylib &JD) = 0;
+};
+
 /// An ExecutionSession represents a running JIT program.
 class ExecutionSession {
   // FIXME: Remove this when we remove the old ORC layers.
   friend class JITDylib;
 
 public:
   /// For reporting errors.
   using ErrorReporter = std::function<void(Error)>;
public:
   Platform *getPlatform() { return P.get(); }
 
   /// Run the given lambda with the session mutex locked.
   template <typename Func> decltype(auto) runSessionLocked(Func &&F) {
     std::lock_guard<std::recursive_mutex> Lock(SessionMutex);
     return F();
   }
 
+  /// Register a JITDylibDestructionListener.
+  void registerJITDylibDestructionListener(JITDylibDestructionListener &L) {
+    runSessionLocked([&]() { JITDylibDestructionListeners.push_back(&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:
   /// names are not being re-used (e.g. by calling getJITDylibByName) if names
   /// are based on user input.
   ///
   /// 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.
+  Error destroyJITDylib(JITDylib &JD);
+
   /// 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.
#endif // NDEBUG
   std::shared_ptr<SymbolStringPool> SSP;
   std::unique_ptr<Platform> P;
   VModuleKey LastKey = 0;
   ErrorReporter ReportError = logErrorsToStdErr;
   DispatchMaterializationFunction DispatchMaterialization =
       materializeOnCurrentThread;
 
   std::vector<std::unique_ptr<JITDylib>> JDs;
+  std::vector<JITDylibDestructionListener *> JITDylibDestructionListeners;
 
   // FIXME: Remove this (and runOutstandingMUs) once the linking layer works
   //        with callbacks from asynchronous queries.
   mutable std::recursive_mutex OutstandingMUsMutex;
   std::vector<std::pair<JITDylib *, std::unique_ptr<MaterializationUnit>>>
       OutstandingMUs;
 };
 

llvm/include/llvm/ExecutionEngine/Orc/IRCompileLayer.h

public:
 
   protected:
     IRSymbolMapper::ManglingOptions &manglingOptions() { return MO; }
 
   private:
     IRSymbolMapper::ManglingOptions MO;
   };
 
-  using NotifyCompiledFunction =
-      std::function<void(VModuleKey K, ThreadSafeModule TSM)>;
+  using NotifyCompiledFunction = std::function<void(ThreadSafeModule TSM)>;
 
   IRCompileLayer(ExecutionSession &ES, ObjectLayer &BaseLayer,
                  std::unique_ptr<IRCompiler> Compile);
 
   IRCompiler &getCompiler() { return *Compile; }
 
   void setNotifyCompiled(NotifyCompiledFunction NotifyCompiled);
 

 ///   This layer immediately compiles each IR module added via addModule to an
 /// object file and adds this module file to the layer below, which must
 /// implement the object layer concept.
 template <typename BaseLayerT, typename CompileFtor>
 class LegacyIRCompileLayer {
 public:
   /// Callback type for notifications when modules are compiled.
   using NotifyCompiledCallback =
-      std::function<void(VModuleKey K, std::unique_ptr<Module>)>;
+      std::function<void(VModuleKey, std::unique_ptr<Module>)>;
 
   /// Construct an LegacyIRCompileLayer with the given BaseLayer, which must
   ///        implement the ObjectLayer concept.
   LLVM_ATTRIBUTE_DEPRECATED(
       LegacyIRCompileLayer(
           BaseLayerT &BaseLayer, CompileFtor Compile,
           NotifyCompiledCallback NotifyCompiled = NotifyCompiledCallback()),
       "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please "

llvm/include/llvm/ExecutionEngine/Orc/Layer.h

 class IRMaterializationUnit : public MaterializationUnit {
 public:
   using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
 
   /// Create an IRMaterializationLayer. Scans the module to build the
   /// SymbolFlags and SymbolToDefinition maps.
   IRMaterializationUnit(ExecutionSession &ES,
                         const IRSymbolMapper::ManglingOptions &MO,
-                        ThreadSafeModule TSM, VModuleKey K);
+                        ThreadSafeModule TSM);
 
   /// Create an IRMaterializationLayer from a module, and pre-existing
   /// SymbolFlags and SymbolToDefinition maps. The maps must provide
   /// entries for each definition in M.
   /// This constructor is useful for delegating work from one
   /// IRMaterializationUnit to another.
-  IRMaterializationUnit(ThreadSafeModule TSM, VModuleKey K,
-                        SymbolFlagsMap SymbolFlags, SymbolStringPtr InitSymbol,
+  IRMaterializationUnit(ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
+                        SymbolStringPtr InitSymbol,
                         SymbolNameToDefinitionMap SymbolToDefinition);
 
   /// Return the ModuleIdentifier as the name for this MaterializationUnit.
   StringRef getName() const override;
 
   /// Return a reference to the contained ThreadSafeModule.
   const ThreadSafeModule &getModule() const { return TSM; }
 
void setCloneToNewContextOnEmit(bool CloneToNewContextOnEmit) {
     this->CloneToNewContextOnEmit = CloneToNewContextOnEmit;
   }
 
   /// Returns the current value of the CloneToNewContextOnEmit flag.
   bool getCloneToNewContextOnEmit() const { return CloneToNewContextOnEmit; }
 
   /// Adds a MaterializationUnit representing the given IR to the given
   /// JITDylib.
-  virtual Error add(JITDylib &JD, ThreadSafeModule TSM,
-                    VModuleKey K = VModuleKey());
+  virtual Error add(JITDylib &JD, ThreadSafeModule TSM);
 
   /// Emit should materialize the given IR.
   virtual void emit(MaterializationResponsibility R, ThreadSafeModule TSM) = 0;
 
 private:
   bool CloneToNewContextOnEmit = false;
   ExecutionSession &ES;
   const IRSymbolMapper::ManglingOptions *&MO;
 };
 
 /// MaterializationUnit that materializes modules by calling the 'emit' method
 /// on the given IRLayer.
 class BasicIRLayerMaterializationUnit : public IRMaterializationUnit {
 public:
   BasicIRLayerMaterializationUnit(IRLayer &L,
                                   const IRSymbolMapper::ManglingOptions &MO,
-                                  ThreadSafeModule TSM, VModuleKey K);
+                                  ThreadSafeModule TSM);
 
 private:
 
   void materialize(MaterializationResponsibility R) override;
 
   IRLayer &L;
-  VModuleKey K;
 };
 
 /// Interface for Layers that accept object files.
 class ObjectLayer {
 public:
   ObjectLayer(ExecutionSession &ES);
   virtual ~ObjectLayer();
 
   /// Returns the execution session for this layer.
   ExecutionSession &getExecutionSession() { return ES; }
 
   /// Adds a MaterializationUnit representing the given IR to the given
   /// JITDylib.
-  virtual Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,
-                    VModuleKey K = VModuleKey());
+  virtual Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O);
 
   /// Emit should materialize the given IR.
   virtual void emit(MaterializationResponsibility R,
                     std::unique_ptr<MemoryBuffer> O) = 0;
 
 private:
   ExecutionSession &ES;
 };
 
 /// Materializes the given object file (represented by a MemoryBuffer
 /// instance) by calling 'emit' on the given ObjectLayer.
 class BasicObjectLayerMaterializationUnit : public MaterializationUnit {
 public:
   static Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
-  Create(ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O);
+  Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> O);
 
-  BasicObjectLayerMaterializationUnit(ObjectLayer &L, VModuleKey K,
+  BasicObjectLayerMaterializationUnit(ObjectLayer &L,
                                       std::unique_ptr<MemoryBuffer> O,
                                       SymbolFlagsMap SymbolFlags,
                                       SymbolStringPtr InitSymbol);
 
   /// Return the buffer's identifier as the name for this MaterializationUnit.
   StringRef getName() const override;
 
 private:

llvm/include/llvm/ExecutionEngine/Orc/LazyReexports.h

 /// match the address of the re-exported symbol, but calling it will behave
 /// the same as calling the re-exported symbol.
 class LazyReexportsMaterializationUnit : public MaterializationUnit {
 public:
   LazyReexportsMaterializationUnit(LazyCallThroughManager &LCTManager,
                                    IndirectStubsManager &ISManager,
                                    JITDylib &SourceJD,
                                    SymbolAliasMap CallableAliases,
-                                   ImplSymbolMap *SrcJDLoc, VModuleKey K);
+                                   ImplSymbolMap *SrcJDLoc);
 
   StringRef getName() const override;
 
 private:
   void materialize(MaterializationResponsibility R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
   static SymbolFlagsMap extractFlags(const SymbolAliasMap &Aliases);
 
   LazyCallThroughManager &LCTManager;
   IndirectStubsManager &ISManager;
   JITDylib &SourceJD;
   SymbolAliasMap CallableAliases;
   ImplSymbolMap *AliaseeTable;
 };
 
 /// Define lazy-reexports based on the given SymbolAliasMap. Each lazy re-export
 /// is a callable symbol that will look up and dispatch to the given aliasee on
 /// first call. All subsequent calls will go directly to the aliasee.
 inline std::unique_ptr<LazyReexportsMaterializationUnit>
 lazyReexports(LazyCallThroughManager &LCTManager,
               IndirectStubsManager &ISManager, JITDylib &SourceJD,
-              SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc = nullptr,
-              VModuleKey K = VModuleKey()) {
+              SymbolAliasMap CallableAliases,
+              ImplSymbolMap *SrcJDLoc = nullptr) {
   return std::make_unique<LazyReexportsMaterializationUnit>(
-      LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc,
-      std::move(K));
+      LCTManager, ISManager, SourceJD, std::move(CallableAliases), SrcJDLoc);
 }
 
 } // End namespace orc
 } // End namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LAZYREEXPORTS_H

llvm/include/llvm/ExecutionEngine/Orc/MachOPlatform.h

public:
 
   MachOPlatform(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
                 std::unique_ptr<MemoryBuffer> StandardSymbolsObject);
 
   ExecutionSession &getExecutionSession() const { return ES; }
 
   Error setupJITDylib(JITDylib &JD) override;
   Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU) override;
-  Error notifyRemoving(JITDylib &JD, VModuleKey K) override;
 
   Expected<InitializerSequence> getInitializerSequence(JITDylib &JD);
 
   Expected<DeinitializerSequence> getDeinitializerSequence(JITDylib &JD);
 
 private:
   // This ObjectLinkingLayer plugin scans JITLink graphs for __mod_init_func,
   // __objc_classlist and __sel_ref sections and records their extents so that

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

 
 class ObjectLinkingLayerJITLinkContext;
 
 /// An ObjectLayer implementation built on JITLink.
 ///
 /// Clients can use this class to add relocatable object files to an
 /// ExecutionSession, and it typically serves as the base layer (underneath
 /// a compiling layer like IRCompileLayer) for the rest of the JIT.
-class ObjectLinkingLayer : public ObjectLayer {
+class ObjectLinkingLayer : public ObjectLayer,
+                           public JITDylibDestructionListener {
   friend class ObjectLinkingLayerJITLinkContext;
 
 public:
   /// Plugin instances can be added to the ObjectLinkingLayer to receive
   /// callbacks when code is loaded or emitted, and when JITLink is being
   /// configured.
   class Plugin {
   public:
     using JITLinkSymbolVector = std::vector<const jitlink::Symbol *>;
     using LocalDependenciesMap = DenseMap<SymbolStringPtr, JITLinkSymbolVector>;
 
     virtual ~Plugin();
     virtual void modifyPassConfig(MaterializationResponsibility &MR,
                                   const Triple &TT,
                                   jitlink::PassConfiguration &Config) {}
 
     virtual void notifyLoaded(MaterializationResponsibility &MR) {}
     virtual Error notifyEmitted(MaterializationResponsibility &MR) {
       return Error::success();
     }
-    virtual Error notifyRemovingModule(VModuleKey K) {
-      return Error::success();
-    }
-    virtual Error notifyRemovingAllModules() { return Error::success(); }
+    virtual Error notifyRemoving(JITDylib &JD) { return Error::success(); }
 
     /// Return any dependencies that synthetic symbols (e.g. init symbols)
     /// have on locally scoped jitlink::Symbols. This is used by the
     /// ObjectLinkingLayer to update the dependencies for the synthetic
     /// symbols.
     virtual LocalDependenciesMap
     getSyntheticSymbolLocalDependencies(MaterializationResponsibility &MR) {
       return LocalDependenciesMap();
     }
   };
 
   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);
 
-  /// Destruct 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.
   ObjectLinkingLayer &addPlugin(std::unique_ptr<Plugin> P) {
     std::lock_guard<std::mutex> Lock(LayerMutex);
     Plugins.push_back(std::move(P));
     return *this;
   }
 
   /// Emit the object.
   void emit(MaterializationResponsibility R,
             std::unique_ptr<MemoryBuffer> O) override;
 
+  /// Handle JITDylib teardown notifications.
+  Error notifyDestroyingJITDylib(JITDylib &JD) override;
+
   /// Instructs this ObjectLinkingLayer instance to override the symbol flags
   /// found in the AtomGraph with the flags supplied by the
   /// MaterializationResponsibility instance. This is a workaround to support
   /// symbol visibility in COFF, which does not use the libObject's
   /// SF_Exported flag. Use only when generating / adding COFF object files.
   ///
   /// FIXME: We should be able to remove this if/when COFF properly tracks
   /// exported symbols.
public:
   ObjectLinkingLayer &
   setAutoClaimResponsibilityForObjectSymbols(bool AutoClaimObjectSymbols) {
     this->AutoClaimObjectSymbols = AutoClaimObjectSymbols;
     return *this;
   }
 
 private:
   using AllocPtr = std::unique_ptr<jitlink::JITLinkMemoryManager::Allocation>;
+  using AllocVector = std::vector<AllocPtr>;
 
   void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
                         jitlink::PassConfiguration &PassConfig);
   void notifyLoaded(MaterializationResponsibility &MR);
   Error notifyEmitted(MaterializationResponsibility &MR, AllocPtr Alloc);
-
-  Error removeModule(VModuleKey K);
-  Error removeAllModules();
+  Error removeJITDylib(JITDylib &JD);
 
   mutable std::mutex LayerMutex;
   std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr;
   bool OverrideObjectFlags = false;
   bool AutoClaimObjectSymbols = false;
   ReturnObjectBufferFunction ReturnObjectBuffer;
-  DenseMap<VModuleKey, AllocPtr> TrackedAllocs;
-  std::vector<AllocPtr> UntrackedAllocs;
+  DenseMap<JITDylib *, AllocVector> Allocs;
   std::vector<std::unique_ptr<Plugin>> Plugins;
 };
 
 class EHFrameRegistrationPlugin : public ObjectLinkingLayer::Plugin {
 public:
   EHFrameRegistrationPlugin(jitlink::EHFrameRegistrar &Registrar);
   Error notifyEmitted(MaterializationResponsibility &MR) override;
   void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
                         jitlink::PassConfiguration &PassConfig) override;
-  Error notifyRemovingModule(VModuleKey K) override;
-  Error notifyRemovingAllModules() override;
+  Error notifyRemoving(JITDylib &JD) override;
 
 private:
 
   struct EHFrameRange {
     JITTargetAddress Addr = 0;
     size_t Size;
   };
+  using EHFrameRangeVector = std::vector<EHFrameRange>;
 
   std::mutex EHFramePluginMutex;
   jitlink::EHFrameRegistrar &Registrar;
   DenseMap<MaterializationResponsibility *, EHFrameRange> InProcessLinks;
-  DenseMap<VModuleKey, EHFrameRange> TrackedEHFrameRanges;
-  std::vector<EHFrameRange> UntrackedEHFrameRanges;
+  DenseMap<JITDylib *, EHFrameRangeVector> EHFrameRanges;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H

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

 #include <vector>
 
 namespace llvm {
 namespace orc {
 
 class RTDyldObjectLinkingLayer : public ObjectLayer {
 public:
   /// Functor for receiving object-loaded notifications.
-  using NotifyLoadedFunction =
-      std::function<void(VModuleKey, const object::ObjectFile &Obj,
-                         const RuntimeDyld::LoadedObjectInfo &)>;
+  using NotifyLoadedFunction = std::function<void(
+      const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &)>;
 
   /// Functor for receiving finalization notifications.
   using NotifyEmittedFunction =
-      std::function<void(VModuleKey, std::unique_ptr<MemoryBuffer>)>;
+      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);
public:
 
   /// Register a JITEventListener.
   void registerJITEventListener(JITEventListener &L);
 
   /// Unregister a JITEventListener.
   void unregisterJITEventListener(JITEventListener &L);
 
 private:
-  Error onObjLoad(VModuleKey K, MaterializationResponsibility &R,
+  Error onObjLoad(MaterializationResponsibility &R,
                   const object::ObjectFile &Obj,
                   RuntimeDyld::MemoryManager *MemMgr,
                   std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
                   std::map<StringRef, JITEvaluatedSymbol> Resolved,
                   std::set<StringRef> &InternalSymbols);
 
-  void onObjEmit(VModuleKey K, MaterializationResponsibility &R,
+  void onObjEmit(MaterializationResponsibility &R,
                  object::OwningBinary<object::ObjectFile> O,
                  RuntimeDyld::MemoryManager *MemMgr, Error Err);
 
   mutable std::mutex RTDyldLayerMutex;
   GetMemoryManagerFunction GetMemoryManager;
   NotifyLoadedFunction NotifyLoaded;
   NotifyEmittedFunction NotifyEmitted;
   bool ProcessAllSections = false;

llvm/lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp

 
 namespace llvm {
 namespace orc {
 
 class PartitioningIRMaterializationUnit : public IRMaterializationUnit {
 public:
   PartitioningIRMaterializationUnit(ExecutionSession &ES,
                                     const IRSymbolMapper::ManglingOptions &MO,
-                                    ThreadSafeModule TSM, VModuleKey K,
+                                    ThreadSafeModule TSM,
                                     CompileOnDemandLayer &Parent)
-      : IRMaterializationUnit(ES, MO, std::move(TSM), std::move(K)),
-        Parent(Parent) {}
+      : IRMaterializationUnit(ES, MO, std::move(TSM)), Parent(Parent) {}
 
   PartitioningIRMaterializationUnit(
-      ThreadSafeModule TSM, VModuleKey K, SymbolFlagsMap SymbolFlags,
+      ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
       SymbolStringPtr InitSymbol, SymbolNameToDefinitionMap SymbolToDefinition,
       CompileOnDemandLayer &Parent)
-      : IRMaterializationUnit(std::move(TSM), std::move(K),
-                              std::move(SymbolFlags), std::move(InitSymbol),
+      : IRMaterializationUnit(std::move(TSM), std::move(SymbolFlags),
+                              std::move(InitSymbol),
                               std::move(SymbolToDefinition)),
         Parent(Parent) {}
 
 private:
   void materialize(MaterializationResponsibility R) override {
     Parent.emitPartition(std::move(R), std::move(TSM),
                          std::move(SymbolToDefinition));
   }
for (auto &KV : R.getSymbols()) {
     else
       NonCallables[Name] = SymbolAliasMapEntry(Name, Flags);
   }
 
   // Create a partitioning materialization unit and lodge it with the
   // implementation dylib.
   if (auto Err = PDR.getImplDylib().define(
           std::make_unique<PartitioningIRMaterializationUnit>(
-              ES, *getManglingOptions(), std::move(TSM), R.getVModuleKey(),
-              *this))) {
+              ES, *getManglingOptions(), std::move(TSM), *this))) {
     ES.reportError(std::move(Err));
     R.failMaterialization();
     return;
   }
 
   if (!NonCallables.empty())
     R.replace(reexports(PDR.getImplDylib(), std::move(NonCallables),
                         JITDylibLookupFlags::MatchAllSymbols));
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()) {
     R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
-        std::move(TSM), R.getVModuleKey(), R.getSymbols(),
-        R.getInitializerSymbol(), std::move(Defs), *this));
+        std::move(TSM), R.getSymbols(), R.getInitializerSymbol(),
+        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.
   //
void CompileOnDemandLayer::emitPartition(
 
   if (!ExtractedTSM) {
     ES.reportError(ExtractedTSM.takeError());
     R.failMaterialization();
     return;
   }
 
   R.replace(std::make_unique<PartitioningIRMaterializationUnit>(
-      ES, *getManglingOptions(), std::move(TSM), R.getVModuleKey(), *this));
+      ES, *getManglingOptions(), std::move(TSM), *this));
   BaseLayer.emit(std::move(R), std::move(*ExtractedTSM));
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/Core.cpp

LLVM_DEBUG(JD.getExecutionSession().runSessionLocked([&]() {
     dbgs() << "In " << JD.getName() << " replacing symbols with " << *MU
            << "\n";
   }););
 
   JD.replace(std::move(MU));
 }
 
 MaterializationResponsibility
-MaterializationResponsibility::delegate(const SymbolNameSet &Symbols,
-                                        VModuleKey NewKey) {
-
-  if (NewKey == VModuleKey())
-    NewKey = K;
-
+MaterializationResponsibility::delegate(const SymbolNameSet &Symbols) {
   SymbolStringPtr DelegatedInitSymbol;
   SymbolFlagsMap DelegatedFlags;
 
   for (auto &Name : Symbols) {
     auto I = SymbolFlags.find(Name);
     assert(I != SymbolFlags.end() &&
            "Symbol is not tracked by this MaterializationResponsibility "
            "instance");
 
     DelegatedFlags[Name] = std::move(I->second);
     if (Name == InitSymbol)
       std::swap(InitSymbol, DelegatedInitSymbol);
 
     SymbolFlags.erase(I);
   }
 
   return MaterializationResponsibility(JD, std::move(DelegatedFlags),
-                                       std::move(DelegatedInitSymbol),
-                                       std::move(NewKey));
+                                       std::move(DelegatedInitSymbol));
 }
 
 void MaterializationResponsibility::addDependencies(
     const SymbolStringPtr &Name, const SymbolDependenceMap &Dependencies) {
   LLVM_DEBUG({
     dbgs() << "Adding dependencies for " << Name << ": " << Dependencies
            << "\n";
   });
   assert(SymbolFlags.count(Name) &&
          "Symbol not covered by this MaterializationResponsibility instance");
   JD.addDependencies(Name, Dependencies);
 }
 
 void MaterializationResponsibility::addDependenciesForAll(
     const SymbolDependenceMap &Dependencies) {
   LLVM_DEBUG({
     dbgs() << "Adding dependencies for all symbols in " << SymbolFlags << ": "
            << Dependencies << "\n";
   });
   for (auto &KV : SymbolFlags)
     JD.addDependencies(KV.first, Dependencies);
 }
 
 AbsoluteSymbolsMaterializationUnit::AbsoluteSymbolsMaterializationUnit(
-    SymbolMap Symbols, VModuleKey K)
-    : MaterializationUnit(extractFlags(Symbols), nullptr, std::move(K)),
+    SymbolMap Symbols)
+    : MaterializationUnit(extractFlags(Symbols), nullptr),
       Symbols(std::move(Symbols)) {}
 
 StringRef AbsoluteSymbolsMaterializationUnit::getName() const {
   return "<Absolute Symbols>";
 }
 
 void AbsoluteSymbolsMaterializationUnit::materialize(
     MaterializationResponsibility R) {
AbsoluteSymbolsMaterializationUnit::extractFlags(const SymbolMap &Symbols) {
   SymbolFlagsMap Flags;
   for (const auto &KV : Symbols)
     Flags[KV.first] = KV.second.getFlags();
   return Flags;
 }
 
 ReExportsMaterializationUnit::ReExportsMaterializationUnit(
     JITDylib *SourceJD, JITDylibLookupFlags SourceJDLookupFlags,
-    SymbolAliasMap Aliases, VModuleKey K)
-    : MaterializationUnit(extractFlags(Aliases), nullptr, std::move(K)),
-      SourceJD(SourceJD), SourceJDLookupFlags(SourceJDLookupFlags),
-      Aliases(std::move(Aliases)) {}
+    SymbolAliasMap Aliases)
+    : MaterializationUnit(extractFlags(Aliases), nullptr), SourceJD(SourceJD),
+      SourceJDLookupFlags(SourceJDLookupFlags), Aliases(std::move(Aliases)) {}
 
 StringRef ReExportsMaterializationUnit::getName() const {
   return "<Reexports>";
 }
 
 void ReExportsMaterializationUnit::materialize(
     MaterializationResponsibility R) {
 
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>()) {
 }
 
 JITDylib *ExecutionSession::getJITDylibByName(StringRef Name) {
   return runSessionLocked([&, this]() -> JITDylib * {
     for (auto &JD : JDs)
       if (JD->getName() == Name)

 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::unique_ptr<JITDylib> OwnedJD;
+
+  runSessionLocked([&]() {
+    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;
+      }
+    }
+  });
+
+  Error Err = Error::success();
+  for (auto *L : reverse(JITDylibDestructionListeners))
+    Err = joinErrors(std::move(Err), L->notifyDestroyingJITDylib(JD));
+
+  return Err;
+}
+
 void ExecutionSession::legacyFailQuery(AsynchronousSymbolQuery &Q, Error Err) {
   assert(!!Err && "Error should be in failure state");
 
   bool SendErrorToQuery;
   runSessionLocked([&]() {
     Q.detach();
     SendErrorToQuery = Q.canStillFail();
   });

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

for (const auto &KV : Symbols) {
     ChildBufferInfos.insert(
         {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()});
   }
 
   for (auto ChildBufferInfo : ChildBufferInfos) {
     MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
                                    ChildBufferInfo.second);
 
-    if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false),
-                         VModuleKey()))
+    if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false)))
       return Err;
   }
 
   return Error::success();
 }
 
 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, Error &Err)
     : L(L), ArchiveBuffer(std::move(ArchiveBuffer)),
       Archive(std::make_unique<object::Archive>(*this->ArchiveBuffer, Err)) {}
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/IRCompileLayer.cpp

 void IRCompileLayer::emit(MaterializationResponsibility R,
                           ThreadSafeModule TSM) {
   assert(TSM && "Module must not be null");
 
   if (auto Obj = TSM.withModuleDo(*Compile)) {
     {
       std::lock_guard<std::mutex> Lock(IRLayerMutex);
       if (NotifyCompiled)
-        NotifyCompiled(R.getVModuleKey(), std::move(TSM));
+        NotifyCompiled(std::move(TSM));
       else
         TSM = ThreadSafeModule();
     }
     BaseLayer.emit(std::move(R), std::move(*Obj));
   } else {
     R.failMaterialization();
     getExecutionSession().reportError(Obj.takeError());
   }
 }
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/IndirectionUtils.cpp

 
 namespace {
 
 class CompileCallbackMaterializationUnit : public orc::MaterializationUnit {
 public:
   using CompileFunction = JITCompileCallbackManager::CompileFunction;
 
   CompileCallbackMaterializationUnit(SymbolStringPtr Name,
-                                     CompileFunction Compile, VModuleKey K)
+                                     CompileFunction Compile)
       : MaterializationUnit(SymbolFlagsMap({{Name, JITSymbolFlags::Exported}}),
-                            nullptr, std::move(K)),
+                            nullptr),
         Name(std::move(Name)), Compile(std::move(Compile)) {}
 
   StringRef getName() const override { return "<Compile Callbacks>"; }
 
 private:
   void materialize(MaterializationResponsibility R) override {
     SymbolMap Result;
     Result[Name] = JITEvaluatedSymbol(Compile(), JITSymbolFlags::Exported);

 Expected<JITTargetAddress>
 JITCompileCallbackManager::getCompileCallback(CompileFunction Compile) {
   if (auto TrampolineAddr = TP->getTrampoline()) {
     auto CallbackName =
         ES.intern(std::string("cc") + std::to_string(++NextCallbackId));
 
     std::lock_guard<std::mutex> Lock(CCMgrMutex);
     AddrToSymbol[*TrampolineAddr] = CallbackName;
-    cantFail(CallbacksJD.define(
-        std::make_unique<CompileCallbackMaterializationUnit>(
-            std::move(CallbackName), std::move(Compile),
-            ES.allocateVModule())));
+    cantFail(
+        CallbacksJD.define(std::make_unique<CompileCallbackMaterializationUnit>(
+            std::move(CallbackName), std::move(Compile))));
     return *TrampolineAddr;
   } else
     return TrampolineAddr.takeError();
 }
 
 JITTargetAddress JITCompileCallbackManager::executeCompileCallback(
     JITTargetAddress TrampolineAddr) {
   SymbolStringPtr Name;

llvm/lib/ExecutionEngine/Orc/LLJIT.cpp

 
 /// orc::Platform component of Generic LLVM IR Platform support.
 /// Just forwards calls to the GenericLLVMIRPlatformSupport class below.
 class GenericLLVMIRPlatform : public Platform {
 public:
   GenericLLVMIRPlatform(GenericLLVMIRPlatformSupport &S) : S(S) {}
   Error setupJITDylib(JITDylib &JD) override;
   Error notifyAdding(JITDylib &JD, const MaterializationUnit &MU) override;
-  Error notifyRemoving(JITDylib &JD, VModuleKey K) override {
-    // Noop -- Nothing to do (yet).
-    return Error::success();
-  }
 
 private:
   GenericLLVMIRPlatformSupport &S;
 };
 
 /// This transform parses llvm.global_ctors to produce a single initialization
 /// function for the module, records the function, then deletes
 /// llvm.global_ctors.

 
 Error LLJIT::addIRModule(JITDylib &JD, ThreadSafeModule TSM) {
   assert(TSM && "Can not add null module");
 
   if (auto Err =
           TSM.withModuleDo([&](Module &M) { return applyDataLayout(M); }))
     return Err;
 
-  return InitHelperTransformLayer->add(JD, std::move(TSM),
-                                       ES->allocateVModule());
+  return InitHelperTransformLayer->add(JD, std::move(TSM));
 }
 
 Error LLJIT::addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj) {
   assert(Obj && "Can not add null object");
 
-  return ObjTransformLayer.add(JD, std::move(Obj), ES->allocateVModule());
+  return ObjTransformLayer.add(JD, std::move(Obj));
 }
 
 Expected<JITEvaluatedSymbol> LLJIT::lookupLinkerMangled(JITDylib &JD,
                                                         SymbolStringPtr Name) {
   return ES->lookup(
       makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols), Name);
 }
 

 
 Error LLLazyJIT::addLazyIRModule(JITDylib &JD, ThreadSafeModule TSM) {
   assert(TSM && "Can not add null module");
 
   if (auto Err = TSM.withModuleDo(
           [&](Module &M) -> Error { return applyDataLayout(M); }))
     return Err;
 
-  return CODLayer->add(JD, std::move(TSM), ES->allocateVModule());
+  return CODLayer->add(JD, std::move(TSM));
 }
 
 LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
 
   // If LLJIT construction failed then bail out.
   if (Err)
     return;
 

llvm/lib/ExecutionEngine/Orc/Layer.cpp

 
 #define DEBUG_TYPE "orc"
 
 namespace llvm {
 namespace orc {
 
 IRLayer::~IRLayer() {}
 
-Error IRLayer::add(JITDylib &JD, ThreadSafeModule TSM, VModuleKey K) {
+Error IRLayer::add(JITDylib &JD, ThreadSafeModule TSM) {
   return JD.define(std::make_unique<BasicIRLayerMaterializationUnit>(
-      *this, *getManglingOptions(), std::move(TSM), std::move(K)));
+      *this, *getManglingOptions(), std::move(TSM)));
 }
 
 IRMaterializationUnit::IRMaterializationUnit(
     ExecutionSession &ES, const IRSymbolMapper::ManglingOptions &MO,
-    ThreadSafeModule TSM, VModuleKey K)
-    : MaterializationUnit(SymbolFlagsMap(), nullptr, std::move(K)),
-      TSM(std::move(TSM)) {
+    ThreadSafeModule TSM)
+    : MaterializationUnit(SymbolFlagsMap(), nullptr), TSM(std::move(TSM)) {
 
   assert(this->TSM && "Module must not be null");
 
   MangleAndInterner Mangle(ES, this->TSM.getModuleUnlocked()->getDataLayout());
   this->TSM.withModuleDo([&](Module &M) {
     for (auto &G : M.global_values()) {
       // Skip globals that don't generate symbols.
 
if (!llvm::empty(getStaticInitGVs(M))) {
             JITSymbolFlags::MaterializationSideEffectsOnly;
         break;
       }
     }
   });
 }
 
 IRMaterializationUnit::IRMaterializationUnit(
-    ThreadSafeModule TSM, VModuleKey K, SymbolFlagsMap SymbolFlags,
+    ThreadSafeModule TSM, SymbolFlagsMap SymbolFlags,
     SymbolStringPtr InitSymbol, SymbolNameToDefinitionMap SymbolToDefinition)
-    : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol),
-                          std::move(K)),
+    : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol)),
       TSM(std::move(TSM)), SymbolToDefinition(std::move(SymbolToDefinition)) {}
 
 StringRef IRMaterializationUnit::getName() const {
   if (TSM)
     return TSM.withModuleDo(
         [](const Module &M) -> StringRef { return M.getModuleIdentifier(); });
   return "<null module>";
 }
assert(I != SymbolToDefinition.end() &&
          "Symbol not provided by this MU, or previously discarded");
   assert(!I->second->isDeclaration() &&
          "Discard should only apply to definitions");
   I->second->setLinkage(GlobalValue::AvailableExternallyLinkage);
   SymbolToDefinition.erase(I);
 }
 
 BasicIRLayerMaterializationUnit::BasicIRLayerMaterializationUnit(
-    IRLayer &L, const IRSymbolMapper::ManglingOptions &MO, ThreadSafeModule TSM,
-    VModuleKey K)
-    : IRMaterializationUnit(L.getExecutionSession(), MO, std::move(TSM),
-                            std::move(K)),
-      L(L), K(std::move(K)) {}
+    IRLayer &L, const IRSymbolMapper::ManglingOptions &MO, ThreadSafeModule TSM)
+    : IRMaterializationUnit(L.getExecutionSession(), MO, std::move(TSM)), L(L) {
+}
 
 void BasicIRLayerMaterializationUnit::materialize(
     MaterializationResponsibility R) {
 
   // Throw away the SymbolToDefinition map: it's not usable after we hand
   // off the module.
   SymbolToDefinition.clear();
 
LLVM_DEBUG(ES.runSessionLocked([&]() {
     dbgs() << "Finished emitting, for " << N << ", " << *this << "\n";
   }););
 }
 
 ObjectLayer::ObjectLayer(ExecutionSession &ES) : ES(ES) {}
 
 ObjectLayer::~ObjectLayer() {}
 
-Error ObjectLayer::add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,
-                       VModuleKey K) {
-  auto ObjMU = BasicObjectLayerMaterializationUnit::Create(*this, std::move(K),
-                                                           std::move(O));
+Error ObjectLayer::add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O) {
+  auto ObjMU = BasicObjectLayerMaterializationUnit::Create(*this, std::move(O));
   if (!ObjMU)
     return ObjMU.takeError();
   return JD.define(std::move(*ObjMU));
 }
 
 Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
-BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L, VModuleKey K,
+BasicObjectLayerMaterializationUnit::Create(ObjectLayer &L,
                                             std::unique_ptr<MemoryBuffer> O) {
   auto ObjSymInfo =
       getObjectSymbolInfo(L.getExecutionSession(), O->getMemBufferRef());
 
   if (!ObjSymInfo)
     return ObjSymInfo.takeError();
 
   auto &SymbolFlags = ObjSymInfo->first;
   auto &InitSymbol = ObjSymInfo->second;
 
   return std::unique_ptr<BasicObjectLayerMaterializationUnit>(
       new BasicObjectLayerMaterializationUnit(
-          L, K, std::move(O), std::move(SymbolFlags), std::move(InitSymbol)));
+          L, std::move(O), std::move(SymbolFlags), std::move(InitSymbol)));
 }
 
 BasicObjectLayerMaterializationUnit::BasicObjectLayerMaterializationUnit(
-    ObjectLayer &L, VModuleKey K, std::unique_ptr<MemoryBuffer> O,
-    SymbolFlagsMap SymbolFlags, SymbolStringPtr InitSymbol)
-    : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol),
-                          std::move(K)),
-      L(L), O(std::move(O)) {}
+    ObjectLayer &L, std::unique_ptr<MemoryBuffer> O, SymbolFlagsMap SymbolFlags,
+    SymbolStringPtr InitSymbol)
+    : MaterializationUnit(std::move(SymbolFlags), std::move(InitSymbol)), L(L),
+      O(std::move(O)) {}
 
 StringRef BasicObjectLayerMaterializationUnit::getName() const {
   if (O)
     return O->getBufferIdentifier();
   return "<null object>";
 }
 
 void BasicObjectLayerMaterializationUnit::materialize(

llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp

case Triple::x86_64:
     else
       return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>(
           ES, ErrorHandlerAddr);
   }
 }
 
 LazyReexportsMaterializationUnit::LazyReexportsMaterializationUnit(
     LazyCallThroughManager &LCTManager, IndirectStubsManager &ISManager,
-    JITDylib &SourceJD, SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc,
-    VModuleKey K)
-    : MaterializationUnit(extractFlags(CallableAliases), nullptr, std::move(K)),
+    JITDylib &SourceJD, SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc)
+    : MaterializationUnit(extractFlags(CallableAliases), nullptr),
       LCTManager(LCTManager), ISManager(ISManager), SourceJD(SourceJD),
       CallableAliases(std::move(CallableAliases)), AliaseeTable(SrcJDLoc) {}
 
 StringRef LazyReexportsMaterializationUnit::getName() const {
   return "<Lazy Reexports>";
 }
 
 void LazyReexportsMaterializationUnit::materialize(

llvm/lib/ExecutionEngine/Orc/MachOPlatform.cpp

RegisteredInitSymbols[&JD].add(InitSym,
                                  SymbolLookupFlags::WeaklyReferencedSymbol);
   LLVM_DEBUG({
     dbgs() << "MachOPlatform: Registered init symbol " << *InitSym << " for MU "
            << MU.getName() << "\n";
   });
   return Error::success();
 }
 
-Error MachOPlatform::notifyRemoving(JITDylib &JD, VModuleKey K) {
-  llvm_unreachable("Not supported yet");
-}
-
 Expected<MachOPlatform::InitializerSequence>
 MachOPlatform::getInitializerSequence(JITDylib &JD) {
 
   LLVM_DEBUG({
     dbgs() << "MachOPlatform: Building initializer sequence for "
            << JD.getName() << "\n";
   });
 

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

private:
   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)) {}
-
-ObjectLinkingLayer::~ObjectLinkingLayer() {
-  if (auto Err = removeAllModules())
-    getExecutionSession().reportError(std::move(Err));
+    : ObjectLayer(ES), MemMgr(std::move(MemMgr)) {
+  ES.registerJITDylibDestructionListener(*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) {
+  Error Err = Error::success();
+  for (auto &P : Plugins)
+    Err = joinErrors(std::move(Err), P->notifyRemoving(JD));
+  return Err;
+}
+
 void ObjectLinkingLayer::modifyPassConfig(MaterializationResponsibility &MR,
                                           const Triple &TT,
                                           PassConfiguration &PassConfig) {
   for (auto &P : Plugins)
     P->modifyPassConfig(MR, TT, PassConfig);
 }
 
 void ObjectLinkingLayer::notifyLoaded(MaterializationResponsibility &MR) {
   for (auto &P : Plugins)
     P->notifyLoaded(MR);
 }
 
 Error ObjectLinkingLayer::notifyEmitted(MaterializationResponsibility &MR,
                                         AllocPtr Alloc) {
   Error Err = Error::success();
   for (auto &P : Plugins)
     Err = joinErrors(std::move(Err), P->notifyEmitted(MR));
 
   if (Err)
     return Err;
 
   {
     std::lock_guard<std::mutex> Lock(LayerMutex);
-    UntrackedAllocs.push_back(std::move(Alloc));
+    Allocs[&MR.getTargetJITDylib()].push_back(std::move(Alloc));
   }
 
   return Error::success();
 }
 
-Error ObjectLinkingLayer::removeModule(VModuleKey K) {
+Error ObjectLinkingLayer::removeJITDylib(JITDylib &JD) {
   Error Err = Error::success();
 
   for (auto &P : Plugins)
-    Err = joinErrors(std::move(Err), P->notifyRemovingModule(K));
-
-  AllocPtr Alloc;
-
-  {
-    std::lock_guard<std::mutex> Lock(LayerMutex);
-    auto AllocItr = TrackedAllocs.find(K);
-    Alloc = std::move(AllocItr->second);
-    TrackedAllocs.erase(AllocItr);
-  }
-
-  assert(Alloc && "No allocation for key K");
-
-  return joinErrors(std::move(Err), Alloc->deallocate());
-}
-
-Error ObjectLinkingLayer::removeAllModules() {
-
-  Error Err = Error::success();
+    Err = joinErrors(std::move(Err), P->notifyRemoving(JD));
 
-  for (auto &P : Plugins)
-    Err = joinErrors(std::move(Err), P->notifyRemovingAllModules());
+  AllocVector AllocsToRemove;
 
-  std::vector<AllocPtr> Allocs;
   {
     std::lock_guard<std::mutex> Lock(LayerMutex);
-    Allocs = std::move(UntrackedAllocs);
-
-    for (auto &KV : TrackedAllocs)
-      Allocs.push_back(std::move(KV.second));
-
-    TrackedAllocs.clear();
+    auto AllocsItr = Allocs.find(&JD);
+    AllocsToRemove = std::move(AllocsItr->second);
+    Allocs.erase(AllocsItr);
   }
 
-  while (!Allocs.empty()) {
-    Err = joinErrors(std::move(Err), Allocs.back()->deallocate());
-    Allocs.pop_back();
-  }
+  for (auto &Alloc : AllocsToRemove)
+    Err = joinErrors(std::move(Err), Alloc->deallocate());
 
   return Err;
 }
 
 EHFrameRegistrationPlugin::EHFrameRegistrationPlugin(
     EHFrameRegistrar &Registrar)
     : Registrar(Registrar) {}
 
Error EHFrameRegistrationPlugin::notifyEmitted(
   if (EHFrameRangeItr == InProcessLinks.end())
     return Error::success();
 
   auto EHFrameRange = EHFrameRangeItr->second;
   assert(EHFrameRange.Addr &&
          "eh-frame addr to register can not be null");
 
   InProcessLinks.erase(EHFrameRangeItr);
-  if (auto Key = MR.getVModuleKey())
-    TrackedEHFrameRanges[Key] = EHFrameRange;
-  else
-    UntrackedEHFrameRanges.push_back(EHFrameRange);
+  EHFrameRanges[&MR.getTargetJITDylib()].push_back(EHFrameRange);
 
   return Registrar.registerEHFrames(EHFrameRange.Addr, EHFrameRange.Size);
 }
 
-Error EHFrameRegistrationPlugin::notifyRemovingModule(VModuleKey K) {
+Error EHFrameRegistrationPlugin::notifyRemoving(JITDylib &JD) {
   std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
 
-  auto EHFrameRangeItr = TrackedEHFrameRanges.find(K);
-  if (EHFrameRangeItr == TrackedEHFrameRanges.end())
+  auto EHFrameRangeItr = EHFrameRanges.find(&JD);
+  if (EHFrameRangeItr == EHFrameRanges.end())
     return Error::success();
 
-  auto EHFrameRange = EHFrameRangeItr->second;
+  Error Err = Error::success();
+  for (auto &EHFrameRange : EHFrameRangeItr->second) {
     assert(EHFrameRange.Addr && "Tracked eh-frame range must not be null");
-
-  TrackedEHFrameRanges.erase(EHFrameRangeItr);
-
-  return Registrar.deregisterEHFrames(EHFrameRange.Addr, EHFrameRange.Size);
+    Err = joinErrors(std::move(Err), Registrar.deregisterEHFrames(
+                                         EHFrameRange.Addr, EHFrameRange.Size));
   }
 
-Error EHFrameRegistrationPlugin::notifyRemovingAllModules() {
-  std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
-
-  std::vector<EHFrameRange> EHFrameRanges =
-    std::move(UntrackedEHFrameRanges);
-  EHFrameRanges.reserve(EHFrameRanges.size() + TrackedEHFrameRanges.size());
-
-  for (auto &KV : TrackedEHFrameRanges)
-    EHFrameRanges.push_back(KV.second);
-
-  TrackedEHFrameRanges.clear();
-
-  Error Err = Error::success();
-
-  while (!EHFrameRanges.empty()) {
-    auto EHFrameRange = EHFrameRanges.back();
-    assert(EHFrameRange.Addr && "Untracked eh-frame range must not be null");
-    EHFrameRanges.pop_back();
-    Err = joinErrors(std::move(Err),
-                     Registrar.deregisterEHFrames(EHFrameRange.Addr,
-                                                  EHFrameRange.Size));
-  }
+  EHFrameRanges.erase(EHFrameRangeItr);
 
   return Err;
 }
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

for (auto &Sym : (*Obj)->symbols()) {
           ES.reportError(SymName.takeError());
           R.failMaterialization();
           return;
         }
       }
     }
   }
 
-  auto K = R.getVModuleKey();
   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();
   }
 
   JITDylibSearchOrderResolver Resolver(*SharedR);
 
   jitLinkForORC(
       object::OwningBinary<object::ObjectFile>(std::move(*Obj), std::move(O)),
       *MemMgr, Resolver, ProcessAllSections,
-      [this, K, SharedR, MemMgr, InternalSymbols](
+      [this, SharedR, MemMgr, InternalSymbols](
           const object::ObjectFile &Obj,
           std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
           std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
-        return onObjLoad(K, *SharedR, Obj, MemMgr, std::move(LoadedObjInfo),
+        return onObjLoad(*SharedR, Obj, MemMgr, std::move(LoadedObjInfo),
                          ResolvedSymbols, *InternalSymbols);
       },
-      [this, K, SharedR, MemMgr](object::OwningBinary<object::ObjectFile> Obj,
-                                 Error Err) mutable {
-        onObjEmit(K, *SharedR, std::move(Obj), MemMgr, std::move(Err));
+      [this, SharedR, MemMgr](object::OwningBinary<object::ObjectFile> Obj,
+        onObjEmit(*SharedR, std::move(Obj), MemMgr, std::move(Err));
       });
 }
 
 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);
 }
 
 void RTDyldObjectLinkingLayer::unregisterJITEventListener(JITEventListener &L) {
   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
   auto I = llvm::find(EventListeners, &L);
   assert(I != EventListeners.end() && "Listener not registered");
   EventListeners.erase(I);
 }
 
 Error RTDyldObjectLinkingLayer::onObjLoad(
-    VModuleKey K, MaterializationResponsibility &R,
-    const object::ObjectFile &Obj, RuntimeDyld::MemoryManager *MemMgr,
+    MaterializationResponsibility &R, const object::ObjectFile &Obj,
+    RuntimeDyld::MemoryManager *MemMgr,
     std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
     std::map<StringRef, JITEvaluatedSymbol> Resolved,
     std::set<StringRef> &InternalSymbols) {
   SymbolFlagsMap ExtraSymbolsToClaim;
   SymbolMap Symbols;
 
   // Hack to support COFF constant pool comdats introduced during compilation:
   // (See http://llvm.org/PR40074)
Error RTDyldObjectLinkingLayer::onObjLoad(
   }
 
   if (auto Err = R.notifyResolved(Symbols)) {
     R.failMaterialization();
     return Err;
   }
 
   if (NotifyLoaded)
-    NotifyLoaded(K, Obj, *LoadedObjInfo);
+    NotifyLoaded(Obj, *LoadedObjInfo);
 
   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
   assert(!LoadedObjInfos.count(MemMgr) && "Duplicate loaded info for MemMgr");
   LoadedObjInfos[MemMgr] = std::move(LoadedObjInfo);
 
   return Error::success();
 }
 
 void RTDyldObjectLinkingLayer::onObjEmit(
-    VModuleKey K, MaterializationResponsibility &R,
+    MaterializationResponsibility &R,
     object::OwningBinary<object::ObjectFile> O,
     RuntimeDyld::MemoryManager *MemMgr, Error Err) {
   if (Err) {
     getExecutionSession().reportError(std::move(Err));
     R.failMaterialization();
     return;
   }
 
// Run EventListener notifyLoaded callbacks.
     for (auto *L : EventListeners)
       L->notifyObjectLoaded(
           static_cast<uint64_t>(reinterpret_cast<uintptr_t>(MemMgr)), *Obj,
           *LOIItr->second);
     LoadedObjInfos.erase(MemMgr);
   }
 
   if (NotifyEmitted)
-    NotifyEmitted(K, std::move(ObjBuffer));
+    NotifyEmitted(std::move(ObjBuffer));
 }
 
 LegacyRTDyldObjectLinkingLayer::LegacyRTDyldObjectLinkingLayer(
     ExecutionSession &ES, ResourcesGetter GetResources,
     NotifyLoadedFtor NotifyLoaded, NotifyFinalizedFtor NotifyFinalized,
     NotifyFreedFtor NotifyFreed)
     : ES(ES), GetResources(std::move(GetResources)),
       NotifyLoaded(std::move(NotifyLoaded)),
       NotifyFinalized(std::move(NotifyFinalized)),
       NotifyFreed(std::move(NotifyFreed)), ProcessAllSections(false) {}
 
 } // End namespace orc.
 } // End namespace llvm.

llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h

using DiscardFunction =
       std::function<void(const orc::JITDylib &, orc::SymbolStringPtr)>;
   using DestructorFunction = std::function<void()>;
 
   SimpleMaterializationUnit(
       orc::SymbolFlagsMap SymbolFlags, MaterializeFunction Materialize,
       orc::SymbolStringPtr InitSym = nullptr,
       DiscardFunction Discard = DiscardFunction(),
       DestructorFunction Destructor = DestructorFunction())
-      : MaterializationUnit(std::move(SymbolFlags), std::move(InitSym),
-                            orc::VModuleKey()),
+      : MaterializationUnit(std::move(SymbolFlags), std::move(InitSym)),
         Materialize(std::move(Materialize)), Discard(std::move(Discard)),
         Destructor(std::move(Destructor)) {}
 
   ~SimpleMaterializationUnit() override {
     if (Destructor)
       Destructor();
   }
 

llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

RTDyldObjectLinkingLayer ObjLayer(ES, [&DebugSectionSeen]() {
     return std::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
   });
 
   auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
     cantFail(std::move(R));
   };
 
   ObjLayer.setProcessAllSections(ProcessAllSections);
-  cantFail(ObjLayer.add(JD, std::move(Obj), ES.allocateVModule()));
+  cantFail(ObjLayer.add(JD, std::move(Obj)));
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Foo), SymbolState::Resolved, OnResolveDoNothing,
             NoDependenciesToRegister);
 
   return DebugSectionSeen;
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer,
                               std::make_unique<FunkySimpleCompiler>(*TM));
 
   ObjLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);
 
-  cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
+  cantFail(CompileLayer.add(JD, std::move(M)));
   ES.lookup(
       LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(Foo),
       SymbolState::Resolved,
       [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
       NoDependenciesToRegister);
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
TEST(RTDyldObjectLinkingLayerTest, TestAutoClaimResponsibilityForSymbols) {
   auto Foo = ES.intern("foo");
   RTDyldObjectLinkingLayer ObjLayer(
       ES, []() { return std::make_unique<SectionMemoryManager>(); });
   IRCompileLayer CompileLayer(ES, ObjLayer,
                               std::make_unique<FunkySimpleCompiler>(*TM));
 
   ObjLayer.setAutoClaimResponsibilityForObjectSymbols(true);
 
-  cantFail(CompileLayer.add(JD, std::move(M), ES.allocateVModule()));
+  cantFail(CompileLayer.add(JD, std::move(M)));
   ES.lookup(
       LookupKind::Static, makeJITDylibSearchOrder(&JD), SymbolLookupSet(Foo),
       SymbolState::Resolved,
       [](Expected<SymbolMap> R) { cantFail(std::move(R)); },
       NoDependenciesToRegister);
 }
 
 } // end anonymous namespace