[ExecutionEngine] Add to the C API possibility to create custom SectionMemoryManager

[jauhien]

Summary

New set of functions in ExecutionEngine C API allows to create custom memory manager
based on the SectionMemoryManager with some of methods overridden by user.
Supprot for LLVM RTTI was added to memory managers hierarchy as this is necessary for
easy implementation of functions that call parent methods.

This change is useful e.g. for implementing custom JIT with the need of symbol resolution
similar to the one from MCJIT variant of the Kaleidoscope tutorial. SectionMemoryManager
can be reused in this case with only getSymbolAddress overriden with the appropriate callback.

This patch is taken with minor changes from my Rust LLVM bindings (https://github.com/jauhien/iron-llvm) used at the moment in the Rust LLVM Kaleidoscope tutorial (https://github.com/jauhien/iron-kaleidoscope). There a relevant example of real use can be found (https://github.com/jauhien/iron-llvm/blob/master/src/execution_engine/{memory_manager.rs,wrappers.rs} and https://github.com/jauhien/iron-kaleidoscope/blob/master/src/jitter.rs).

[DiamondLovesYou]

include/llvm-c/ExecutionEngine.h

214

What will ErrMsg's lifetime be (or who owns it after the callback returns)? Also, how would use of alloc_jemalloc affect this (w.r.t. Rust)?

223

Typos

225

*to the client object

lib/ExecutionEngine/ExecutionEngineBindings.cpp

450

Keep this line.

[lhames]

Hi Jauhien,

I don't think this is a good fit for the stable C API. To remain stable, we need to minimize the dependency on implementation details. This patch would add a lot of dependence on the behavior of SectionMemoryManager.

Are there any aspects that can't be satisfied by re-implementing SectionMemoryManager in C? (I know that may seem inconvenient, but it allows the client to remain stable, which is something SectionMemoryManager doesn't guarantee).

I think the big missing piece at the moment is the symbol lookup support (getSymbolAddress and getSymbolAddressInDylib). If that's what you need I would prefer to add a new variant of LLVMCreateSimpleMCJITMemoryManager that also supports overloading those functions.

[jauhien]

include/llvm-c/ExecutionEngine.h

214

This is the same situation as in already existing LLVMMemoryManagerFinalizeMemoryCallback. C API binding code freez it. With alloc_jemalloc -- a good question, but something like this already exists in the C API, so it is not in the scope of this patch.

[jauhien]

Fix typos.

[jauhien]

Hi Lang,

thanks for reply.

In D12607#240729, @lhames wrote:

Hi Jauhien,

I don't think this is a good fit for the stable C API. To remain stable, we need to minimize the dependency on implementation details. This patch would add a lot of dependence on the behavior of SectionMemoryManager.

This patch relies on these things:

1. Methods needed for memory management (already used in create mcjit)
2. Methods for symbol resolution
3. Existence of section MM and the fact that it implements mentioned methods

Are there any aspects that can't be satisfied by re-implementing SectionMemoryManager in C? (I know that may seem inconvenient, but it allows the client to remain stable, which is something SectionMemoryManager doesn't guarantee).

I think the big missing piece at the moment is the symbol lookup support (getSymbolAddress and getSymbolAddressInDylib). If that's what you need I would prefer to add a new variant of LLVMCreateSimpleMCJITMemoryManager that also supports overloading those functions.

Yes, this is the main reason why I needed this patch. But if we will introduce something for fixing this, we will have a dependency on the point 2 in the list above. And the fact of existence of section MM and implementation of all listed methods by it looks quite stable for me (no much of dependency of its behavior really). Or am I wrong somewhere?

[lhames]

Hi Jauhien,

This patch relies on these things:

1. Methods needed for memory management (already used in create mcjit)
2. Methods for symbol resolution
3. Existence of section MM and the fact that it implements mentioned methods

Point 3 is the problem: This would lock SectionMemoryManager and its behavior in as part of the stable C API. That's convenient from an implementation standpoint, but it's a problem for maintenance. We want to be able to redesign the memory management behavior in the future.

Are there any aspects that can't be satisfied by re-implementing SectionMemoryManager in C? (I know that may seem inconvenient, but it allows the client to remain stable, which is something SectionMemoryManager doesn't guarantee).

