[mlir][CRunnerUtils] Use explicit execution engine symbol registration.

[ingomueller-net]

Summary

As a follow up of https://reviews.llvm.org/D153250, this path uses the
explicit symbol registration mechanism of the execution engine in the
CRunnerUtils library.

[ingomueller-net]

Marking the symbols that aren't exported explicitly as hidden. I'll wait for CI to succeed and then land, assuming that this change is OK. Otherwise, we'll revert.

[ingomueller-net]

CI failed because, in the Windows builds, two symbols implemented in the mlir_float16_utils libraries and exported through the init/destroy mechanism in the mlir_c_runner_utils libraries could not be found by the linker. I can only suspect (because I don't have a Windows machine) that this is because these two symbols were not explicitly exported in the mlir_float16_utils library, so I am now exporting those explicitly in that lib. I'll see if I am right in a bit when CI finishes...

[ingomueller-net]

(Rebasing to resolve unrelated build error.)

[antmo]

Hi @ingomueller-net,
I suspect this patch broke two bots:

• clang-aarch64-sve-vla: https://lab.llvm.org/buildbot/#/builders/197/builds/6919
• clang-aarch64-sve-vls: https://lab.llvm.org/buildbot/#/builders/184/builds/4469

Is that correct? Could you please take a look?

[ingomueller-net]

@antmo: thanks for investigating! @mehdi_amini: thanks for reverting!

I found the problem: SparseRuntime.cpp is part of the mlir_c_runner_utils lib and I did not export the symbols of that file or change their visibility. While I can simply do that, I wonder whether they shouldn't be in their own lib? Opinions?

mlir/include/mlir/ExecutionEngine/Float16bits.h

 };
 }
 
 // Outputs a half precision value.
 MLIR_FLOAT16_EXPORT std::ostream &operator<<(std::ostream &os, const f16 &f);
 // Outputs a bfloat value.
 MLIR_FLOAT16_EXPORT std::ostream &operator<<(std::ostream &os, const bf16 &d);
 
-#undef MLIR_FLOAT16_EXPORT
 #endif // MLIR_EXECUTIONENGINE_FLOAT16BITS_H_

mlir/lib/ExecutionEngine/CMakeLists.txt

add_mlir_library(mlir_c_runner_utils
 
     EXCLUDE_FROM_LIBMLIR
 
     LINK_LIBS PUBLIC
     mlir_float16_utils
     MLIRSparseTensorEnums
     MLIRSparseTensorRuntime
     )
+  set_property(TARGET mlir_c_runner_utils PROPERTY CXX_VISIBILITY_PRESET hidden)
   set_property(TARGET mlir_c_runner_utils PROPERTY CXX_STANDARD 17)
   target_compile_definitions(mlir_c_runner_utils PRIVATE mlir_c_runner_utils_EXPORTS)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    # Don't export symbols from link-time dependencies, these are internal
+    # implementation details.
+    # FIXME: Add a similar fix for Windows.
+    target_link_options(mlir_c_runner_utils PRIVATE "-Wl,-exclude-libs,ALL")
+  endif()
 
   add_mlir_library(mlir_runner_utils
     SHARED
     RunnerUtils.cpp
 
     EXCLUDE_FROM_LIBMLIR
   )
   set_property(TARGET mlir_runner_utils PROPERTY CXX_VISIBILITY_PRESET hidden)

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

 //===- CRunnerUtils.cpp - Utils for MLIR execution ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements basic functions to manipulate structured MLIR types at
 // runtime. Entities in this file are meant to be retargetable, including on
 // targets without a C++ runtime, and must be kept C compatible.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/CRunnerUtils.h"
 #include "mlir/ExecutionEngine/Msan.h"
+#include "llvm/ADT/StringMap.h"
 
 #ifndef _WIN32
 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 #include <cstdlib>
 #else
 #include <alloca.h>
 #endif
 #include <sys/time.h>
extern "C" void _mlir_ciface_stdSort##VNAME(uint64_t n,                      \
     V *values = vref->data + vref->offset;                                     \
     stdSort(n, values);                                                        \
   }
 IMPL_STDSORT(I64, int64_t)
 IMPL_STDSORT(F64, double)
 IMPL_STDSORT(F32, float)
 #undef IMPL_STDSORT
 
+//===----------------------------------------------------------------------===//
+// MLIR ExecutionEngine dynamic library integration.
+//===----------------------------------------------------------------------===//
+
+// Visual Studio had a bug that fails to compile nested generic lambdas
+// inside an `extern "C"` function.
+//   https://developercommunity.visualstudio.com/content/problem/475494/clexe-error-with-lambda-inside-function-templates.html
+// The bug is fixed in VS2019 16.1. Separating the declaration and definition is
+// a work around for older versions of Visual Studio.
+extern "C" MLIR_CRUNNERUTILS_EXPORT void
+__mlir_execution_engine_init(llvm::StringMap<void *> &exportSymbols);
+
+void __mlir_execution_engine_init(llvm::StringMap<void *> &exportSymbols) {
+  auto exportSymbol = [&](llvm::StringRef name, auto ptr) {
+    assert(exportSymbols.count(name) == 0 && "symbol already exists");
+    exportSymbols[name] = reinterpret_cast<void *>(ptr);
+  };
+
+  exportSymbol("memrefCopy", &memrefCopy);
+  exportSymbol("printI64", &printI64);
+  exportSymbol("printU64", &printU64);
+  exportSymbol("printF32", &printF32);
+  exportSymbol("printF64", &printF64);
+  exportSymbol("printOpen", &printOpen);
+  exportSymbol("printClose", &printClose);
+  exportSymbol("printComma", &printComma);
+  exportSymbol("printNewline", &printNewline);
+  exportSymbol("printF16", &printF16);
+  exportSymbol("printBF16", &printBF16);
+  exportSymbol("printFlops", &printFlops);
+  exportSymbol("rtclock", &rtclock);
+  exportSymbol("*rtsrand", &*rtsrand);
+  exportSymbol("rtrand", &rtrand);
+  exportSymbol("rtdrand", &rtdrand);
+  exportSymbol("_mlir_ciface_stdSortI64", &_mlir_ciface_stdSortI64);
+  exportSymbol("_mlir_ciface_stdSortF64", &_mlir_ciface_stdSortF64);
+  exportSymbol("_mlir_ciface_stdSortF32", &_mlir_ciface_stdSortF32);
+}
+
+extern "C" MLIR_CRUNNERUTILS_EXPORT void __mlir_execution_engine_destroy() {}
+
 #endif // MLIR_CRUNNERUTILS_DEFINE_FUNCTIONS

mlir/lib/ExecutionEngine/Float16bits.cpp

 // one.
 extern "C" BF16ABIType ATTR_WEAK __truncdfbf2(double d) {
   // This does a double rounding step, but it's precise enough for our use
   // cases.
   return __truncsfbf2(static_cast<float>(d));
 }
 
 // Provide these to the CRunner with the local float16 knowledge.
-extern "C" void printF16(uint16_t bits) {
+extern "C" MLIR_FLOAT16_EXPORT void printF16(uint16_t bits) {
   f16 f;
   std::memcpy(&f, &bits, sizeof(f16));
   std::cout << f;
 }
-extern "C" void printBF16(uint16_t bits) {
+extern "C" MLIR_FLOAT16_EXPORT void printBF16(uint16_t bits) {
   bf16 f;
   std::memcpy(&f, &bits, sizeof(bf16));
   std::cout << f;
 }
 
 #endif // MLIR_FLOAT16_DEFINE_FUNCTIONS