[mlir] Fix exports in mlir_async_runtime.

[plietar]

Summary

The MLIR_ASYNCRUNTIME_EXPORT macro was being defined to be either __declspec(dllexport) or __declspec(dllimport), depending on whether
mlir_c_runner_utils_EXPORTS is defined. The latter was a copy/paste error and should have been mlir_async_runtime_EXPORTS.

Additionally, the uses of that macro in the .cpp file were unnecessary, as only function declarations need to be exported, not their definitions.

[ezhulenev]

Thanks!

mlir/include/mlir/ExecutionEngine/AsyncRuntime.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 #define MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 
 #ifdef _WIN32
 #ifndef MLIR_ASYNCRUNTIME_EXPORT
-#ifdef mlir_c_runner_utils_EXPORTS
+#ifdef mlir_async_runtime_EXPORTS
 // We are building this library
 #define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllexport)
 #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
 #else
 // We are using this library
 #define MLIR_ASYNCRUNTIME_EXPORT __declspec(dllimport)
-#endif // mlir_c_runner_utils_EXPORTS
+#endif // mlir_async_runtime_EXPORTS
 #endif // MLIR_ASYNCRUNTIME_EXPORT
 #else
 #define MLIR_ASYNCRUNTIME_EXPORT
 #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
 #endif // _WIN32
 
 //===----------------------------------------------------------------------===//
 // Async runtime API.

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

 struct AsyncToken {
   bool ready = false;
   std::mutex mu;
   std::condition_variable cv;
   std::vector<std::function<void()>> awaiters;
 };
 
 // Create a new `async.token` in not-ready state.
-extern "C" MLIR_ASYNCRUNTIME_EXPORT AsyncToken *mlirAsyncRuntimeCreateToken() {
+extern "C" AsyncToken *mlirAsyncRuntimeCreateToken() {
   AsyncToken *token = new AsyncToken;
   return token;
 }
 
 // Switches `async.token` to ready state and runs all awaiters.
-extern "C" MLIR_ASYNCRUNTIME_EXPORT void
-mlirAsyncRuntimeEmplaceToken(AsyncToken *token) {
+extern "C" void mlirAsyncRuntimeEmplaceToken(AsyncToken *token) {
   std::unique_lock<std::mutex> lock(token->mu);
   token->ready = true;
   token->cv.notify_all();
   for (auto &awaiter : token->awaiters)
     awaiter();
 }
 
-extern "C" MLIR_ASYNCRUNTIME_EXPORT void
-mlirAsyncRuntimeAwaitToken(AsyncToken *token) {
+extern "C" void mlirAsyncRuntimeAwaitToken(AsyncToken *token) {
   std::unique_lock<std::mutex> lock(token->mu);
   if (!token->ready)
     token->cv.wait(lock, [token] { return token->ready; });
   delete token;
 }
 
-extern "C" MLIR_ASYNCRUNTIME_EXPORT void
-mlirAsyncRuntimeExecute(CoroHandle handle, CoroResume resume) {
+extern "C" void mlirAsyncRuntimeExecute(CoroHandle handle, CoroResume resume) {
 #if LLVM_ENABLE_THREADS
   std::thread thread([handle, resume]() { (*resume)(handle); });
   thread.detach();
 #else
   (*resume)(handle);
 #endif
 }
 
-extern "C" MLIR_ASYNCRUNTIME_EXPORT void
-mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *token, CoroHandle handle,
+extern "C" void mlirAsyncRuntimeAwaitTokenAndExecute(AsyncToken *token,
+                                                     CoroHandle handle,
                                                      CoroResume resume) {
   std::unique_lock<std::mutex> lock(token->mu);
 
   auto execute = [token, handle, resume]() {
     mlirAsyncRuntimeExecute(handle, resume);
     delete token;
   };
 
   if (token->ready)
     execute();
   else
     token->awaiters.push_back([execute]() { execute(); });
 }
 
 //===----------------------------------------------------------------------===//
 // Small async runtime support library for testing.
 //===----------------------------------------------------------------------===//
 
-extern "C" MLIR_ASYNCRUNTIME_EXPORT void
-mlirAsyncRuntimePrintCurrentThreadId() {
+extern "C" void mlirAsyncRuntimePrintCurrentThreadId() {
   static thread_local std::thread::id thisId = std::this_thread::get_id();
   std::cout << "Current thread id: " << thisId << "\n";
 }
 
 #endif // MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS