[Coroutines] Introduce "coro_readnone" operand bundles (2/3)

[ChuanqiXu]

Summary

This belongs to a series of patches which try to solve the thread identification problem in coroutines. See https://discourse.llvm.org/t/address-thread-identification-problems-with-coroutine/62015 for a full background.

This patch tries to solve the readnone problem by removing the readnone attributes for calls in a coroutine in CoroEarly pass. And we would add the readnone attribute back after the coroutine get split in CoroCleanup pass. To record the calls we removed the attribute and block unexpect optimizations, we introduced "coro_readnone" operand bundles.

Why operand bundles instead of another attribute on the callsite?

Since when the compiler query whether a call is readnone, it would try to lookup to the callee declaration of the call if it failed to find the attribute at the callsite. See https://github.com/llvm/llvm-project/blob/3b762b3ab8d205cd6a7d42c96d39d5f4f701f2ab/llvm/include/llvm/IR/InstrTypes.h#L2315-L2325

The method would only try to process coroutines only to avoid affecting thousands of normal functions.

[ChuanqiXu]

llvm/lib/Transforms/Coroutines/CoroEarly.cpp

238–244

@rjmccall Could we remove the check now? If yes, we could add a check in the beginning of the function to return quickly for normal functions.

[ChuanqiXu]

Although this one is marked (2/3) in the title, it is independent with the previous revision logically. We could review and submit this one independently.

@rjmccall @eli.friedman @jyknight gentle ping~

[efriedma]

I don't think we reached a consensus this is the right approach; please ping the Discourse thread.

[ChuanqiXu]

In D125292#3523819, @efriedma wrote:

I don't think we reached a consensus this is the right approach; please ping the Discourse thread.

Oh, I misread the thread.. I translated it as 'no objections...', will do.

[ChuanqiXu]

Prefer https://reviews.llvm.org/D127383

llvm/docs/LangRef.rst

 
 Pointer Authentication Operand Bundles
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Pointer Authentication operand bundles are characterized by the
 ``"ptrauth"`` operand bundle tag.  They are described in the
 `Pointer Authentication <PointerAuth.html#operand-bundle>`__ document.
 
+Coroutine Readnone Operand Bundles
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A ``"coro_readnone"`` operand bundle on a call indicates the call is a readnone
+call in a coroutine. A call with ``"coro_readnone"`` operand bundle is only allowed
+to appear in a coroutine. The ``"coro_readnone"`` operand bundles would be eliminated
+after the coroutine get splitted.
+
 .. _moduleasm:
 
 Module-Level Inline Assembly
 ----------------------------
 
 Modules may contain "module-level inline asm" blocks, which corresponds
 to the GCC "file scope inline asm" blocks. These blocks are internally
 concatenated by LLVM and treated as a single unit, but may be separated

llvm/include/llvm/IR/LLVMContext.h

enum : unsigned {
     OB_deopt = 0,                  // "deopt"
     OB_funclet = 1,                // "funclet"
     OB_gc_transition = 2,          // "gc-transition"
     OB_cfguardtarget = 3,          // "cfguardtarget"
     OB_preallocated = 4,           // "preallocated"
     OB_gc_live = 5,                // "gc-live"
     OB_clang_arc_attachedcall = 6, // "clang.arc.attachedcall"
     OB_ptrauth = 7,                // "ptrauth"
+    OB_coro_readnone = 8,          // "coro_readnone"
   };
 
   /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
   /// This ID is uniqued across modules in the current LLVMContext.
   unsigned getMDKindID(StringRef Name) const;
 
   /// getMDKindNames - Populate client supplied SmallVector with the name for
   /// custom metadata IDs registered in this LLVMContext.

llvm/lib/IR/LLVMContext.cpp