I think the big missing piece at the moment is the symbol lookup support (getSymbolAddress and getSymbolAddressInDylib). If that's what you need I would prefer to add a new variant of LLVMCreateSimpleMCJITMemoryManager that also supports overloading those functions.

Yes, this is the main reason why I needed this patch. But if we will introduce something for fixing this, we will have a dependency on the point 2 in the list above. And the fact of existence of section MM and implementation of all listed methods by it looks quite stable for me (no much of dependency of its behavior really). Or am I wrong somewhere?

I'm happy to add symbol resolution methods to the abstract C memory manager interface. The stability of SectionMemoryManager is accidental though: it's just that nobody has found time to work on it. As I said - we want to reserve the right to change that behavior in the future, so we can't expose it via the stable API.

[jauhien]

Hi Lang,

In D12607#241981, @lhames wrote:

Hi Jauhien,

I'm happy to add symbol resolution methods to the abstract C memory manager interface. The stability of SectionMemoryManager is accidental though: it's just that nobody has found time to work on it. As I said - we want to reserve the right to change that behavior in the future, so we can't expose it via the stable API.

I'll work on the support for symbol resolution methods then. But before it I want to figure out one thing that I do not understand. This thing is how APIs that I've added need SectionMemoryManager implementation to be stable.

Three facts that I rely on (memory management API, symbol resolution API, existence of some MM) will be exposed by execution engine API anyway. If some of MM methods will change implementation, client that uses it correctly will not see it, as it sees only quite common interface. Even SectionMemoryManager itself can be removed and replaced by something that implements necessary functionality. Could you, please, point me to the exact place where this patch (API, not realization) demands SectionMemoryManager to be stable?

[lhames]

Hi Jauhien,

I'll work on the support for symbol resolution methods then. But before it I want to figure out one thing that I do not understand. This thing is how APIs that I've added need SectionMemoryManager implementation to be stable.

Three facts that I rely on (memory management API, symbol resolution API, existence of some MM) will be exposed by execution engine API anyway. If some of MM methods will change implementation, client that uses it correctly will not see it, as it sees only quite common interface. Even SectionMemoryManager itself can be removed and replaced by something that implements necessary functionality. Could you, please, point me to the exact place where this patch (API, not realization) demands SectionMemoryManager to be stable?

The problem is the fall-back to SectionMemoryManager for unimplemented callbacks, which seems to be a central aim for this patch.

As an example: If an API takes a callback called 'allocateCodeSection' it should document some contract on it. E.g. 'allocateCodeSection should allocate memory for text sections, the memory will be aligned to at least Align bytes (but could be higher). Memory allocated via this method must be marked executable when memory is finalized, etc.'. Once that's documented people can reason about the guarantees provided by the contract.

In this patch, the contract is 'If you do not provide an allocateCodeSection method you will get whatever SectionMemoryManager does', but there's no contract for SectionMemoryManager's behavior. Since the C API is stable, people are going to assume that the implied contract is "Whatever SectionMemoryManager does Today", and they may come to rely on implementation details of SectionMemoryManager that aren't actually guaranteed to be stable.

If we were to provide a C API for obtaining a default memory manager implementation, it would have to have a very restricted contract* (i.e. the default implementation would only be guaranteed to meet the same bare-minimum requirements that we place on user-supplied memory managers). The question is whether a default implementation with so few guarantees would be useful to clients. I can imagine it being useful as a stop-gap solution for people bringing up a new JIT, but anyone building a robust solution would want to roll their own versions of all methods. (As a straw man example of the problem: the lack of contract means we might choose to slow every method down by 1000000x and nobody would have the right to complain, because the contract makes no guarantees on performance).

If all you're looking for is a bare-bones default memory manager implementation I think this patch could serve as a base for that, but I have to stress: This would *not* be a matter of exposing access to SectionMemoryManager through the C API, even if that's how it happened to be implemented today. Tomorrow we might replace SectionMemoryManager with something that still met the restricted contact, but behaved totally different to SectionMemoryManager.

So - the question is whether you're just looking for a default memory manager, or for SectionMemoryManager in particular. The former is doable, the latter is not.

