[mlir:Async] Use LLVM coro operations to lower from async.coro

[ezhulenev]

Summary

Instead of using function calls to LLVM intrinsics, use intr operations defined in the LLVM dialect.

Leftovers from: https://reviews.llvm.org/D94923

[ezhulenev]

Rebased

[ezhulenev]

Rebase

[ezhulenev]

Rebase

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 = [{
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,
 
     // 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}));
 
     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());
 
     // Allocate memory for the coroutine frame.
     auto coroAlloc = rewriter.create<LLVM::CallOp>(
         loc, i8Ptr, rewriter.getSymbolRefAttr(kMalloc),
         ValueRange(coroSize.getResult(0)));
 
     // 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)}));
 
     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);
 
     // Free the memory.
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, TypeRange(),
                                               rewriter.getSymbolRefAttr(kFree),
                                               ValueRange(coroMem.getResult(0)));
 
     return success();
   }
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),
                                   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);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.suspend to @llvm.coro.suspend intrinsic.
matchAndRewrite(CoroSuspendOp op, ArrayRef<Value> operands,
 
     // 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}));
 
     // 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};
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-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: %[[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]])