assert(ClangAttachedCall->second == LLVMContext::OB_clang_arc_attachedcall &&
          "clang.arc.attachedcall operand bundle id drifted!");
   (void)ClangAttachedCall;
 
   auto *PtrauthEntry = pImpl->getOrInsertBundleTag("ptrauth");
   assert(PtrauthEntry->second == LLVMContext::OB_ptrauth &&
          "ptrauth operand bundle id drifted!");
   (void)PtrauthEntry;
 
+  auto *CoroReadnoneEntry = pImpl->getOrInsertBundleTag("coro_readnone");
+  assert(CoroReadnoneEntry->second == LLVMContext::OB_coro_readnone &&
+         "coro_readnone operand bundle id drifted!");
+  (void)CoroReadnoneEntry;
+
   SyncScope::ID SingleThreadSSID =
       pImpl->getOrInsertSyncScopeID("singlethread");
   assert(SingleThreadSSID == SyncScope::SingleThread &&
          "singlethread synchronization scope ID drifted!");
   (void)SingleThreadSSID;
 
   SyncScope::ID SystemSSID =
       pImpl->getOrInsertSyncScopeID("");

llvm/lib/Transforms/Coroutines/CoroCleanup.cpp

 }
 
 bool Lowerer::lower(Function &F) {
   bool IsPrivateAndUnprocessed =
       F.hasFnAttribute(CORO_PRESPLIT_ATTR) && F.hasLocalLinkage();
   bool Changed = false;
 
   for (Instruction &I : llvm::make_early_inc_range(instructions(F))) {
-    if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
+    auto *CB = dyn_cast<CallBase>(&I);
+    if (!CB)
+      continue;
+
+    // Convert "coro_readnone" operand bundles to normal ReadNone attribute
+    // to enable further optimizations.
+    if (CB->getOperandBundle("coro_readnone")) {
+      auto *NewCB =
+          CallBase::removeOperandBundle(CB, LLVMContext::OB_coro_readnone, CB);
+      NewCB->copyMetadata(*CB);
+      NewCB->addFnAttr(Attribute::ReadNone);
+      NewCB->removeFnAttr(Attribute::ReadOnly);
+      NewCB->removeFnAttr(Attribute::InaccessibleMemOnly);
+
+      CB->replaceAllUsesWith(NewCB);
+      CB->eraseFromParent();
+      CB = NewCB;
+    }
+
+    if (auto *II = dyn_cast<IntrinsicInst>(CB)) {
       switch (II->getIntrinsicID()) {
       default:
         continue;
       case Intrinsic::coro_begin:
         II->replaceAllUsesWith(II->getArgOperand(1));
         break;
       case Intrinsic::coro_free:
         II->replaceAllUsesWith(II->getArgOperand(1));

llvm/lib/Transforms/Coroutines/CoroEarly.cpp

for (User *U : CoroId->users())
     if (auto *CB = dyn_cast<CoroBeginInst>(U))
       CB->setCannotDuplicate();
 }
 
 void Lowerer::lowerEarlyIntrinsics(Function &F) {
   CoroIdInst *CoroId = nullptr;
   SmallVector<CoroFreeInst *, 4> CoroFrees;
   bool HasCoroSuspend = false;
+
   for (Instruction &I : llvm::make_early_inc_range(instructions(F))) {
     auto *CB = dyn_cast<CallBase>(&I);
     if (!CB)
       continue;
 
+    // This is a workaround for the bug about pthread_self() in coroutine.
+    // See https://github.com/llvm/llvm-project/issues/47177 for the
+    // background. The reason behind the bug is that pthread_self() is
+    // marked as
+    // __attribute__((__const__)) which would be converted to `readnone`
+    // when get lowered to LLVM IR. The readnone function without parameters
+    // implies that all the calls to the function would return the same
+    // result. So the compiler would optimize the following code:
+    //
+    //   auto a = pthread_self();
+    //   co_await something();
+    //   auto b = pthread_self();
+    //
+    // to
+    //
+    //   auto a = pthread_self();
+    //   co_await something();
+    //   // replace uses of b with a
+    //
+    // The transformation is incorrect in case the coroutine might resume in
+    // another thread. The key reason for the bug is the abuse of
+    // __attribute__((__const__)) for thread identification. However, it is
+    // not easy to fix the problem in the library side (we don't know if
+    // there are other similar problems in other places) and ask the end
+    // user to update the library. So we choose to block the optimization
+    // before we split coroutine by replacing readnone attribute as a
+    // placeholder so that we could rewrite readnone after we lowered
+    // coroutines.
+    if (F.isPresplitCoroutine() && CB->hasFnAttr(Attribute::ReadNone) &&
+        !isa<DbgInfoIntrinsic>(CB)) {
+      OperandBundleDef OB("coro_readnone", std::vector<Value *>{});
+      auto *NewCall =
+          CallBase::addOperandBundle(CB, LLVMContext::OB_coro_readnone, OB, CB);
+      NewCall->copyMetadata(*CB);
+      NewCall->removeFnAttr(Attribute::ReadNone);
+      // We add readonly and inaccessiblememonly attributes here to enable
+      // optimizations as much as possible.
+      NewCall->addFnAttr(Attribute::ReadOnly);
+      NewCall->addFnAttr(Attribute::InaccessibleMemOnly);
+
+      CB->replaceAllUsesWith(NewCall);
+      CB->eraseFromParent();
+      CB = NewCall;
+    }
+
     switch (CB->getIntrinsicID()) {
       default:
         continue;
       case Intrinsic::coro_free:
         CoroFrees.push_back(cast<CoroFreeInst>(&I));
         break;
       case Intrinsic::coro_suspend:
         // Make sure that final suspend point is not duplicated as CoroSplit
switch (CB->getIntrinsicID()) {
                    "The frontend uses Swtich-Resumed ABI should emit "
                    "\"coroutine.presplit\" attribute for the coroutine.");
             setCannotDuplicate(CII);
             CII->setCoroutineSelf();
             CoroId = cast<CoroIdInst>(&I);
           }
         }
         break;
       case Intrinsic::coro_id_retcon:
       case Intrinsic::coro_id_retcon_once:
       case Intrinsic::coro_id_async:
         // TODO: Remove the line once we support it in the corresponding
         // frontend.
         F.addFnAttr(CORO_PRESPLIT_ATTR);
         break;
       case Intrinsic::coro_resume:
         lowerResumeOrDestroy(*CB, CoroSubFnInst::ResumeIndex);
         break;
       case Intrinsic::coro_destroy:
         lowerResumeOrDestroy(*CB, CoroSubFnInst::DestroyIndex);
         break;
       case Intrinsic::coro_promise:
         lowerCoroPromise(cast<CoroPromiseInst>(&I));

llvm/lib/Transforms/Utils/InlineFunction.cpp

for (int i = 0, e = CB.getNumOperandBundles(); i != e; ++i) {
       if (Tag == LLVMContext::OB_deopt)
         continue;
       // ... and "funclet" operand bundles.
       if (Tag == LLVMContext::OB_funclet)
         continue;
       if (Tag == LLVMContext::OB_clang_arc_attachedcall)
         continue;
 
+      // We could inline calls with "coro_readnone" directly.
+      if (Tag == LLVMContext::OB_coro_readnone)
+        continue;
+
       return InlineResult::failure("unsupported operand bundle");
     }
   }
 
   // If the call to the callee cannot throw, set the 'nounwind' flag on any
   // calls that we inline.
   bool MarkNoUnwind = CB.doesNotThrow();
 
for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
           ChildTCK = std::min(CallSiteTailKind, ChildTCK);
         CI->setTailCallKind(ChildTCK);
         InlinedMustTailCalls |= CI->isMustTailCall();
 
         // Calls inlined through a 'nounwind' call site should be marked
         // 'nounwind'.
         if (MarkNoUnwind)
           CI->setDoesNotThrow();
+
+        // Due to legacy reasons, the readnone function might read the thread
+        // identification. It is fine before we introduced coroutines since a
+        // coroutine might resume in another thread. Here we remove the readnone
+        // attibute when we inline readnone calls to an unlowered coroutines to
+        // disable the incorrect optimizations. The readnone attribute would be
+        // added back after the coroutine get lowered.
+        if (Caller->isPresplitCoroutine() &&
+            CI->hasFnAttr(Attribute::ReadNone) && !isa<DbgInfoIntrinsic>(CI)) {
+          OperandBundleDef OB("coro_readnone", std::vector<Value *>{});
+          auto *NewCI = CallBase::addOperandBundle(
+              CI, LLVMContext::OB_coro_readnone, OB, CI);
+          NewCI->copyMetadata(*CI);
+          NewCI->removeFnAttr(Attribute::ReadNone);
+          // We add readonly and inaccessiblememonly attributes here to enable
+          // optimizations as much as possible.
+          NewCI->addFnAttr(Attribute::ReadOnly);
+          NewCI->addFnAttr(Attribute::InaccessibleMemOnly);
+
+          CI->replaceAllUsesWith(NewCI);
+          CI->eraseFromParent();
+        }
       }
     }
   }
 
   // Leave lifetime markers for the static alloca's, scoping them to the
   // function we just inlined.
   // We need to insert lifetime intrinsics even at O0 to avoid invalid
   // access caused by multithreaded coroutines. The check