• There's nothing stopping us from providing more guarantees on a default memory manager in time, but the more guarantees we provide the higher the maintenance burden going forward, so the amount of consideration and commitment needed rises a lot.

[jauhien]

Hi Lang,

thank you for in-depth answer. Now I clearly see what are your reasons.

In D12607#242715, @lhames wrote:

Hi Jauhien,

If all you're looking for is a bare-bones default memory manager implementation I think this patch could serve as a base for that, but I have to stress: This would *not* be a matter of exposing access to SectionMemoryManager through the C API, even if that's how it happened to be implemented today. Tomorrow we might replace SectionMemoryManager with something that still met the restricted contact, but behaved totally different to SectionMemoryManager.

So - the question is whether you're just looking for a default memory manager, or for SectionMemoryManager in particular. The former is doable, the latter is not.

What I'm looking for is (starting from the most important):

1. possibility to have MM with custom symbol resolution
2. have default MM that is ok for simplest uses

If we could use this patch as a base for solving both problems, it would be really great. What should I change to have this patch accepted as implementation of a bare-bones default MM? The most obvious thing that I see is renaming (so no section MM is mentioned) and warning for users in comments about only base guaranties.

What I would like to have as result is:

1. Possibility to implement completely custom MM with custom symbol resolution
2. Possibility to define not all callbacks, for undefined callbacks some base implementation is used. No guaranties apart from those most basic.
3. Possibility to call custom implementation from user implemented callbacks (specially usefull for symbol resolution).

include/llvm-c/ExecutionEngine.h

  */
 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
   void *Opaque,
   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
   LLVMMemoryManagerDestroyCallback Destroy);
 
+typedef uint8_t *(*LLVMBSMMAllocateCodeSectionCallback)(
+  void *Opaque, LLVMMCJITMemoryManagerRef MM, uintptr_t Size, unsigned Alignment, unsigned SectionID,
+  const char *SectionName);
+typedef uint8_t *(*LLVMBSMMAllocateDataSectionCallback)(
+  void *Opaque, LLVMMCJITMemoryManagerRef MM, uintptr_t Size, unsigned Alignment, unsigned SectionID,
+  const char *SectionName, LLVMBool IsReadOnly);
+typedef LLVMBool (*LLVMBSMMFinalizeMemoryCallback)(
+  void *Opaque, LLVMMCJITMemoryManagerRef MM, char **ErrMsg);
+typedef void     (*LLVMBSMMDestroyCallback)(void *Opaque);
+typedef void     (*LLVMBSMMInvalidateInstructionCacheCallback)(
+  void *Opaque, LLVMMCJITMemoryManagerRef MM);
+typedef uint64_t (*LLVMBSMMGetSymbolAddressCallback)(
+  void *Opaque, LLVMMCJITMemoryManagerRef MM, const char *Name);
+
+/**
+ * Create a simple custom MCJIT memory manager based on SectionMemoryManager.
+ * If any of passed functions in NULL, appropriate method from the parent class
+ * (SectionMemoryManager) will be called.
+ * Every callback receives an opaque pointer to the client object and a pointer to the
+ * memory manager object, so it can call methods from the parent class.
+ */
+LLVMMCJITMemoryManagerRef LLVMCreateBindingSectionMemoryManager(
+  void *Opaque,
+  LLVMBSMMAllocateCodeSectionCallback AllocateCodeSection,
+  LLVMBSMMAllocateDataSectionCallback AllocateDataSection,
+  LLVMBSMMFinalizeMemoryCallback FinalizeMemory,
+  LLVMBSMMInvalidateInstructionCacheCallback InvalidateInstructionCache,
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddress,
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddressInLogicalDylib,
+  LLVMBSMMDestroyCallback Destroy);
+
+uint8_t *LLVMCallSectionMMAllocateCodeSection(
+  LLVMMCJITMemoryManagerRef MM,
+  uintptr_t Size,
+  unsigned Alignment,
+  unsigned SectionID,
+  const char *SectionName);
+
+uint8_t *LLVMBSMMtCallParentAllocateDataSection(
+  LLVMMCJITMemoryManagerRef MM,
+  uintptr_t Size,
+  unsigned Alignment,
+  unsigned SectionID,
+  const char *SectionName,
+  LLVMBool isReadOnly);
+
+LLVMBool LLVMCallSectionMMFinalizeMemory(
+  LLVMMCJITMemoryManagerRef MM,
+  char **ErrMsg);
+
+void LLVMCallSectionMMInvalidateInstructionCache(LLVMMCJITMemoryManagerRef MM);
+
+uint64_t LLVMCallSectionMMGetSymbolAddress(
+  LLVMMCJITMemoryManagerRef MM,
+  const char *Name);
+
+uint64_t LLVMCallSectionMMGetSymbolAddressInLogicalDylib(
+  LLVMMCJITMemoryManagerRef MM,
+  const char *Name);
+
+uint64_t LLVMGetSymbolAddressInProcess(const char *Name);
+
 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
 
 /**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif /* defined(__cplusplus) */
 
 #endif

include/llvm/ExecutionEngine/RTDyldMemoryManager.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H
 #define LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H
 
 #include "RuntimeDyld.h"
 #include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Memory.h"
 
 namespace llvm {
 
 class ExecutionEngine;
 
   namespace object {

 //
 // FIXME: As the RuntimeDyld fills out, additional routines will be needed
 //        for the varying types of objects to be allocated.
 class RTDyldMemoryManager : public MCJITMemoryManager,
                             public RuntimeDyld::SymbolResolver {
   RTDyldMemoryManager(const RTDyldMemoryManager&) = delete;
   void operator=(const RTDyldMemoryManager&) = delete;
 public:
-  RTDyldMemoryManager() {}
+  enum RTDyldMMSubclass {
+    SectionMemoryManager,
+    SimpleBindingMemoryManager,
+    TrivialMemoryManager,
+    RemoteMemoryManager
+  };
+
+public:
+  RTDyldMemoryManager(RTDyldMMSubclass Subclass) : Subclass(Subclass) {}
   ~RTDyldMemoryManager() override;
 
+  RTDyldMMSubclass getSubclass() const { return Subclass; }
+
   void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
   void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
 
   /// This method returns the address of the specified function or variable in
   /// the current process.
   static uint64_t getSymbolAddressInProcess(const std::string &Name);
 
   /// Legacy symbol lookup - DEPRECATED! Please override findSymbol instead.
public:
   /// If \p AbortOnFailure is false and no function with the given name is
   /// found, this function returns a null pointer. Otherwise, it prints a
   /// message to stderr and aborts.
   ///
   /// This function is deprecated for memory managers to be used with
   /// MCJIT or RuntimeDyld.  Use getSymbolAddress instead.
   virtual void *getPointerToNamedFunction(const std::string &Name,
                                           bool AbortOnFailure = true);
+
+private:
+  const RTDyldMMSubclass Subclass;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
-DEFINE_SIMPLE_CONVERSION_FUNCTIONS(
+DEFINE_ISA_CONVERSION_FUNCTIONS(
     RTDyldMemoryManager, LLVMMCJITMemoryManagerRef)
 
 } // namespace llvm
 
 
 #endif

include/llvm/ExecutionEngine/SectionMemoryManager.h

 /// in the JITed object.  Permissions can be applied either by calling
 /// MCJIT::finalizeObject or by calling SectionMemoryManager::finalizeMemory
 /// directly.  Clients of MCJIT should call MCJIT::finalizeObject.
 class SectionMemoryManager : public RTDyldMemoryManager {
   SectionMemoryManager(const SectionMemoryManager&) = delete;
   void operator=(const SectionMemoryManager&) = delete;
 
 public:
-  SectionMemoryManager() { }
+  SectionMemoryManager() : RTDyldMemoryManager(RTDyldMemoryManager::SectionMemoryManager) { }
   ~SectionMemoryManager() override;
 
+  static bool classof(const RTDyldMemoryManager *MM) {
+    return MM->getSubclass() == RTDyldMemoryManager::SectionMemoryManager;
+  }
+
   /// \brief Allocates a memory block of (at least) the given size suitable for
   /// executable code.
   ///
   /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
   /// a default alignment of 16 will be used.
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID,
                                StringRef SectionName) override;

lib/ExecutionEngine/ExecutionEngineBindings.cpp

 // This file defines the C bindings for the ExecutionEngine library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cstring>
 
 using namespace llvm;
 

 };
 
 class SimpleBindingMemoryManager : public RTDyldMemoryManager {
 public:
   SimpleBindingMemoryManager(const SimpleBindingMMFunctions& Functions,
                              void *Opaque);
   ~SimpleBindingMemoryManager() override;
 
+  static bool classof(const RTDyldMemoryManager *MM);
+
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID,
                                StringRef SectionName) override;
 
   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID, StringRef SectionName,
                                bool isReadOnly) override;
 
   bool finalizeMemory(std::string *ErrMsg) override;
 
 private:
   SimpleBindingMMFunctions Functions;
   void *Opaque;
 };
 
 SimpleBindingMemoryManager::SimpleBindingMemoryManager(
   const SimpleBindingMMFunctions& Functions,
   void *Opaque)
