3bb39690d7
The C++ standard requires that symmetric transfer from one coroutine to another is performed via a tail call. Failure to do so is a miscompile and often breaks programs by quickly overflowing the stack. Until now, the coro split pass tried to ensure this in the `addMustTailToCoroResumes()` function by searching for `llvm.coro.resume` calls to lower as tail calls if the conditions were right: the right function arguments, attributes, calling convention etc., and if a `ret void` was sure to be reached after traversal with some ad-hoc constant folding following the call. This was brittle, as the kind of implicit variants required for a tail call to happen could easily be broken by other passes (e.g. if some instruction got in between the `resume` and `ret`), see for example9d1cb18d19and284da049f5. Also the logic seemed backwards: instead of searching for possible tail call candidates and doing them if the circumstances are right, it seems better to start with the intention of making the tail calls we need, and forcing the circumstances to be right. Now that we have the `llvm.coro.await.suspend.handle` intrinsic (sincef786881340) which corresponds exactly to symmetric transfer, change the lowering of that to also include the `resume` part, always lowered as a tail call.
396 lines
15 KiB
C++
396 lines
15 KiB
C++
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple x86_64-unknown-linux-gnu -std=c++20 \
|
|
// RUN: -emit-llvm %s -o - -disable-llvm-passes -Wno-coroutine -Wno-unused | FileCheck %s
|
|
|
|
namespace std {
|
|
template <typename... T>
|
|
struct coroutine_traits;
|
|
|
|
template <typename Promise = void> struct coroutine_handle;
|
|
|
|
template <>
|
|
struct coroutine_handle<void> {
|
|
void *ptr;
|
|
static coroutine_handle from_address(void *);
|
|
void *address();
|
|
};
|
|
|
|
template <typename Promise>
|
|
struct coroutine_handle : coroutine_handle<> {
|
|
static coroutine_handle from_address(void *) noexcept;
|
|
};
|
|
|
|
} // namespace std
|
|
|
|
struct init_susp {
|
|
bool await_ready();
|
|
void await_suspend(std::coroutine_handle<>);
|
|
void await_resume();
|
|
};
|
|
struct final_susp {
|
|
bool await_ready() noexcept;
|
|
void await_suspend(std::coroutine_handle<>) noexcept;
|
|
void await_resume() noexcept;
|
|
};
|
|
|
|
struct suspend_always {
|
|
int stuff;
|
|
bool await_ready();
|
|
void await_suspend(std::coroutine_handle<>);
|
|
void await_resume();
|
|
};
|
|
|
|
template <>
|
|
struct std::coroutine_traits<void> {
|
|
struct promise_type {
|
|
void get_return_object();
|
|
init_susp initial_suspend();
|
|
final_susp final_suspend() noexcept;
|
|
void return_void();
|
|
};
|
|
};
|
|
|
|
// CHECK-LABEL: f0(
|
|
extern "C" void f0() {
|
|
// CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
|
|
|
|
// See if initial_suspend was issued:
|
|
// ----------------------------------
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
|
|
// CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(ptr
|
|
// CHECK: %[[INITSP_ID:.+]] = call token @llvm.coro.save(
|
|
// CHECK: call i8 @llvm.coro.suspend(token %[[INITSP_ID]], i1 false)
|
|
|
|
co_await suspend_always{};
|
|
// See if we need to suspend:
|
|
// --------------------------
|
|
// CHECK: %[[READY:.+]] = call zeroext i1 @_ZN14suspend_always11await_readyEv(ptr {{[^,]*}} %[[AWAITABLE:.+]])
|
|
// CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
|
|
|
|
// If we are suspending:
|
|
// ---------------------
|
|
// CHECK: [[SUSPEND_BB]]:
|
|
// CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
|
|
// ---------------------------
|
|
// Call coro.await.suspend
|
|
// ---------------------------
|
|
// CHECK-NEXT: call void @llvm.coro.await.suspend.void(ptr %[[AWAITABLE]], ptr %[[FRAME]], ptr @f0.__await_suspend_wrapper__await)
|
|
// -------------------------
|
|
// Generate a suspend point:
|
|
// -------------------------
|
|
// CHECK-NEXT: %[[OUTCOME:.+]] = call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
|
|
// CHECK: switch i8 %[[OUTCOME]], label %[[RET_BB:.+]] [
|
|
// CHECK: i8 0, label %[[READY_BB]]
|
|
// CHECK: i8 1, label %[[CLEANUP_BB:.+]]
|
|
// CHECK: ]
|
|
|
|
// Cleanup code goes here:
|
|
// -----------------------
|
|
// CHECK: [[CLEANUP_BB]]:
|
|
|
|
// When coroutine is resumed, call await_resume
|
|
// --------------------------
|
|
// CHECK: [[READY_BB]]:
|
|
// CHECK: call void @_ZN14suspend_always12await_resumeEv(ptr {{[^,]*}} %[[AWAITABLE]])
|
|
|
|
// See if final_suspend was issued:
|
|
// ----------------------------------
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type13final_suspendEv(
|
|
// CHECK-NEXT: call zeroext i1 @_ZN10final_susp11await_readyEv(ptr
|
|
// CHECK: %[[FINALSP_ID:.+]] = call token @llvm.coro.save(
|
|
// CHECK: call i8 @llvm.coro.suspend(token %[[FINALSP_ID]], i1 true)
|
|
|
|
// Await suspend wrapper
|
|
// CHECK: define{{.*}} @f0.__await_suspend_wrapper__await(ptr {{[^,]*}} %[[AWAITABLE_ARG:.+]], ptr {{[^,]*}} %[[FRAME_ARG:.+]])
|
|
// CHECK: store ptr %[[AWAITABLE_ARG]], ptr %[[AWAITABLE_TMP:.+]],
|
|
// CHECK: store ptr %[[FRAME_ARG]], ptr %[[FRAME_TMP:.+]],
|
|
// CHECK: %[[AWAITABLE:.+]] = load ptr, ptr %[[AWAITABLE_TMP]]
|
|
// CHECK: %[[FRAME:.+]] = load ptr, ptr %[[FRAME_TMP]]
|
|
// CHECK: call ptr @_ZNSt16coroutine_handleINSt16coroutine_traitsIJvEE12promise_typeEE12from_addressEPv(ptr %[[FRAME]])
|
|
// ... many lines of code to coerce coroutine_handle into an ptr scalar
|
|
// CHECK: %[[CH:.+]] = load ptr, ptr %{{.+}}
|
|
// CHECK: call void @_ZN14suspend_always13await_suspendESt16coroutine_handleIvE(ptr {{[^,]*}} %[[AWAITABLE]], ptr %[[CH]])
|
|
}
|
|
|
|
struct suspend_maybe {
|
|
float stuff;
|
|
~suspend_maybe();
|
|
bool await_ready();
|
|
bool await_suspend(std::coroutine_handle<>);
|
|
void await_resume();
|
|
};
|
|
|
|
template <>
|
|
struct std::coroutine_traits<void, int> {
|
|
struct promise_type {
|
|
void get_return_object();
|
|
init_susp initial_suspend();
|
|
final_susp final_suspend() noexcept;
|
|
void return_void();
|
|
suspend_maybe yield_value(int);
|
|
};
|
|
};
|
|
|
|
// CHECK-LABEL: f1(
|
|
extern "C" void f1(int) {
|
|
// CHECK: %[[PROMISE:.+]] = alloca %"struct.std::coroutine_traits<void, int>::promise_type"
|
|
// CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
|
|
co_yield 42;
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIJviEE12promise_type11yield_valueEi(ptr dead_on_unwind writable sret(%struct.suspend_maybe) align 4 %[[AWAITER:.+]], ptr {{[^,]*}} %[[PROMISE]], i32 42)
|
|
|
|
// See if we need to suspend:
|
|
// --------------------------
|
|
// CHECK: %[[READY:.+]] = call zeroext i1 @_ZN13suspend_maybe11await_readyEv(ptr {{[^,]*}} %[[AWAITABLE:.+]])
|
|
// CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
|
|
|
|
// If we are suspending:
|
|
// ---------------------
|
|
// CHECK: [[SUSPEND_BB]]:
|
|
// CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
|
|
// ---------------------------
|
|
// Call coro.await.suspend
|
|
// ---------------------------
|
|
// CHECK-NEXT: %[[YES:.+]] = call i1 @llvm.coro.await.suspend.bool(ptr %[[AWAITABLE]], ptr %[[FRAME]], ptr @f1.__await_suspend_wrapper__yield)
|
|
// -------------------------------------------
|
|
// See if await_suspend decided not to suspend
|
|
// -------------------------------------------
|
|
// CHECK: br i1 %[[YES]], label %[[SUSPEND_PLEASE:.+]], label %[[READY_BB]]
|
|
|
|
// CHECK: [[SUSPEND_PLEASE]]:
|
|
// CHECK: call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
|
|
|
|
// CHECK: [[READY_BB]]:
|
|
// CHECK: call void @_ZN13suspend_maybe12await_resumeEv(ptr {{[^,]*}} %[[AWAITABLE]])
|
|
|
|
// Await suspend wrapper
|
|
// CHECK: define {{.*}} i1 @f1.__await_suspend_wrapper__yield(ptr {{[^,]*}} %[[AWAITABLE_ARG:.+]], ptr {{[^,]*}} %[[FRAME_ARG:.+]])
|
|
// CHECK: store ptr %[[AWAITABLE_ARG]], ptr %[[AWAITABLE_TMP:.+]],
|
|
// CHECK: store ptr %[[FRAME_ARG]], ptr %[[FRAME_TMP:.+]],
|
|
// CHECK: %[[AWAITABLE:.+]] = load ptr, ptr %[[AWAITABLE_TMP]]
|
|
// CHECK: %[[FRAME:.+]] = load ptr, ptr %[[FRAME_TMP]]
|
|
// CHECK: call ptr @_ZNSt16coroutine_handleINSt16coroutine_traitsIJviEE12promise_typeEE12from_addressEPv(ptr %[[FRAME]])
|
|
// ... many lines of code to coerce coroutine_handle into an ptr scalar
|
|
// CHECK: %[[CH:.+]] = load ptr, ptr %{{.+}}
|
|
// CHECK: %[[YES:.+]] = call zeroext i1 @_ZN13suspend_maybe13await_suspendESt16coroutine_handleIvE(ptr {{[^,]*}} %[[AWAITABLE]], ptr %[[CH]])
|
|
// CHECK-NEXT: ret i1 %[[YES]]
|
|
}
|
|
|
|
struct ComplexAwaiter {
|
|
template <typename F> void await_suspend(F);
|
|
bool await_ready();
|
|
_Complex float await_resume();
|
|
};
|
|
extern "C" void UseComplex(_Complex float);
|
|
|
|
// CHECK-LABEL: @TestComplex(
|
|
extern "C" void TestComplex() {
|
|
UseComplex(co_await ComplexAwaiter{});
|
|
// CHECK: call <2 x float> @_ZN14ComplexAwaiter12await_resumeEv(ptr
|
|
// CHECK: call void @UseComplex(<2 x float> %{{.+}})
|
|
|
|
co_await ComplexAwaiter{};
|
|
// CHECK: call <2 x float> @_ZN14ComplexAwaiter12await_resumeEv(ptr
|
|
|
|
_Complex float Val = co_await ComplexAwaiter{};
|
|
// CHECK: call <2 x float> @_ZN14ComplexAwaiter12await_resumeEv(ptr
|
|
}
|
|
|
|
struct Aggr { int X, Y, Z; ~Aggr(); };
|
|
struct AggrAwaiter {
|
|
template <typename F> void await_suspend(F);
|
|
bool await_ready();
|
|
Aggr await_resume();
|
|
};
|
|
|
|
extern "C" void Whatever();
|
|
extern "C" void UseAggr(Aggr&&);
|
|
|
|
// FIXME: Once the cleanup code is in, add testing that destructors for Aggr
|
|
// are invoked properly on the cleanup branches.
|
|
|
|
// CHECK-LABEL: @TestAggr(
|
|
extern "C" void TestAggr() {
|
|
UseAggr(co_await AggrAwaiter{});
|
|
Whatever();
|
|
// CHECK: call void @_ZN11AggrAwaiter12await_resumeEv(ptr dead_on_unwind writable sret(%struct.Aggr) align 4 %[[AwaitResume:.+]],
|
|
// CHECK: call void @UseAggr(ptr nonnull align 4 dereferenceable(12) %[[AwaitResume]])
|
|
// CHECK: call void @_ZN4AggrD1Ev(ptr {{[^,]*}} %[[AwaitResume]])
|
|
// CHECK: call void @Whatever()
|
|
|
|
co_await AggrAwaiter{};
|
|
Whatever();
|
|
// CHECK: call void @_ZN11AggrAwaiter12await_resumeEv(ptr dead_on_unwind writable sret(%struct.Aggr) align 4 %[[AwaitResume2:.+]],
|
|
// CHECK: call void @_ZN4AggrD1Ev(ptr {{[^,]*}} %[[AwaitResume2]])
|
|
// CHECK: call void @Whatever()
|
|
|
|
Aggr Val = co_await AggrAwaiter{};
|
|
Whatever();
|
|
// CHECK: call void @_ZN11AggrAwaiter12await_resumeEv(ptr dead_on_unwind writable sret(%struct.Aggr) align 4 %[[AwaitResume3:.+]],
|
|
// CHECK: call void @Whatever()
|
|
// CHECK: call void @_ZN4AggrD1Ev(ptr {{[^,]*}} %[[AwaitResume3]])
|
|
}
|
|
|
|
struct ScalarAwaiter {
|
|
template <typename F> void await_suspend(F);
|
|
bool await_ready();
|
|
int await_resume();
|
|
};
|
|
|
|
extern "C" void UseScalar(int);
|
|
|
|
// CHECK-LABEL: @TestScalar(
|
|
extern "C" void TestScalar() {
|
|
UseScalar(co_await ScalarAwaiter{});
|
|
// CHECK: %[[Result:.+]] = call i32 @_ZN13ScalarAwaiter12await_resumeEv(ptr
|
|
// CHECK: call void @UseScalar(i32 %[[Result]])
|
|
|
|
int Val = co_await ScalarAwaiter{};
|
|
// CHECK: %[[Result2:.+]] = call i32 @_ZN13ScalarAwaiter12await_resumeEv(ptr
|
|
// CHECK: store i32 %[[Result2]], ptr %[[TMP_EXPRCLEANUP:.+]],
|
|
// CHECK: %[[TMP:.+]] = load i32, ptr %[[TMP_EXPRCLEANUP]],
|
|
// CHECK: store i32 %[[TMP]], ptr %Val,
|
|
|
|
co_await ScalarAwaiter{};
|
|
// CHECK: call i32 @_ZN13ScalarAwaiter12await_resumeEv(ptr
|
|
}
|
|
|
|
// Test operator co_await codegen.
|
|
enum class MyInt: int {};
|
|
ScalarAwaiter operator co_await(MyInt);
|
|
|
|
struct MyAgg {
|
|
AggrAwaiter operator co_await();
|
|
};
|
|
|
|
// CHECK-LABEL: @TestOpAwait(
|
|
extern "C" void TestOpAwait() {
|
|
co_await MyInt(42);
|
|
// CHECK: call void @_Zaw5MyInt(i32 42)
|
|
// CHECK: call i32 @_ZN13ScalarAwaiter12await_resumeEv(ptr {{[^,]*}} %
|
|
|
|
co_await MyAgg{};
|
|
// CHECK: call void @_ZN5MyAggawEv(ptr {{[^,]*}} %
|
|
// CHECK: call void @_ZN11AggrAwaiter12await_resumeEv(ptr dead_on_unwind writable sret(%struct.Aggr) align 4 %
|
|
}
|
|
|
|
// CHECK-LABEL: EndlessLoop(
|
|
extern "C" void EndlessLoop() {
|
|
// CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
|
|
|
|
// See if initial_suspend was issued:
|
|
// ----------------------------------
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
|
|
// CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(ptr
|
|
|
|
for (;;)
|
|
co_await suspend_always{};
|
|
|
|
// Verify that final_suspend was NOT issued:
|
|
// ----------------------------------
|
|
// CHECK-NOT: call void @_ZNSt16coroutine_traitsIJvEE12promise_type13final_suspendEv(
|
|
// CHECK-NOT: call zeroext i1 @_ZN10final_susp11await_readyEv(ptr
|
|
}
|
|
|
|
// Verifies that we don't crash when awaiting on an lvalue.
|
|
// CHECK-LABEL: @_Z11AwaitLValuev(
|
|
void AwaitLValue() {
|
|
suspend_always lval;
|
|
co_await lval;
|
|
}
|
|
|
|
struct RefTag { };
|
|
|
|
struct AwaitResumeReturnsLValue {
|
|
bool await_ready();
|
|
void await_suspend(std::coroutine_handle<>);
|
|
RefTag& await_resume();
|
|
};
|
|
|
|
template <>
|
|
struct std::coroutine_traits<void, double> {
|
|
struct promise_type {
|
|
void get_return_object();
|
|
init_susp initial_suspend();
|
|
final_susp final_suspend() noexcept;
|
|
void return_void();
|
|
AwaitResumeReturnsLValue yield_value(int);
|
|
};
|
|
};
|
|
|
|
// Verifies that we don't crash when returning an lvalue from an await_resume()
|
|
// expression.
|
|
// CHECK-LABEL: define{{.*}} void @_Z18AwaitReturnsLValued(double %0)
|
|
void AwaitReturnsLValue(double) {
|
|
AwaitResumeReturnsLValue a;
|
|
// CHECK: %[[AVAR:.+]] = alloca %struct.AwaitResumeReturnsLValue,
|
|
// CHECK: %[[XVAR:.+]] = alloca ptr,
|
|
|
|
// CHECK: %[[YVAR:.+]] = alloca ptr,
|
|
// CHECK-NEXT: %[[TMP1:.+]] = alloca %struct.AwaitResumeReturnsLValue,
|
|
|
|
// CHECK: %[[TMP_EXPRCLEANUP1:.+]] = alloca ptr,
|
|
// CHECK: %[[ZVAR:.+]] = alloca ptr,
|
|
// CHECK-NEXT: %[[TMP2:.+]] = alloca %struct.AwaitResumeReturnsLValue,
|
|
// CHECK: %[[TMP_EXPRCLEANUP2:.+]] = alloca ptr,
|
|
|
|
// CHECK: %[[RES1:.+]] = call nonnull align 1 dereferenceable({{.*}}) ptr @_ZN24AwaitResumeReturnsLValue12await_resumeEv(ptr {{[^,]*}} %[[AVAR]])
|
|
// CHECK-NEXT: store ptr %[[RES1]], ptr %[[XVAR]],
|
|
RefTag& x = co_await a;
|
|
|
|
// CHECK: %[[RES2:.+]] = call nonnull align 1 dereferenceable({{.*}}) ptr @_ZN24AwaitResumeReturnsLValue12await_resumeEv(ptr {{[^,]*}} %[[TMP1]])
|
|
// CHECK-NEXT: store ptr %[[RES2]], ptr %[[TMP_EXPRCLEANUP1]],
|
|
// CHECK: %[[LOAD_TMP1:.+]] = load ptr, ptr %[[TMP_EXPRCLEANUP1]],
|
|
// CHECK: store ptr %[[LOAD_TMP1]], ptr %[[YVAR]],
|
|
|
|
RefTag& y = co_await AwaitResumeReturnsLValue{};
|
|
// CHECK: %[[RES3:.+]] = call nonnull align 1 dereferenceable({{.*}}) ptr @_ZN24AwaitResumeReturnsLValue12await_resumeEv(ptr {{[^,]*}} %[[TMP2]])
|
|
// CHECK-NEXT: store ptr %[[RES3]], ptr %[[TMP_EXPRCLEANUP2]],
|
|
// CHECK: %[[LOAD_TMP2:.+]] = load ptr, ptr %[[TMP_EXPRCLEANUP2]],
|
|
// CHECK: store ptr %[[LOAD_TMP2]], ptr %[[ZVAR]],
|
|
RefTag& z = co_yield 42;
|
|
}
|
|
|
|
struct TailCallAwait {
|
|
bool await_ready();
|
|
std::coroutine_handle<> await_suspend(std::coroutine_handle<>);
|
|
void await_resume();
|
|
};
|
|
|
|
// CHECK-LABEL: @TestTailcall(
|
|
extern "C" void TestTailcall() {
|
|
// CHECK: %[[PROMISE:.+]] = alloca %"struct.std::coroutine_traits<void>::promise_type"
|
|
// CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
|
|
co_await TailCallAwait{};
|
|
// CHECK: %[[READY:.+]] = call zeroext i1 @_ZN13TailCallAwait11await_readyEv(ptr {{[^,]*}} %[[AWAITABLE:.+]])
|
|
// CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
|
|
|
|
// If we are suspending:
|
|
// ---------------------
|
|
// CHECK: [[SUSPEND_BB]]:
|
|
// CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
|
|
// ---------------------------
|
|
// Call coro.await.suspend
|
|
// ---------------------------
|
|
// Note: The call must not be nounwind since the resumed function could throw.
|
|
// CHECK-NEXT: call void @llvm.coro.await.suspend.handle(ptr %[[AWAITABLE]], ptr %[[FRAME]], ptr @TestTailcall.__await_suspend_wrapper__await){{$}}
|
|
// CHECK-NEXT: %[[OUTCOME:.+]] = call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
|
|
// CHECK-NEXT: switch i8 %[[OUTCOME]], label %[[RET_BB:.+]] [
|
|
// CHECK-NEXT: i8 0, label %[[READY_BB]]
|
|
// CHECK-NEXT: i8 1, label %{{.+}}
|
|
// CHECK-NEXT: ]
|
|
|
|
// Await suspend wrapper
|
|
// CHECK: define {{.*}} ptr @TestTailcall.__await_suspend_wrapper__await(ptr {{[^,]*}} %[[AWAITABLE_ARG:.+]], ptr {{[^,]*}} %[[FRAME_ARG:.+]])
|
|
// CHECK: store ptr %[[AWAITABLE_ARG]], ptr %[[AWAITABLE_TMP:.+]],
|
|
// CHECK: store ptr %[[FRAME_ARG]], ptr %[[FRAME_TMP:.+]],
|
|
// CHECK: %[[AWAITABLE:.+]] = load ptr, ptr %[[AWAITABLE_TMP]]
|
|
// CHECK: %[[FRAME:.+]] = load ptr, ptr %[[FRAME_TMP]]
|
|
// CHECK: call ptr @_ZNSt16coroutine_handleINSt16coroutine_traitsIJvEE12promise_typeEE12from_addressEPv(ptr %[[FRAME]])
|
|
// ... many lines of code to coerce coroutine_handle into an ptr scalar
|
|
// CHECK: %[[CH:.+]] = load ptr, ptr %{{.+}}
|
|
// CHECK-NEXT: %[[RESULT:.+]] = call ptr @_ZN13TailCallAwait13await_suspendESt16coroutine_handleIvE(ptr {{[^,]*}} %[[AWAITABLE]], ptr %[[CH]])
|
|
// CHECK-NEXT: %[[COERCE:.+]] = getelementptr inbounds %"struct.std::coroutine_handle", ptr %[[TMP:.+]], i32 0, i32 0
|
|
// CHECK-NEXT: store ptr %[[RESULT]], ptr %[[COERCE]]
|
|
// CHECK-NEXT: %[[ADDR:.+]] = call ptr @_ZNSt16coroutine_handleIvE7addressEv(ptr {{[^,]*}} %[[TMP]])
|
|
// CHECK-NEXT: ret ptr %[[ADDR]]
|
|
}
|