llvm/test/Bitcode/operand-bundles-bc-analyzer.ll

 ; RUN: llvm-as < %s | llvm-bcanalyzer -dump -disable-histogram | FileCheck %s
 
 ; CHECK:  <OPERAND_BUNDLE_TAGS_BLOCK
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
+; CHECK-NEXT:    <OPERAND_BUNDLE_TAG
 ; CHECK-NEXT:  </OPERAND_BUNDLE_TAGS_BLOCK
 
 ; CHECK:   <FUNCTION_BLOCK
 ; CHECK:    <OPERAND_BUNDLE
 ; CHECK:    <OPERAND_BUNDLE
 ; CHECK-NOT: <OPERAND_BUNDLE
 ; CHECK:  </FUNCTION_BLOCK
 

llvm/test/Transforms/Coroutines/coro-readnone-01.ll

+; Tests that the readnone function which cross suspend points wouldn't be misoptimized.
+; RUN: opt < %s -S -passes='default<O3>' -opaque-pointers | FileCheck %s
+
+define ptr @f() "coroutine.presplit" {
+entry:
+  %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call i8* @malloc(i32 %size)
+  %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+  %j = call i32 @readnone_func() readnone
+  %sus_result = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %sus_result, label %suspend [i8 0, label %resume
+                                         i8 1, label %cleanup]
+resume:
+  %i = call i32 @readnone_func() readnone
+  %cmp = icmp eq i32 %i, %j
+  br i1 %cmp, label %same, label %diff
+
+same:
+  call void @print_same()
+  br label %cleanup
+
+diff:
+  call void @print_diff()
+  br label %cleanup
+
+cleanup:
+  %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
+  call void @free(i8* %mem)
+  br label %suspend
+
+suspend:
+  call i1 @llvm.coro.end(i8* %hdl, i1 0)
+  ret i8* %hdl
+}
+
+; Tests that normal functions wouldn't be affected.
+define i1 @normal_function() {
+entry:
+  %i = call i32 @readnone_func() readnone
+  %j = call i32 @readnone_func() readnone
+  %cmp = icmp eq i32 %i, %j
+  br i1 %cmp, label %same, label %diff
+
+same:
+  call void @print_same()
+  ret i1 true
+
+diff:
+  call void @print_diff()
+  ret i1 false
+}
+
+; CHECK-LABEL: normal_function(
+; CHECK-NEXT: entry
+; CHECK-NEXT:   call i32 @readnone_func()
+; CHECK-NEXT:   call void @print_same()
+; CHECK-NEXT:   ret i1 true
+;
+; CHECK-LABEL: f.resume(
+; CHECK: br i1 %cmp, label %same, label %diff
+; CHECK-EMPTY:
+; CHECK-NEXT: same:
+; CHECK-NEXT:   call void @print_same()
+; CHECK-NEXT:   br label
+; CHECK-EMPTY:
+; CHECK-NEXT: diff:
+; CHECK-NEXT:   call void @print_diff()
+; CHECK-NEXT:   br label
+
+declare i32 @readnone_func() readnone
+
+declare void @print_same()
+declare void @print_diff()
+declare i8* @llvm.coro.free(token, i8*)
+declare i32 @llvm.coro.size.i32()
+declare i8  @llvm.coro.suspend(token, i1)
+
+declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare i1 @llvm.coro.alloc(token)
+declare i8* @llvm.coro.begin(token, i8*)
+declare i1 @llvm.coro.end(i8*, i1)
+
+declare noalias i8* @malloc(i32)
+declare void @free(i8*)

llvm/test/Transforms/Coroutines/coro-readnone-02.ll

+; Tests that the calls with "coro_readnone" operand bundles could be lowered
+; correctly by CoroCleanup pass.
+; RUN: opt < %s -S -passes=coro-cleanup -opaque-pointers | FileCheck %s
+
+%f.Frame = type { ptr, ptr, i32, i1 }
+
[e-mail] = private constant [3 x ptr] [ptr @f.resume, ptr @f.destroy, ptr @f.cleanup]
+
+define ptr @f() {
+entry:
+  %id = call token @llvm.coro.id(i32 0, ptr null, ptr @f, ptr @f.resumers)
+  %alloc = call ptr @malloc(i32 24)
+  %hdl = call noalias nonnull ptr @llvm.coro.begin(token %id, ptr %alloc)
+  %resume.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 0
+  store ptr @f.resume, ptr %resume.addr, align 8
+  %destroy.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 1
+  store ptr @f.destroy, ptr %destroy.addr, align 8
+  %j2 = call i32 @readnone_func() [ "coro_readnone"() ]
+  %j2.spill.addr = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 2
+  store i32 %j2, ptr %j2.spill.addr, align 4
+  %index.addr4 = getelementptr inbounds %f.Frame, ptr %hdl, i32 0, i32 3
+  store i1 false, ptr %index.addr4, align 1
+  ret ptr %hdl
+}
+
+; CHECK: call i32 @readnone_func() #[[ATTR_NUM:[0-9]+]]
+; CHECK: attributes #[[ATTR_NUM]] = { readnone }
+
+declare void @f.resume()
+declare void @f.destroy()
+declare void @f.cleanup()
+
+declare i32 @readnone_func() readnone
+declare void @print_same()
+declare void @print_diff()
+
+declare ptr @llvm.coro.free(token, ptr nocapture readonly)
+declare i32 @llvm.coro.size.i32()
+declare i8 @llvm.coro.suspend(token, i1)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)
+declare i1 @llvm.coro.alloc(token)
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+declare i1 @llvm.coro.end(ptr, i1)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)

llvm/test/Transforms/Coroutines/coro-readnone-03.ll

+; Tests that the readnone function attribute could be lowered correctly by
+; CoroEarly and EarlyCSE pass.
+;
+; The following line tests that CoroEarly pass would add "coro_readnone" operand
+; bundle for readnone calls correctly.
+; RUN: opt < %s -S -passes=coro-early -opaque-pointers | FileCheck %s
+;
+; The following line tests that EarlyCSE pass wouldn't optimize calls with
+; "coro_readnone" operand bundles.
+; RUN: opt < %s -S -passes=coro-early,early-cse -opaque-pointers | FileCheck %s
+
+define ptr @f() "coroutine.presplit" {
+entry:
+  %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call i8* @malloc(i32 %size)
+  %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+  %j = call i32 @readnone_func() readnone
+  %sus_result = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %sus_result, label %suspend [i8 0, label %resume
+                                         i8 1, label %cleanup]
+resume:
+  %i = call i32 @readnone_func() readnone
+  %cmp = icmp eq i32 %i, %j
+  br i1 %cmp, label %same, label %diff
+
+same:
+  call void @print_same()
+  br label %cleanup
+
+diff:
+  call void @print_diff()
+  br label %cleanup
+
+cleanup:
+  %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
+  call void @free(i8* %mem)
+  br label %suspend
+
+suspend:
+  call i1 @llvm.coro.end(i8* %hdl, i1 0)
+  ret i8* %hdl
+}
+
+; CHECK: call i32 @readnone_func() #[[ATTR_NUM:[0-9]+]] [ "coro_readnone"() ]
+; CHECK: call i32 @readnone_func() #[[ATTR_NUM]] [ "coro_readnone"() ]
+; CHECK: attributes #[[ATTR_NUM]] = { inaccessiblememonly readonly }
+
+declare i32 @readnone_func() readnone
+
+declare void @print_same()
+declare void @print_diff()
+declare i8* @llvm.coro.free(token, i8*)
+declare i32 @llvm.coro.size.i32()
+declare i8  @llvm.coro.suspend(token, i1)
+
+declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare i1 @llvm.coro.alloc(token)
+declare i8* @llvm.coro.begin(token, i8*)
+declare i1 @llvm.coro.end(i8*, i1)
+
+declare noalias i8* @malloc(i32)
+declare void @free(i8*)