-  : Functions(Functions), Opaque(Opaque) {
+  : RTDyldMemoryManager(RTDyldMemoryManager::SimpleBindingMemoryManager),
+    Functions(Functions),
+    Opaque(Opaque) {
   assert(Functions.AllocateCodeSection &&
          "No AllocateCodeSection function provided!");
   assert(Functions.AllocateDataSection &&
          "No AllocateDataSection function provided!");
   assert(Functions.FinalizeMemory &&
          "No FinalizeMemory function provided!");
   assert(Functions.Destroy &&
          "No Destroy function provided!");
 }
 
 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
   Functions.Destroy(Opaque);
 }
 
+bool SimpleBindingMemoryManager::classof(const RTDyldMemoryManager *MM) {
+  return MM->getSubclass() == RTDyldMemoryManager::SimpleBindingMemoryManager;
+}
+
+
 uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
   uintptr_t Size, unsigned Alignment, unsigned SectionID,
   StringRef SectionName) {
   return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
                                        SectionName.str().c_str());
 }
 
 uint8_t *SimpleBindingMemoryManager::allocateDataSection(
bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
   if (errMsgCString) {
     if (ErrMsg)
       *ErrMsg = errMsgCString;
     free(errMsgCString);
   }
   return result;
 }
 
+struct BSMMFunctions {
+  LLVMBSMMAllocateCodeSectionCallback AllocateCodeSection;
+  LLVMBSMMAllocateDataSectionCallback AllocateDataSection;
+  LLVMBSMMFinalizeMemoryCallback FinalizeMemory;
+  LLVMBSMMInvalidateInstructionCacheCallback InvalidateInstructionCache;
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddress;
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddressInLogicalDylib;
+  LLVMBSMMDestroyCallback Destroy;
+};
+
+class BindingSectionMemoryManager : public SectionMemoryManager {
+public:
+  BindingSectionMemoryManager(const BSMMFunctions& Functions, void *Opaque);
+  ~BindingSectionMemoryManager() override;
+
+  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
+                               unsigned SectionID,
+                               StringRef SectionName) override;
+
+  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
+                               unsigned SectionID, StringRef SectionName,
+                               bool isReadOnly) override;
+
+  bool finalizeMemory(std::string *ErrMsg = nullptr) override;
+
+  void invalidateInstructionCache() override;
+
+  uint64_t getSymbolAddress(const std::string &Name) override;
+
+  uint64_t getSymbolAddressInLogicalDylib(const std::string &Name) override;
+
+private:
+  BSMMFunctions Functions;
+  void *Opaque;
+};
+
+BindingSectionMemoryManager::BindingSectionMemoryManager(const BSMMFunctions& Functions, void *Opaque)
+  : Functions(Functions), Opaque(Opaque) {}
+
+BindingSectionMemoryManager::~BindingSectionMemoryManager() {
+  if (Functions.Destroy) {
+    Functions.Destroy(Opaque);
+  }
+}
+
+uint8_t *BindingSectionMemoryManager::allocateCodeSection(uintptr_t Size, unsigned Alignment,
+                                                          unsigned SectionID,
+                                                          StringRef SectionName) {
+  if (Functions.AllocateCodeSection) {
+    return Functions.AllocateCodeSection(Opaque, wrap(this), Size, Alignment, SectionID,
+                       SectionName.str().c_str());
+  } else {
+    return SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID, SectionName);
+  }
+}
+
+uint8_t *BindingSectionMemoryManager::allocateDataSection(uintptr_t Size, unsigned Alignment,
+                                                          unsigned SectionID, StringRef SectionName,
+                                                          bool isReadOnly) {
+  if (Functions.AllocateDataSection) {
+    return Functions.AllocateDataSection(Opaque, wrap(this), Size, Alignment, SectionID,
+                       SectionName.str().c_str(),
+                       isReadOnly);
+  } else {
+    return SectionMemoryManager::allocateDataSection(Size, Alignment, SectionID, SectionName, isReadOnly);
+  }
+}
+
+bool BindingSectionMemoryManager::finalizeMemory(std::string *ErrMsg) {
+  if (Functions.FinalizeMemory) {
+    char *errMsgCString = nullptr;
+    bool result = Functions.FinalizeMemory(Opaque, wrap(this), &errMsgCString);
+    assert((result || !errMsgCString) &&
+           "Did not expect an error message if FinalizeMemory succeeded");
+    if (errMsgCString) {
+      if (ErrMsg)
+        *ErrMsg = errMsgCString;
+      free(errMsgCString);
+    }
+    return result;
+  } else {
+    return SectionMemoryManager::finalizeMemory(ErrMsg);
+  }
+}
+
+void BindingSectionMemoryManager::invalidateInstructionCache() {
+  if (Functions.InvalidateInstructionCache) {
+    Functions.InvalidateInstructionCache(Opaque, wrap(this));
+  } else {
+    SectionMemoryManager::invalidateInstructionCache();
+  }
+}
+
+uint64_t BindingSectionMemoryManager::getSymbolAddress(const std::string &Name) {
+  if (Functions.GetSymbolAddress) {
+    return Functions.GetSymbolAddress(Opaque, wrap(this), Name.c_str());
+  } else {
+    return SectionMemoryManager::getSymbolAddress(Name);
+  }
+}
+
+uint64_t BindingSectionMemoryManager::getSymbolAddressInLogicalDylib(const std::string &Name) {
+  if (Functions.GetSymbolAddressInLogicalDylib) {
+    return Functions.GetSymbolAddressInLogicalDylib(Opaque, wrap(this), Name.c_str());
+  } else {
+    return SectionMemoryManager::getSymbolAddressInLogicalDylib(Name);
+  }
+}
+
 } // anonymous namespace
 
 LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
   void *Opaque,
   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
   LLVMMemoryManagerDestroyCallback Destroy) {
-  
   if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
       !Destroy)
     return nullptr;
