[mlir] Add sectionMemoryMapper to ExecutionEngineOptions

[cota]

Summary

By specifying a sectionMemoryMapper, users can control how
memory for JIT code is allocated.

In particular, I need this in order to use a named memory
region so that profilers such as perf(1) can correctly label
execution cycles coming from JIT'ed code.

[cota]

Capture options.sectionMemoryMapper by value instead of by reference

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_EXECUTIONENGINE_H_
 #define MLIR_EXECUTIONENGINE_EXECUTIONENGINE_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Error.h"
 
 #include <functional>
 #include <memory>
 
 namespace llvm {
 template <typename T> class Expected;
struct ExecutionEngineOptions {
   /// `jitCodeGenOptLevel`, when provided, is used as the optimization level for
   /// target code generation.
   Optional<llvm::CodeGenOpt::Level> jitCodeGenOptLevel = llvm::None;
 
   /// If `sharedLibPaths` are provided, the underlying JIT-compilation will
   /// open and link the shared libraries for symbol resolution.
   ArrayRef<StringRef> sharedLibPaths = {};
 
+  /// Specifies an existing `sectionMemoryMapper` to be associated with the
+  /// compiled code. If none is provided, a default memory mapper that directly
+  /// calls into the operating system is used.
+  llvm::SectionMemoryManager::MemoryMapper *sectionMemoryMapper = nullptr;
+
   /// If `enableObjectCache` is set, the JIT compiler will create one to store
   /// the object generated for the given module.
   bool enableObjectCache = true;
 
   /// If enable `enableGDBNotificationListener` is set, the JIT compiler will
   /// notify the llvm's global GDB notification listener.
   bool enableGDBNotificationListener = true;
 

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

 #include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/IRTransformLayer.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ToolOutputFile.h"
 
ExecutionEngine::create(ModuleOp m, const ExecutionEngineOptions &options) {
 
   auto dataLayout = llvmModule->getDataLayout();
 
   // Callback to create the object layer with symbol resolution to current
   // process and dynamically linked libraries.
   auto objectLinkingLayerCreator = [&](ExecutionSession &session,
                                        const Triple &tt) {
     auto objectLayer = std::make_unique<RTDyldObjectLinkingLayer>(
-        session, []() { return std::make_unique<SectionMemoryManager>(); });
+        session, [sectionMemoryMapper = options.sectionMemoryMapper]() {
+          return std::make_unique<SectionMemoryManager>(sectionMemoryMapper);
+        });
 
     // Register JIT event listeners if they are enabled.
     if (engine->gdbListener)
       objectLayer->registerJITEventListener(*engine->gdbListener);
     if (engine->perfListener)
       objectLayer->registerJITEventListener(*engine->perfListener);
 
     // COFF format binaries (Windows) need special handling to deal with