[mlir:Async] Use LLVM coro operations in async.coro lowering

[ezhulenev]

Summary

Instead of using llvm.call operations to call LLVM coro intrinsics use Coro operations from the LLVM dialect.

(This was reviewed as a part of https://reviews.llvm.org/D94923 but was lost in arc land from local branch)

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

let description = [{
 
     ```mlir
     %0 = async.create_group
     ...
     async.await_all %0
     ```
   }];
 
-  let arguments = (ins );
   let results = (outs Async_GroupType:$result);
 
   let assemblyFormat = "attr-dict";
 }
 
 def Async_AddToGroupOp : Async_Op<"add_to_group", []> {
   let summary = "adds and async token or value to the group";
   let description = [{

 // [2] https://llvm.org/docs/Coroutines.html#switched-resume-lowering
 
 def Async_CoroIdOp : Async_Op<"coro.id"> {
   let summary = "returns a switched-resume coroutine identifier";
   let description = [{
     The `async.coro.id` returns a switched-resume coroutine identifier.
   }];
 
-  let arguments = (ins );
   let results = (outs Async_CoroIdType:$id);
   let assemblyFormat = "attr-dict";
 }
 
 def Async_CoroBeginOp : Async_Op<"coro.begin"> {
   let summary = "returns a handle to the coroutine";
   let description = [{
     The `async.coro.begin` allocates a coroutine frame and returns a handle to
def Async_CoroFreeOp : Async_Op<"coro.free"> {
   let summary = "deallocates the coroutine frame";
   let description = [{
     The `async.coro.free` deallocates the coroutine frame created by the
     async.coro.begin operation.
   }];
 
   let arguments = (ins Async_CoroIdType:$id,
                        Async_CoroHandleType:$handle);
-  let results = (outs );
   let assemblyFormat = "$id `,` $handle attr-dict";
 }
 
 def Async_CoroEndOp : Async_Op<"coro.end"> {
   let summary = "marks the end of the coroutine in the suspend block";
   let description = [{
     The `async.coro.end` marks the point where a coroutine needs to return
     control back to the caller if it is not an initial invocation of the
     coroutine. It the start part of the coroutine is is no-op.
   }];
 
   let arguments = (ins Async_CoroHandleType:$handle);
-  let results = (outs );
   let assemblyFormat = "$handle attr-dict";
 }
 
 def Async_CoroSaveOp : Async_Op<"coro.save"> {
   let summary = "saves the coroutine state";
   let description = [{
     The `async.coro.saves` saves the coroutine state.
   }];
 
   let arguments = (ins Async_CoroHandleType:$handle);
   let results = (outs Async_CoroStateType:$state);
   let assemblyFormat = "$handle attr-dict";
 }
 
 def Async_CoroSuspendOp : Async_Op<"coro.suspend", [Terminator]> {
   let summary = "suspends the coroutine";
   let description = [{
     The `async.coro.suspend` suspends the coroutine and transfers control to the
     `suspend` successor. If suspended coroutine later resumed it will transfer
-    control to the `resume` successor. If it destroyed it will transfer control
-    to the the `cleanup` successor.
+    control to the `resume` successor. If it is destroyed it will transfer
+    control to the the `cleanup` successor.
 
     In switched-resume lowering coroutine can be already in resumed state when
     suspend operation is called, in this case control will be transferred to the
     `resume` successor skipping the `suspend` successor.
   }];
 
   let arguments = (ins Async_CoroStateType:$state);
   let successors = (successor AnySuccessor:$suspendDest,
                               AnySuccessor:$resumeDest,
                               AnySuccessor:$cleanupDest);
   let assemblyFormat =
     "$state `,` $suspendDest `,` $resumeDest  `,` $cleanupDest attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // Async Dialect Runtime Operations.
 //===----------------------------------------------------------------------===//
 
 // The following operations are intermediate async dialect operations to help
 // lowering from high level async operation like `async.execute` to the Async
 // Runtime API defined in the `ExecutionEngine/AsyncRuntime.h`.
 
 def Async_RuntimeCreateOp : Async_Op<"runtime.create"> {
-  let summary = "creates and async runtime value (token, value or group)";
+  let summary = "creates an async runtime value (token, value or group)";
   let description = [{
     The `async.runtime.create` operation creates an async dialect value
     (token, value or group). Tokens and values are created in non-ready state.
     Groups are created in empty state.
   }];
 
-  let arguments = (ins );
   let results = (outs Async_AnyAsyncType:$result);
   let assemblyFormat = "attr-dict `:` type($result)";
 }
 
 def Async_RuntimeSetAvailableOp : Async_Op<"runtime.set_available"> {
   let summary = "switches token or value available state";
   let description = [{
     The `async.runtime.set_available` operation switches async token or value
     state to available.
   }];
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
-  let results = (outs );
   let assemblyFormat = "$operand attr-dict `:` type($operand)";
 }
 
 def Async_RuntimeAwaitOp : Async_Op<"runtime.await"> {
   let summary = "blocks the caller thread until the operand becomes available";
   let description = [{
     The `async.runtime.await` operation blocks the caller thread until the
     operand becomes available.
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand);
-  let results = (outs );
   let assemblyFormat = "$operand attr-dict `:` type($operand)";
 }
 
 def Async_RuntimeResumeOp : Async_Op<"runtime.resume"> {
   let summary = "resumes the coroutine on a thread managed by the runtime";
   let description = [{
     The `async.runtime.resume` operation resumes the coroutine on a thread
     managed by the runtime.
   }];
 
   let arguments = (ins Async_CoroHandleType:$handle);
-  let results = (outs );
   let assemblyFormat = "$handle attr-dict";
 }
 
 def Async_RuntimeAwaitAndResumeOp : Async_Op<"runtime.await_and_resume"> {
   let summary = "awaits the async operand and resumes the coroutine";
   let description = [{
     The `async.runtime.await_and_resume` operation awaits for the operand to
     become available and resumes the coroutine on a thread managed by the
     runtime.
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand,
                        Async_CoroHandleType:$handle);
-  let results = (outs );
   let assemblyFormat = "$operand `,` $handle attr-dict `:` type($operand)";
 }
 
 def Async_RuntimeStoreOp : Async_Op<"runtime.store",
       [TypesMatchWith<"type of 'value' matches element type of 'storage'",
                      "storage", "value",
                      "$_self.cast<ValueType>().getValueType()">]> {
   let summary = "stores the value into the runtime async.value";
   let description = [{
     The `async.runtime.store` operation stores the value into the runtime
     async.value storage.
   }];
 
   let arguments = (ins AnyType:$value,
                        Async_AnyValueType:$storage);
-  let results = (outs );
   let assemblyFormat = "$value `,` $storage attr-dict `:` type($storage)";
 }
 
 def Async_RuntimeLoadOp : Async_Op<"runtime.load",
       [TypesMatchWith<"type of 'value' matches element type of 'storage'",
                      "storage", "result",
                      "$_self.cast<ValueType>().getValueType()">]> {
   let summary = "loads the value from the runtime async.value";
def Async_RuntimeAddRefOp : Async_Op<"runtime.add_ref"> {
   let summary = "adds a reference to async value";
   let description = [{
     The `async.runtime.add_ref` operation adds a reference(s) to async value
     (token, value or group).
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand,
                        Confined<I32Attr, [IntPositive]>:$count);
-  let results = (outs );
 
   let assemblyFormat = [{
     $operand attr-dict `:` type($operand)
   }];
 }
 
 def Async_RuntimeDropRefOp : Async_Op<"runtime.drop_ref"> {
   let summary = "drops a reference to async value";
   let description = [{
     The `async.runtime.drop_ref` operation drops a reference(s) to async value
     (token, value or group).
   }];
 
   let arguments = (ins Async_AnyAsyncType:$operand,
                        Confined<I32Attr, [IntPositive]>:$count);
-  let results = (outs );
 
   let assemblyFormat = [{
     $operand attr-dict `:` type($operand)
   }];
 }
 
 #endif // ASYNC_OPS

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

addFuncDecl(kAwaitTokenAndExecute,
               AsyncAPI::awaitTokenAndExecuteFunctionType(ctx));
   addFuncDecl(kAwaitValueAndExecute,
               AsyncAPI::awaitValueAndExecuteFunctionType(ctx));
   addFuncDecl(kAwaitAllAndExecute,
               AsyncAPI::awaitAllAndExecuteFunctionType(ctx));
 }
 
 //===----------------------------------------------------------------------===//
-// LLVM coroutines intrinsics declarations.
+// Add malloc/free declarations to the module.
 //===----------------------------------------------------------------------===//
 
-static constexpr const char *kCoroId = "llvm.coro.id";
-static constexpr const char *kCoroSizeI64 = "llvm.coro.size.i64";
-static constexpr const char *kCoroBegin = "llvm.coro.begin";
-static constexpr const char *kCoroSave = "llvm.coro.save";
-static constexpr const char *kCoroSuspend = "llvm.coro.suspend";
-static constexpr const char *kCoroEnd = "llvm.coro.end";
-static constexpr const char *kCoroFree = "llvm.coro.free";
-static constexpr const char *kCoroResume = "llvm.coro.resume";
+static constexpr const char *kMalloc = "malloc";
+static constexpr const char *kFree = "free";
 
 static void addLLVMFuncDecl(ModuleOp module, ImplicitLocOpBuilder &builder,
                             StringRef name, Type ret, ArrayRef<Type> params) {
   if (module.lookupSymbol(name))
     return;
   Type type = LLVM::LLVMFunctionType::get(ret, params);
   builder.create<LLVM::LLVMFuncOp>(name, type);
 }
 
-/// Adds coroutine intrinsics declarations to the module.
-static void addCoroutineIntrinsicsDeclarations(ModuleOp module) {
-  using namespace mlir::LLVM;
-
-  MLIRContext *ctx = module.getContext();
-  ImplicitLocOpBuilder builder(module.getLoc(),
-                               module.getBody()->getTerminator());
-
-  auto token = LLVMTokenType::get(ctx);
-  auto voidTy = LLVMVoidType::get(ctx);
-
-  auto i8 = IntegerType::get(ctx, 8);
-  auto i1 = IntegerType::get(ctx, 1);
-  auto i32 = IntegerType::get(ctx, 32);
-  auto i64 = IntegerType::get(ctx, 64);
-  auto i8Ptr = LLVMPointerType::get(i8);
-
-  addLLVMFuncDecl(module, builder, kCoroId, token, {i32, i8Ptr, i8Ptr, i8Ptr});
-  addLLVMFuncDecl(module, builder, kCoroSizeI64, i64, {});
-  addLLVMFuncDecl(module, builder, kCoroBegin, i8Ptr, {token, i8Ptr});
-  addLLVMFuncDecl(module, builder, kCoroSave, token, {i8Ptr});
-  addLLVMFuncDecl(module, builder, kCoroSuspend, i8, {token, i1});
-  addLLVMFuncDecl(module, builder, kCoroEnd, i1, {i8Ptr, i1});
-  addLLVMFuncDecl(module, builder, kCoroFree, i8Ptr, {token, i8Ptr});
-  addLLVMFuncDecl(module, builder, kCoroResume, voidTy, {i8Ptr});
-}
-
-//===----------------------------------------------------------------------===//
-// Add malloc/free declarations to the module.
-//===----------------------------------------------------------------------===//
-
-static constexpr const char *kMalloc = "malloc";
-static constexpr const char *kFree = "free";
-
 /// Adds malloc/free declarations to the module.
 static void addCRuntimeDeclarations(ModuleOp module) {
   using namespace mlir::LLVM;
 
   MLIRContext *ctx = module.getContext();
   ImplicitLocOpBuilder builder(module.getLoc(),
                                module.getBody()->getTerminator());
 
static void addResumeFunction(ModuleOp module) {
 
   auto resumeOp = moduleBuilder.create<LLVM::LLVMFuncOp>(
       loc, kResume, LLVM::LLVMFunctionType::get(voidTy, {i8Ptr}));
   resumeOp.setPrivate();
 
   auto *block = resumeOp.addEntryBlock();
   auto blockBuilder = ImplicitLocOpBuilder::atBlockEnd(loc, block);
 
-  blockBuilder.create<LLVM::CallOp>(TypeRange(),
-                                    blockBuilder.getSymbolRefAttr(kCoroResume),
-                                    resumeOp.getArgument(0));
-
+  blockBuilder.create<LLVM::CoroResumeOp>(resumeOp.getArgument(0));
   blockBuilder.create<LLVM::ReturnOp>(ValueRange());
 }
 
 //===----------------------------------------------------------------------===//
 // async.execute op outlining to the coroutine functions.
 //===----------------------------------------------------------------------===//
 
 /// Function targeted for coroutine transformation has two additional blocks at
matchAndRewrite(CoroIdOp op, ArrayRef<Value> operands,
     auto loc = op->getLoc();
 
     // Constants for initializing coroutine frame.
     auto constZero = rewriter.create<LLVM::ConstantOp>(
         loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
     auto nullPtr = rewriter.create<LLVM::NullOp>(loc, i8Ptr);
 
     // Get coroutine id: @llvm.coro.id.
-    rewriter.replaceOpWithNewOp<LLVM::CallOp>(
-        op, token, rewriter.getSymbolRefAttr(kCoroId),
-        ValueRange({constZero, nullPtr, nullPtr, nullPtr}));
+    rewriter.replaceOpWithNewOp<LLVM::CoroIdOp>(
+        op, token, ValueRange({constZero, nullPtr, nullPtr, nullPtr}));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.begin to @llvm.coro.begin intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroBeginOpConversion : public OpConversionPattern<CoroBeginOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(CoroBeginOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Get coroutine frame size: @llvm.coro.size.i64.
-    auto coroSize = rewriter.create<LLVM::CallOp>(
-        loc, rewriter.getI64Type(), rewriter.getSymbolRefAttr(kCoroSizeI64),
-        ValueRange());
+    auto coroSize =
+        rewriter.create<LLVM::CoroSizeOp>(loc, rewriter.getI64Type());
 
     // Allocate memory for the coroutine frame.
     auto coroAlloc = rewriter.create<LLVM::CallOp>(
         loc, i8Ptr, rewriter.getSymbolRefAttr(kMalloc),
-        ValueRange(coroSize.getResult(0)));
+        ValueRange(coroSize.getResult()));
 
     // Begin a coroutine: @llvm.coro.begin.
     auto coroId = CoroBeginOpAdaptor(operands).id();
-    rewriter.replaceOpWithNewOp<LLVM::CallOp>(
-        op, i8Ptr, rewriter.getSymbolRefAttr(kCoroBegin),
-        ValueRange({coroId, coroAlloc.getResult(0)}));
+    rewriter.replaceOpWithNewOp<LLVM::CoroBeginOp>(
+        op, i8Ptr, ValueRange({coroId, coroAlloc.getResult(0)}));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.free to @llvm.coro.free intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroFreeOpConversion : public OpConversionPattern<CoroFreeOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(CoroFreeOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Get a pointer to the coroutine frame memory: @llvm.coro.free.
-    auto coroMem = rewriter.create<LLVM::CallOp>(
-        loc, i8Ptr, rewriter.getSymbolRefAttr(kCoroFree), operands);
+    auto coroMem = rewriter.create<LLVM::CoroFreeOp>(loc, i8Ptr, operands);
 
     // Free the memory.
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, TypeRange(),
                                               rewriter.getSymbolRefAttr(kFree),
-                                              ValueRange(coroMem.getResult(0)));
+                                              ValueRange(coroMem.getResult()));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.end to @llvm.coro.end intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroEndOpConversion : public OpConversionPattern<CoroEndOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(CoroEndOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     // We are not in the block that is part of the unwind sequence.
     auto constFalse = rewriter.create<LLVM::ConstantOp>(
         op->getLoc(), rewriter.getI1Type(), rewriter.getBoolAttr(false));
 
     // Mark the end of a coroutine: @llvm.coro.end.
     auto coroHdl = CoroEndOpAdaptor(operands).handle();
-    rewriter.create<LLVM::CallOp>(op->getLoc(), rewriter.getI1Type(),
-                                  rewriter.getSymbolRefAttr(kCoroEnd),
+    rewriter.create<LLVM::CoroEndOp>(op->getLoc(), rewriter.getI1Type(),
                                      ValueRange({coroHdl, constFalse}));
     rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.save to @llvm.coro.save intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroSaveOpConversion : public OpConversionPattern<CoroSaveOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(CoroSaveOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     // Save the coroutine state: @llvm.coro.save
-    rewriter.replaceOpWithNewOp<LLVM::CallOp>(
-        op, AsyncAPI::tokenType(op->getContext()),
-        rewriter.getSymbolRefAttr(kCoroSave), operands);
+    rewriter.replaceOpWithNewOp<LLVM::CoroSaveOp>(
+        op, AsyncAPI::tokenType(op->getContext()), operands);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.suspend to @llvm.coro.suspend intrinsic.

 ///     "op"(...)
 ///   ^cleanup: ...
 ///   ^suspend: ...
 ///
 /// After:
 ///
 ///   ^suspended:
 ///     "opBefore"(...)
-///     %suspend = llmv.call @llvm.coro.suspend(...)
+///     %suspend = llmv.intr.coro.suspend ...
 ///     switch %suspend [-1: ^suspend, 0: ^resume, 1: ^cleanup]
 ///   ^resume:
 ///     "op"(...)
 ///   ^cleanup: ...
 ///   ^suspend: ...
 ///
 class CoroSuspendOpConversion : public OpConversionPattern<CoroSuspendOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(CoroSuspendOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8 = rewriter.getIntegerType(8);
     auto i32 = rewriter.getI32Type();
     auto loc = op->getLoc();
 
     // This is not a final suspension point.
     auto constFalse = rewriter.create<LLVM::ConstantOp>(
         loc, rewriter.getI1Type(), rewriter.getBoolAttr(false));
 
     // Suspend a coroutine: @llvm.coro.suspend
     auto coroState = CoroSuspendOpAdaptor(operands).state();
-    auto coroSuspend = rewriter.create<LLVM::CallOp>(
-        loc, i8, rewriter.getSymbolRefAttr(kCoroSuspend),
-        ValueRange({coroState, constFalse}));
+    auto coroSuspend = rewriter.create<LLVM::CoroSuspendOp>(
+        loc, i8, ValueRange({coroState, constFalse}));
 
     // Cast return code to i32.
 
     // After a suspension point decide if we should branch into resume, cleanup
     // or suspend block of the coroutine (see @llvm.coro.suspend return code
     // documentation).
     llvm::SmallVector<int32_t, 2> caseValues = {0, 1};
     llvm::SmallVector<Block *, 2> caseDest = {op.resumeDest(),
                                               op.cleanupDest()};
     rewriter.replaceOpWithNewOp<LLVM::SwitchOp>(
-        op, rewriter.create<LLVM::SExtOp>(loc, i32, coroSuspend.getResult(0)),
+        op, rewriter.create<LLVM::SExtOp>(loc, i32, coroSuspend.getResult()),
         /*defaultDestination=*/op.suspendDest(),
         /*defaultOperands=*/ValueRange(),
         /*caseValues=*/caseValues,
         /*caseDestinations=*/caseDest,
         /*caseOperands=*/ArrayRef<ValueRange>(),
         /*branchWeights=*/ArrayRef<int32_t>());
 
     return success();
void ConvertAsyncToLLVMPass::runOnOperation() {
   LLVM_DEBUG({
     llvm::dbgs() << "Outlined " << outlinedFunctions.size()
                  << " async functions\n";
   });
 
   // Add declarations for all functions required by the coroutines lowering.
   addResumeFunction(module);
   addAsyncRuntimeApiDeclarations(module);
-  addCoroutineIntrinsicsDeclarations(module);
   addCRuntimeDeclarations(module);
 
   // ------------------------------------------------------------------------ //
   // Lower async operations to async.runtime operations.
   // ------------------------------------------------------------------------ //
   OwningRewritePatternList asyncPatterns;
 
   // Async lowering does not use type converter because it must preserve all

mlir/test/Conversion/AsyncToLLVM/convert-coro-to-llvm.mlir

 // RUN: mlir-opt %s -convert-async-to-llvm | FileCheck %s
 
 // CHECK-LABEL: @coro_id
 func @coro_id() {
   // CHECK: %0 = llvm.mlir.constant(0 : i32) : i32
   // CHECK: %1 = llvm.mlir.null : !llvm.ptr<i8>
-  // CHECK: %2 = llvm.call @llvm.coro.id(%0, %1, %1, %1)
+  // CHECK: %2 = llvm.intr.coro.id %0, %1, %1, %1 : !llvm.token
   %0 = async.coro.id
   return
 }
 
 // CHECK-LABEL: @coro_begin
 func @coro_begin() {
-  // CHECK: %[[ID:.*]] = llvm.call @llvm.coro.id
+  // CHECK: %[[ID:.*]] = llvm.intr.coro.id
   %0 = async.coro.id
-  // CHECK: %[[SIZE:.*]] = llvm.call @llvm.coro.size.i64()
+  // CHECK: %[[SIZE:.*]] = llvm.intr.coro.size : i64
   // CHECK: %[[ALLOC:.*]] = llvm.call @malloc(%[[SIZE]])
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin(%[[ID]], %[[ALLOC]])
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin %[[ID]], %[[ALLOC]]
   %1 = async.coro.begin %0
   return
 }
 
 // CHECK-LABEL: @coro_free
 func @coro_free() {
-  // CHECK: %[[ID:.*]] = llvm.call @llvm.coro.id
+  // CHECK: %[[ID:.*]] = llvm.intr.coro.id
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
-  // CHECK: %[[MEM:.*]] = llvm.call @llvm.coro.free(%[[ID]], %[[HDL]])
+  // CHECK: %[[MEM:.*]] = llvm.intr.coro.free %[[ID]], %[[HDL]]
   // CHECK: llvm.call @free(%[[MEM]])
   async.coro.free %0, %1
   return
 }
 
 // CHECK-LABEL: @coro_end
 func @coro_end() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[FALSE:.*]] = llvm.mlir.constant(false) : i1
-  // CHECK: llvm.call @llvm.coro.end(%[[HDL]], %[[FALSE]])
+  // CHECK: llvm.intr.coro.end %[[HDL]], %[[FALSE]]
   async.coro.end %1
   return
 }
 
 // CHECK-LABEL: @coro_save
 func @coro_save() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
-  // CHECK: llvm.call @llvm.coro.save(%[[HDL]])
+  // CHECK: llvm.intr.coro.save %[[HDL]]
   %2 = async.coro.save %1
   return
 }
 
 // CHECK-LABEL: @coro_suspend
 func @coro_suspend() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
-  // CHECK: %[[STATE:.*]] = llvm.call @llvm.coro.save(%[[HDL]])
+  // CHECK: %[[STATE:.*]] = llvm.intr.coro.save %[[HDL]]
   %2 = async.coro.save %1
 
   // CHECK: %[[FINAL:.*]] = llvm.mlir.constant(false) : i1
-  // CHECK: %[[RET:.*]] = llvm.call @llvm.coro.suspend(%[[STATE]], %[[FINAL]])
+  // CHECK: %[[RET:.*]] = llvm.intr.coro.suspend %[[STATE]], %[[FINAL]]
   // CHECK: %[[SEXT:.*]] = llvm.sext %[[RET]] : i8 to i32
   // CHECK: llvm.switch %[[SEXT]], ^[[SUSPEND:[b0-9]+]]
   // CHECK-NEXT: 0: ^[[RESUME:[b0-9]+]]
   // CHECK-NEXT: 1: ^[[CLEANUP:[b0-9]+]]
   async.coro.suspend %2, ^suspend, ^resume, ^cleanup
 ^resume:
   // CHECK: ^[[RESUME]]
   // CHECK:   return {coro.resume}

mlir/test/Conversion/AsyncToLLVM/convert-runtime-to-llvm.mlir

func @await_group() {
   // CHECK: call @mlirAsyncRuntimeAwaitAllInGroup(%[[GROUP]])
   async.runtime.await %0 : !async.group
   return
 }
 
 // CHECK-LABEL: @await_and_resume_token
 func @await_and_resume_token() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[TOKEN:.*]] = call @mlirAsyncRuntimeCreateToken
   %2 = async.runtime.create : !async.token
   // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
   // CHECK: call @mlirAsyncRuntimeAwaitTokenAndExecute
   // CHECK-SAME: (%[[TOKEN]], %[[HDL]], %[[RESUME]])
   async.runtime.await_and_resume %2, %1 : !async.token
   return
 }
 
 // CHECK-LABEL: @await_and_resume_value
 func @await_and_resume_value() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[VALUE:.*]] = call @mlirAsyncRuntimeCreateValue
   %2 = async.runtime.create : !async.value<f32>
   // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
   // CHECK: call @mlirAsyncRuntimeAwaitValueAndExecute
   // CHECK-SAME: (%[[VALUE]], %[[HDL]], %[[RESUME]])
   async.runtime.await_and_resume %2, %1 : !async.value<f32>
   return
 }
 
 // CHECK-LABEL: @await_and_resume_group
 func @await_and_resume_group() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[TOKEN:.*]] = call @mlirAsyncRuntimeCreateGroup
   %2 = async.runtime.create : !async.group
   // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
   // CHECK: call @mlirAsyncRuntimeAwaitAllInGroupAndExecute
   // CHECK-SAME: (%[[TOKEN]], %[[HDL]], %[[RESUME]])
   async.runtime.await_and_resume %2, %1 : !async.group
   return
 }
 
 // CHECK-LABEL: @resume
 func @resume() {
   %0 = async.coro.id
-  // CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+  // CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
   %1 = async.coro.begin %0
   // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
   // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL]], %[[RESUME]])
   async.runtime.resume %1
   return
 }
 
 // CHECK-LABEL: @store

mlir/test/Conversion/AsyncToLLVM/convert-to-llvm.mlir

 }
 
 // Function outlined from the async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
 // CHECK-SAME: -> !llvm.ptr<i8>
 
 // Create token for return op, and mark a function as a coroutine.
 // CHECK: %[[RET:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
 
 // Pass a suspended coroutine to the async runtime.
-// CHECK: %[[STATE:.*]] = llvm.call @llvm.coro.save
+// CHECK: %[[STATE:.*]] = llvm.intr.coro.save
 // CHECK: %[[RESUME:.*]] = llvm.mlir.addressof @__resume
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL]], %[[RESUME]])
-// CHECK: %[[SUSPENDED:.*]] = llvm.call @llvm.coro.suspend(%[[STATE]]
+// CHECK: %[[SUSPENDED:.*]] = llvm.intr.coro.suspend %[[STATE]]
 
 // Decide the next block based on the code returned from suspend.
 // CHECK: %[[SEXT:.*]] = llvm.sext %[[SUSPENDED]] : i8 to i32
 // CHECK: llvm.switch %[[SEXT]], ^[[SUSPEND:[b0-9]+]]
 // CHECK-NEXT: 0: ^[[RESUME:[b0-9]+]]
 // CHECK-NEXT: 1: ^[[CLEANUP:[b0-9]+]]
 
 // Resume coroutine after suspension.
 // CHECK: ^[[RESUME]]:
 // CHECK: store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET]])
 
 // Delete coroutine.
 // CHECK: ^[[CLEANUP]]:
-// CHECK: %[[MEM:.*]] = llvm.call @llvm.coro.free
+// CHECK: %[[MEM:.*]] = llvm.intr.coro.free
 // CHECK: llvm.call @free(%[[MEM]])
 
 // Suspend coroutine, and also a return statement for ramp function.
 // CHECK: ^[[SUSPEND]]:
-// CHECK: llvm.call @llvm.coro.end
+// CHECK: llvm.intr.coro.end
 // CHECK: return %[[RET]]
 
 // -----
 
 // CHECK-LABEL: nested_async_execute
 func @nested_async_execute(%arg0: f32, %arg1: f32, %arg2: memref<1xf32>) {
   // CHECK: %[[TOKEN:.*]] = call @async_execute_fn_0(%arg0, %arg2, %arg1)
   %token0 = async.execute {
func @nested_async_execute(%arg0: f32, %arg1: f32, %arg2: memref<1xf32>) {
   async.await %token0 : !async.token
   return
 }
 
 // Function outlined from the inner async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>, %arg2: index)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL_0:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL_0:.*]] = llvm.intr.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 // CHECK: store %arg0, %arg1[%arg2] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the outer async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn_0(%arg0: f32, %arg1: memref<1xf32>, %arg2: f32)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL_1:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL_1:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of inner execute op.
 // CHECK: %[[TOKEN_1:.*]] = call @async_execute_fn
-// CHECK: llvm.call @llvm.coro.save
+// CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitTokenAndExecute(%[[TOKEN_1]], %[[HDL_1]]
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Emplace result token after second resumption.
 // CHECK: store %arg2, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_1]])
 
 // -----
 
 // CHECK-LABEL: async_execute_token_dependency
func @async_execute_token_dependency(%arg0: f32, %arg1: memref<1xf32>) {
   }
   return
 }
 
 // Function outlined from the first async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL_0:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL_0:.*]] = llvm.intr.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 // CHECK: store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the second async.execute operation with dependency.
 // CHECK-LABEL: func private @async_execute_fn_0(%arg0: !llvm.ptr<i8>, %arg1: f32, %arg2: memref<1xf32>)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL_1:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL_1:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL_1]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of token dependency.
-// CHECK: llvm.call @llvm.coro.save
+// CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitTokenAndExecute(%arg0, %[[HDL_1]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Emplace result token after second resumption.
 // CHECK: store %arg1, %arg2[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_1]])
 
 // -----
 
 // CHECK-LABEL: async_group_await_all
func @async_group_await_all(%arg0: f32, %arg1: memref<1xf32>) {
   async.await_all %0
 
   return
 }
 
 // Function outlined from the async.execute operation.
 // CHECK: func private @async_execute_fn_0(%arg0: !llvm.ptr<i8>)
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL_1:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL_1:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL_1]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the group.
-// CHECK: llvm.call @llvm.coro.save
+// CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitAllInGroupAndExecute(%arg0, %[[HDL_1]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Emplace result token.
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_1]])
 
 // -----
 
 // CHECK-LABEL: execute_and_return_f32
 func @execute_and_return_f32() -> f32 {
// CHECK: %[[RET:.*]]:2 = call @async_execute_fn
 
   return %0 : f32
 }
 
 // Function outlined from the async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn()
 // CHECK: %[[TOKEN:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[VALUE:.*]] = call @mlirAsyncRuntimeCreateValue
-// CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Emplace result value.
 // CHECK: %[[CST:.*]] = constant 1.230000e+02 : f32
 // CHECK: %[[STORAGE:.*]] = call @mlirAsyncRuntimeGetValueStorage(%[[VALUE]])
 // CHECK: %[[ST_F32:.*]] = llvm.bitcast %[[STORAGE]]
 // CHECK: llvm.store %[[CST]], %[[ST_F32]] : !llvm.ptr<f32>
 // CHECK: call @mlirAsyncRuntimeEmplaceValue(%[[VALUE]])
 

 }
 
 // Function outlined from the first async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn()
 
 // Function outlined from the second async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn_0(%arg0: !llvm.ptr<i8>)
 // CHECK: %[[TOKEN:.*]] = call @mlirAsyncRuntimeCreateToken()
-// CHECK: %[[HDL:.*]] = llvm.call @llvm.coro.begin
+// CHECK: %[[HDL:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the async operand.
-// CHECK: llvm.call @llvm.coro.save
+// CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitValueAndExecute(%arg0, %[[HDL]],
-// CHECK: llvm.call @llvm.coro.suspend
+// CHECK: llvm.intr.coro.suspend
 
 // Get the operand value storage, cast to f32 and add the value.
 // CHECK: %[[STORAGE:.*]] = call @mlirAsyncRuntimeGetValueStorage(%arg0)
 // CHECK: %[[ST_F32:.*]] = llvm.bitcast %[[STORAGE]]
 // CHECK: %[[LOADED:.*]] = llvm.load %[[ST_F32]] :  !llvm.ptr<f32>
 // CHECK: addf %[[LOADED]], %[[LOADED]] : f32
 
 // Emplace result token.
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[TOKEN]])