-  
   SimpleBindingMMFunctions functions;
   functions.AllocateCodeSection = AllocateCodeSection;
   functions.AllocateDataSection = AllocateDataSection;
   functions.FinalizeMemory = FinalizeMemory;
   functions.Destroy = Destroy;
   return wrap(new SimpleBindingMemoryManager(functions, Opaque));
 }
 
+LLVMMCJITMemoryManagerRef LLVMCreateBindingSectionMemoryManager(
+  void *Opaque,
+  LLVMBSMMAllocateCodeSectionCallback AllocateCodeSection,
+  LLVMBSMMAllocateDataSectionCallback AllocateDataSection,
+  LLVMBSMMFinalizeMemoryCallback FinalizeMemory,
+  LLVMBSMMInvalidateInstructionCacheCallback InvalidateInstructionCache,
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddress,
+  LLVMBSMMGetSymbolAddressCallback GetSymbolAddressInLogicalDylib,
+  LLVMBSMMDestroyCallback Destroy) {
+  BSMMFunctions functions;
+  functions.AllocateCodeSection = AllocateCodeSection;
+  functions.AllocateDataSection = AllocateDataSection;
+  functions.FinalizeMemory = FinalizeMemory;
+  functions.InvalidateInstructionCache = InvalidateInstructionCache;
+  functions.GetSymbolAddress = GetSymbolAddress;
+  functions.GetSymbolAddressInLogicalDylib = GetSymbolAddressInLogicalDylib;
+  functions.Destroy = Destroy;
+  return wrap(new BindingSectionMemoryManager(functions, Opaque));
+}
+
+uint8_t *LLVMCallSectionMMAllocateCodeSection(
+  LLVMMCJITMemoryManagerRef MM,
+  uintptr_t Size,
+  unsigned Alignment,
+  unsigned SectionID,
+  const char *SectionName) {
+  return unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::allocateCodeSection(
+    Size, Alignment, SectionID, SectionName);
+}
+
+uint8_t *LLVMCallSectionMMAllocateDataSection(
+  LLVMMCJITMemoryManagerRef MM,
+  uintptr_t Size,
+  unsigned Alignment,
+  unsigned SectionID,
+  const char *SectionName,
+  LLVMBool isReadOnly) {
+  return unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::allocateDataSection(
+    Size, Alignment, SectionID, SectionName, isReadOnly);
+}
+
+LLVMBool LLVMCallSectionMMFinalizeMemory(
+  LLVMMCJITMemoryManagerRef MM,
+  char **ErrMsg) {
+  std::string errMsg;
+  bool result = unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::finalizeMemory(&errMsg);
+  if (result && !errMsg.empty()) {
+    *ErrMsg = new char[errMsg.size() + 1];
+    std::copy(&(errMsg.c_str()[0]), &(errMsg.c_str()[errMsg.size() - 1]), *ErrMsg);
+    (*ErrMsg)[errMsg.size()] = '\0';
+  }
+
+  return result;
+}
+
+void LLVMCallSectionMMInvalidateInstructionCache(LLVMMCJITMemoryManagerRef MM) {
+  unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::invalidateInstructionCache();
+}
+
+uint64_t LLVMCallSectionMMGetSymbolAddress(
+  LLVMMCJITMemoryManagerRef MM,
+  const char *Name) {
+  return unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::getSymbolAddress(Name);
+}
+
+uint64_t LLVMCallSectionMMGetSymbolAddressInLogicalDylib(
+  LLVMMCJITMemoryManagerRef MM,
+  const char *Name) {
+  return unwrap<SectionMemoryManager>(MM)->SectionMemoryManager::getSymbolAddressInLogicalDylib(Name);
+}
+
+uint64_t LLVMGetSymbolAddressInProcess(const char *Name) {
+  return RTDyldMemoryManager::getSymbolAddressInProcess(Name);
+}
+
 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) {
   delete unwrap(MM);
 }
 

