[mlir] [ExecutionEngine] add option to enable/disable GDB notification listener

[aartbik]

Summary

This way, clients can opt-out of the GDB notification listener. Also, this
changes the semantics of enabling the object cache, which seemed the wrong
way around.

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

 ///     void _mlir_funcName(void **)
 ///
 /// where the only argument is interpreted as a list of pointers to the actual
 /// arguments of the function, followed by a pointer to the result.  This allows
 /// the engine to provide the caller with a generic function pointer that can
 /// be used to invoke the JIT-compiled function.
 class ExecutionEngine {
 public:
-  ExecutionEngine(bool enableObjectCache);
+  ExecutionEngine(bool enableObjectCache, bool enableGDBNotificationListener);
 
   /// Creates an execution engine for the given module.  If `transformer` is
   /// provided, it will be called on the LLVM module during JIT-compilation and
   /// can be used, e.g., for reporting or optimization. `jitCodeGenOptLevel`,
   /// when provided, is used as the optimization level for target code
   /// generation. If `sharedLibPaths` are provided, the underlying
   /// JIT-compilation will open and link the shared libraries for symbol
-  /// resolution. If `objectCache` is provided, JIT compiler will use it to
-  /// store the object generated for the given module.
-  static llvm::Expected<std::unique_ptr<ExecutionEngine>> create(
-      ModuleOp m, std::function<llvm::Error(llvm::Module *)> transformer = {},
+  /// resolution. If `enableObjectCache` is set, the JIT compiler will create
+  /// one to store the object generated for the given module. If enable
+  // `enableGDBNotificationListener` is set, the JIT compiler will notify
+  /// the llvm's global GDB notification listener.
+  static llvm::Expected<std::unique_ptr<ExecutionEngine>>
+  create(ModuleOp m,
+         std::function<llvm::Error(llvm::Module *)> transformer = {},
          Optional<llvm::CodeGenOpt::Level> jitCodeGenOptLevel = llvm::None,
-      ArrayRef<StringRef> sharedLibPaths = {}, bool enableObjectCache = false);
+         ArrayRef<StringRef> sharedLibPaths = {}, bool enableObjectCache = true,
+         bool enableGDBNotificationListener = true);
 
   /// Looks up a packed-argument function with the given name and returns a
   /// pointer to it.  Propagates errors in case of failure.
   llvm::Expected<void (*)(void **)> lookup(StringRef name) const;
 
   /// Invokes the function with the given name passing it the list of arguments.
   /// The arguments are accepted by lvalue-reference since the packed function
   /// interface expects a list of non-null pointers.

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

if (!result->getType()->isVoidTy()) {
       builder.CreateStore(result, retPtr);
     }
 
     // The interface function returns void.
     builder.CreateRetVoid();
   }
 }
 
-ExecutionEngine::ExecutionEngine(bool enableObjectCache)
-    : cache(enableObjectCache ? nullptr : new SimpleObjectCache()),
-      gdbListener(llvm::JITEventListener::createGDBRegistrationListener()) {}
+ExecutionEngine::ExecutionEngine(bool enableObjectCache,
+                                 bool enableGDBNotificationListener)
+    : cache(enableObjectCache ? new SimpleObjectCache() : nullptr),
+      gdbListener(enableGDBNotificationListener
+                      ? llvm::JITEventListener::createGDBRegistrationListener()
+                      : nullptr) {}
 
 Expected<std::unique_ptr<ExecutionEngine>> ExecutionEngine::create(
     ModuleOp m, std::function<Error(llvm::Module *)> transformer,
     Optional<llvm::CodeGenOpt::Level> jitCodeGenOptLevel,
-    ArrayRef<StringRef> sharedLibPaths, bool enableObjectCache) {
-  auto engine = std::make_unique<ExecutionEngine>(enableObjectCache);
+    ArrayRef<StringRef> sharedLibPaths, bool enableObjectCache,
+    bool enableGDBNotificationListener) {
+  auto engine = std::make_unique<ExecutionEngine>(
+      enableObjectCache, enableGDBNotificationListener);
 
   std::unique_ptr<llvm::LLVMContext> ctx(new llvm::LLVMContext);
   auto llvmModule = translateModuleToLLVMIR(m);
   if (!llvmModule)
     return make_string_error("could not convert to LLVM IR");
   // FIXME: the triple should be passed to the translation or dialect conversion
   // instead of this.  Currently, the LLVM module created above has no triple
   // associated with it.
Expected<std::unique_ptr<ExecutionEngine>> ExecutionEngine::create(
   auto objectLinkingLayerCreator = [&](ExecutionSession &session,
                                        const Triple &TT) {
     auto objectLayer = std::make_unique<RTDyldObjectLinkingLayer>(
         session, []() { return std::make_unique<SectionMemoryManager>(); });
     objectLayer->setNotifyLoaded(
         [engine = engine.get()](
             llvm::orc::VModuleKey, const llvm::object::ObjectFile &object,
             const llvm::RuntimeDyld::LoadedObjectInfo &objectInfo) {
+          if (engine->gdbListener) {
             uint64_t key = static_cast<uint64_t>(
                 reinterpret_cast<uintptr_t>(object.getData().data()));
             engine->gdbListener->notifyObjectLoaded(key, object, objectInfo);
+          }
         });
 
     // Resolve symbols from shared libraries.
     for (auto libPath : sharedLibPaths) {
       auto mb = llvm::MemoryBuffer::getFile(libPath);
       if (!mb) {
         errs() << "Fail to create MemoryBuffer for: " << libPath << "\n";
         continue;