[mlir] ExecutionEngine: default enableObjectCache to false

[cota]

Summary

The enableObjectCache option was added in
https://reviews.llvm.org/rG06e8101034e, defaulting to false. However,
the init code added there got its logic reversed
(cache(enableObjectCache ? nullptr : new SimpleObjectCache()), which was
fixed in https://reviews.llvm.org/rGd1186fcb04 by setting the default to
true, thereby preserving the existing behavior even if it was
unintentional.

Default now the object cache to false as it was originally intended.
While at it, mention in enableObjectCache's documentation how the
cache can be dumped.

[cota]

Context: https://reviews.llvm.org/D120380

[mehdi_amini]

Thanks!

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

struct ExecutionEngineOptions {
   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;
+  /// the object generated for the given module. The contents of the cache can
+  /// be dumped to a file via the `dumpToObjectfile` method.
+  bool enableObjectCache = false;
 
   /// If enable `enableGDBNotificationListener` is set, the JIT compiler will
   /// notify the llvm's global GDB notification listener.
   bool enableGDBNotificationListener = true;
 
   /// If `enablePerfNotificationListener` is set, the JIT compiler will notify
   /// the llvm's global Perf notification listener.
   bool enablePerfNotificationListener = true;

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

void SimpleObjectCache::dumpToObjectFile(StringRef outputFilename) {
   // Dump the object generated for a single module to the output file.
   assert(cachedObjects.size() == 1 && "Expected only one object entry.");
   auto &cachedObject = cachedObjects.begin()->second;
   file->os() << cachedObject->getBuffer();
   file->keep();
 }
 
 void ExecutionEngine::dumpToObjectFile(StringRef filename) {
+  if (cache == nullptr) {
+    llvm::errs() << "cannot dump ExecutionEngine object code to file: "
+                    "object cache is disabled\n";
+    return;
+  }
   cache->dumpToObjectFile(filename);
 }
 
 void ExecutionEngine::registerSymbols(
     llvm::function_ref<SymbolMap(MangleAndInterner)> symbolMap) {
   auto &mainJitDylib = jit->getMainJITDylib();
   cantFail(mainJitDylib.define(
       absoluteSymbols(symbolMap(llvm::orc::MangleAndInterner(

mlir/lib/ExecutionEngine/JitRunner.cpp

auto runtimeSymbolMap = [&](llvm::orc::MangleAndInterner interner) {
     return symbolMap;
   };
 
   mlir::ExecutionEngineOptions engineOptions;
   engineOptions.llvmModuleBuilder = config.llvmModuleBuilder;
   engineOptions.transformer = config.transformer;
   engineOptions.jitCodeGenOptLevel = jitCodeGenOptLevel;
   engineOptions.sharedLibPaths = executionEngineLibs;
+  engineOptions.enableObjectCache = true;
   auto expectedEngine = mlir::ExecutionEngine::create(module, engineOptions);
   if (!expectedEngine)
     return expectedEngine.takeError();
 
   auto engine = std::move(*expectedEngine);
   engine->registerSymbols(runtimeSymbolMap);
 
   auto expectedFPtr = engine->lookupPacked(entryPoint);