tools/lli/RemoteMemoryManager.h

private:
   // when MCJIT performs relocations after code emission but before
   // the generated code is moved to the remote target.
   sys::MemoryBlock Near;
   sys::MemoryBlock allocateSection(uintptr_t Size);
 
   RemoteTarget *Target;
 
 public:
-  RemoteMemoryManager() : Target(nullptr) {}
+  RemoteMemoryManager() : RTDyldMemoryManager(RTDyldMemoryManager::RemoteMemoryManager),
+                          Target(nullptr) {}
   ~RemoteMemoryManager() override;
 
+  static bool classof(const RTDyldMemoryManager *MM) {
+    return MM->getSubclass() == RTDyldMemoryManager::RemoteMemoryManager;
+  }
+
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID,
                                StringRef SectionName) override;
 
   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID, StringRef SectionName,
                                bool IsReadOnly) override;
 

tools/llvm-rtdyld/llvm-rtdyld.cpp

 
 // A trivial memory manager that doesn't do anything fancy, just uses the
 // support library allocation routines directly.
 class TrivialMemoryManager : public RTDyldMemoryManager {
 public:
   SmallVector<sys::MemoryBlock, 16> FunctionMemory;
   SmallVector<sys::MemoryBlock, 16> DataMemory;
 
+  TrivialMemoryManager() : RTDyldMemoryManager(RTDyldMemoryManager::TrivialMemoryManager) {}
+
+  static bool classof(const RTDyldMemoryManager *MM) {
+    return MM->getSubclass() == RTDyldMemoryManager::TrivialMemoryManager;
+  }
+
   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID,
                                StringRef SectionName) override;
   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                unsigned SectionID, StringRef SectionName,
                                bool IsReadOnly) override;
 
   void *getPointerToNamedFunction(const std::string &Name,