[mlir][ExecutionEngine] Only load JITDyLibs without init/destroy funcs.

[ingomueller-net]

Summary

In https://reviews.llvm.org/D153029, I moved the loading/unloading
mechanisms of shared libraries from the JIT runner to the execution
engine in order to make that mechanism available in the latter
(including its Python bindings). However, I realized that I introduced a
small change in semantic: previously, the JIT runner checked for the
presence of init/destroy functions and only loaded the library as
JITDyLib if they were not present. After I moved the code, all libraries
were loaded as JITDyLib, even if they registered their symbols
explicitly in their init function. I am not sure if this is really a
problem but (1) the previous behavior was different and (2) I guess it
could cause a problem if some symbols are exported through the init
function *and* have public visibility. This patch reestablishes the
original behaviour in the new place of the code.

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

ExecutionEngine::create(Operation *m, const ExecutionEngineOptions &options,
   transform(
       options.sharedLibPaths, std::back_inserter(sharedLibPaths),
       [](StringRef libPath) {
         SmallString<256> absPath(libPath.begin(), libPath.end());
         cantFail(llvm::errorCodeToError(llvm::sys::fs::make_absolute(absPath)));
         return absPath;
       });
 
+  // If shared library implements custom execution layer library init and
+  // destroy functions, we'll use them to register the library. Otherwise, load
+  // the library as JITDyLib below.
+  llvm::StringMap<void *> exportSymbols;
+  SmallVector<LibraryDestroyFn> destroyFns;
+  SmallVector<StringRef> jitDyLibPaths;
+
+  for (auto &libPath : sharedLibPaths) {
+    auto lib = llvm::sys::DynamicLibrary::getPermanentLibrary(
+        libPath.str().str().c_str());
+    void *initSym = lib.getAddressOfSymbol(kLibraryInitFnName);
+    void *destroySim = lib.getAddressOfSymbol(kLibraryDestroyFnName);
+
+    // Library does not provide call backs, rely on symbol visiblity.
+    if (!initSym || !destroySim) {
+      jitDyLibPaths.push_back(libPath);
+      continue;
+    }
+
+    auto initFn = reinterpret_cast<LibraryInitFn>(initSym);
+    initFn(exportSymbols);
+
+    auto destroyFn = reinterpret_cast<LibraryDestroyFn>(destroySim);
+    destroyFns.push_back(destroyFn);
+  }
+  engine->destroyFns = std::move(destroyFns);
+
   // 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, [sectionMemoryMapper = options.sectionMemoryMapper]() {
           return std::make_unique<SectionMemoryManager>(sectionMemoryMapper);
         });
auto objectLinkingLayerCreator = [&](ExecutionSession &session,
     // cf llvm/lib/ExecutionEngine/Orc/LLJIT.cpp LLJIT::createObjectLinkingLayer
     llvm::Triple targetTriple(llvm::Twine(llvmModule->getTargetTriple()));
     if (targetTriple.isOSBinFormatCOFF()) {
       objectLayer->setOverrideObjectFlagsWithResponsibilityFlags(true);
       objectLayer->setAutoClaimResponsibilityForObjectSymbols(true);
     }
 
     // Resolve symbols from shared libraries.
-    for (auto &libPath : sharedLibPaths) {
+    for (auto &libPath : jitDyLibPaths) {
       auto mb = llvm::MemoryBuffer::getFile(libPath);
       if (!mb) {
         errs() << "Failed to create MemoryBuffer for: " << libPath
                << "\nError: " << mb.getError().message() << "\n";
         continue;
       }
       auto &jd = session.createBareJITDylib(std::string(libPath));
       auto loaded = DynamicLibrarySearchGenerator::Load(
-          libPath.str().str().c_str(), dataLayout.getGlobalPrefix());
+          libPath.str().c_str(), dataLayout.getGlobalPrefix());
       if (!loaded) {
         errs() << "Could not load " << libPath << ":\n  " << loaded.takeError()
                << "\n";
         continue;
       }
       jd.addGenerator(std::move(*loaded));
       cantFail(objectLayer->add(jd, std::move(mb.get())));
     }
ExecutionEngine::create(Operation *m, const ExecutionEngineOptions &options,
   engine->jit = std::move(jit);
 
   // Resolve symbols that are statically linked in the current process.
   llvm::orc::JITDylib &mainJD = engine->jit->getMainJITDylib();
   mainJD.addGenerator(
       cantFail(DynamicLibrarySearchGenerator::GetForCurrentProcess(
           dataLayout.getGlobalPrefix())));
 
-  // If shared library implements custom execution layer library init and
-  // destroy functions, we'll use them to register the library.
-
-  llvm::StringMap<void *> exportSymbols;
-  SmallVector<LibraryDestroyFn> destroyFns;
-
-  for (auto &libPath : sharedLibPaths) {
-    auto lib = llvm::sys::DynamicLibrary::getPermanentLibrary(
-        libPath.str().str().c_str());
-    void *initSym = lib.getAddressOfSymbol(kLibraryInitFnName);
-    void *destroySim = lib.getAddressOfSymbol(kLibraryDestroyFnName);
-
-    // Library does not provide call backs, rely on symbol visiblity.
-    if (!initSym || !destroySim) {
-      continue;
-    }
-
-    auto initFn = reinterpret_cast<LibraryInitFn>(initSym);
-    initFn(exportSymbols);
-
-    auto destroyFn = reinterpret_cast<LibraryDestroyFn>(destroySim);
-    destroyFns.push_back(destroyFn);
-  }
-  engine->destroyFns = std::move(destroyFns);
-
   // Build a runtime symbol map from the exported symbols and register them.
   auto runtimeSymbolMap = [&](llvm::orc::MangleAndInterner interner) {
     auto symbolMap = llvm::orc::SymbolMap();
     for (auto &exportSymbol : exportSymbols)
       symbolMap[interner(exportSymbol.getKey())] = {
           llvm::orc::ExecutorAddr::fromPtr(exportSymbol.getValue()),
           llvm::JITSymbolFlags::Exported};
     return symbolMap;