llvm/test/Transforms/Coroutines/coro-readnone-04.ll

+; Tests that the readnone functions not in coroutines directly wouldn't be misoptimized
+; RUN: opt < %s -S -passes='default<O3>' -opaque-pointers | FileCheck %s
+; RUN: opt < %s -S -passes=inline -opaque-pointers | FileCheck %s --check-prefix=CHECK-INLINE
+
+define ptr @f() "coroutine.presplit" {
+entry:
+  %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call i8* @malloc(i32 %size)
+  %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+  %j = call i32 @g()
+  %sus_result = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %sus_result, label %suspend [i8 0, label %resume
+                                         i8 1, label %cleanup]
+resume:
+  %i = call i32 @g()
+  %cmp = icmp eq i32 %i, %j
+  br i1 %cmp, label %same, label %diff
+
+same:
+  call void @print_same()
+  br label %cleanup
+
+diff:
+  call void @print_diff()
+  br label %cleanup
+
+cleanup:
+  %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
+  call void @free(i8* %mem)
+  br label %suspend
+
+suspend:
+  call i1 @llvm.coro.end(i8* %hdl, i1 0)
+  ret i8* %hdl
+}
+
+define i32 @g() alwaysinline {
+entry:
+    %ret = call i32 @readnone_func() readnone
+    ret i32 %ret
+}
+
+; CHECK-LABEL: f.resume(
+; CHECK: br i1 %cmp, label %same, label %diff
+; CHECK-EMPTY:
+; CHECK-NEXT: same:
+; CHECK-NEXT:   call void @print_same()
+; CHECK-NEXT:   br label
+; CHECK-EMPTY:
+; CHECK-NEXT: diff:
+; CHECK-NEXT:   call void @print_diff()
+; CHECK-NEXT:   br label
+
+; CHECK-INLINE-LABEL: @f
+; CHECK-INLINE: call i32 @readnone_func() #[[ATTR_NUM:[0-9]+]] [ "coro_readnone"() ]
+; CHECK-INLINE: call i32 @readnone_func() #[[ATTR_NUM]] [ "coro_readnone"() ]
+; CHECK-INLINE-LABEL: @g
+; CHECK-INLINE: attributes #[[ATTR_NUM]] = { inaccessiblememonly readonly }
+
+declare i32 @readnone_func() readnone
+
+declare void @print_same()
+declare void @print_diff()
+declare i8* @llvm.coro.free(token, i8*)
+declare i32 @llvm.coro.size.i32()
+declare i8  @llvm.coro.suspend(token, i1)
+
+declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare i1 @llvm.coro.alloc(token)
+declare i8* @llvm.coro.begin(token, i8*)
+declare i1 @llvm.coro.end(i8*, i1)
+
+declare noalias i8* @malloc(i32)
+declare void @free(i8*)

llvm/test/Transforms/Coroutines/coro-readnone-05.ll

+; Tests that the calls with "coro_readnone" operand bundels could be inlined correctly.
+; RUN: opt < %s -S -passes='default<O3>' -opaque-pointers | FileCheck %s
+; RUN: opt < %s -S -passes=inline -opaque-pointers | FileCheck %s --check-prefix=CHECK-INLINE
+
+define ptr @f() "coroutine.presplit" {
+entry:
+  %id = call token @llvm.coro.id(i32 0, i8* null, i8* null, i8* null)
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call i8* @malloc(i32 %size)
+  %hdl = call i8* @llvm.coro.begin(token %id, i8* %alloc)
+  %j = call i32 @g() [ "coro_readnone"() ]
+  %sus_result = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %sus_result, label %suspend [i8 0, label %resume
+                                         i8 1, label %cleanup]
+resume:
+  %i = call i32 @g() [ "coro_readnone"() ]
+  %cmp = icmp eq i32 %i, %j
+  br i1 %cmp, label %same, label %diff
+
+same:
+  call void @print_same()
+  br label %cleanup
+
+diff:
+  call void @print_diff()
+  br label %cleanup
+
+cleanup:
+  %mem = call i8* @llvm.coro.free(token %id, i8* %hdl)
+  call void @free(i8* %mem)
+  br label %suspend
+
+suspend:
+  call i1 @llvm.coro.end(i8* %hdl, i1 0)
+  ret i8* %hdl
+}
+
+define i32 @g() readnone {
+entry:
+    %ret = call i32 @readnone_func() readnone
+    ret i32 %ret
+}
+
+; CHECK-LABEL: f.resume(
+; CHECK: br i1 %cmp, label %same, label %diff
+; CHECK-EMPTY:
+; CHECK-NEXT: same:
+; CHECK-NEXT:   call void @print_same()
+; CHECK-NEXT:   br label
+; CHECK-EMPTY:
+; CHECK-NEXT: diff:
+; CHECK-NEXT:   call void @print_diff()
+; CHECK-NEXT:   br label
+
+; CHECK-INLINE-LABEL: @f
+; CHECK-INLINE: call i32 @readnone_func() #[[ATTR_NUM:[0-9]+]] [ "coro_readnone"() ]
+; CHECK-INLINE: call i32 @readnone_func() #[[ATTR_NUM]] [ "coro_readnone"() ]
+; CHECK-INLINE-LABEL: @g
+; CHECK-INLINE: attributes #[[ATTR_NUM]] = { inaccessiblememonly readonly }
+
+declare i32 @readnone_func() readnone
+
+declare void @print_same()
+declare void @print_diff()
+declare i8* @llvm.coro.free(token, i8*)
+declare i32 @llvm.coro.size.i32()
+declare i8  @llvm.coro.suspend(token, i1)
+
+declare token @llvm.coro.id(i32, i8*, i8*, i8*)
+declare i1 @llvm.coro.alloc(token)
+declare i8* @llvm.coro.begin(token, i8*)
+declare i1 @llvm.coro.end(i8*, i1)
+
+declare noalias i8* @malloc(i32)
+declare void @free(i8*)