85 lines
2.7 KiB
C++
85 lines
2.7 KiB
C++
// An end-to-end test to make sure things get processed correctly.
|
|
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -emit-llvm -o - %s -O3 | \
|
|
// RUN: FileCheck %s
|
|
|
|
#include "Inputs/coroutine.h"
|
|
|
|
struct SomeAwaitable {
|
|
// Resume the supplied handle once the awaitable becomes ready,
|
|
// returning a handle that should be resumed now for the sake of symmetric transfer.
|
|
// If the awaitable is already ready, return an empty handle without doing anything.
|
|
//
|
|
// Defined in another translation unit. Note that this may contain
|
|
// code that synchronizees with another thread.
|
|
std::coroutine_handle<> Register(std::coroutine_handle<>);
|
|
};
|
|
|
|
// Defined in another translation unit.
|
|
void DidntSuspend();
|
|
|
|
struct Awaiter {
|
|
SomeAwaitable&& awaitable;
|
|
bool suspended;
|
|
|
|
bool await_ready() { return false; }
|
|
|
|
std::coroutine_handle<> await_suspend(const std::coroutine_handle<> h) {
|
|
// Assume we will suspend unless proven otherwise below. We must do
|
|
// this *before* calling Register, since we may be destroyed by another
|
|
// thread asynchronously as soon as we have registered.
|
|
suspended = true;
|
|
|
|
// Attempt to hand off responsibility for resuming/destroying the coroutine.
|
|
const auto to_resume = awaitable.Register(h);
|
|
|
|
if (!to_resume) {
|
|
// The awaitable is already ready. In this case we know that Register didn't
|
|
// hand off responsibility for the coroutine. So record the fact that we didn't
|
|
// actually suspend, and tell the compiler to resume us inline.
|
|
suspended = false;
|
|
return h;
|
|
}
|
|
|
|
// Resume whatever Register wants us to resume.
|
|
return to_resume;
|
|
}
|
|
|
|
void await_resume() {
|
|
// If we didn't suspend, make note of that fact.
|
|
if (!suspended) {
|
|
DidntSuspend();
|
|
}
|
|
}
|
|
};
|
|
|
|
struct MyTask{
|
|
struct promise_type {
|
|
MyTask get_return_object() { return {}; }
|
|
std::suspend_never initial_suspend() { return {}; }
|
|
std::suspend_always final_suspend() noexcept { return {}; }
|
|
void unhandled_exception();
|
|
|
|
Awaiter await_transform(SomeAwaitable&& awaitable) {
|
|
return Awaiter{static_cast<SomeAwaitable&&>(awaitable)};
|
|
}
|
|
};
|
|
};
|
|
|
|
MyTask FooBar() {
|
|
co_await SomeAwaitable();
|
|
}
|
|
|
|
// CHECK-LABEL: @_Z6FooBarv
|
|
// CHECK: %[[to_resume:.*]] = {{.*}}call ptr @_ZN13SomeAwaitable8RegisterESt16coroutine_handleIvE
|
|
// CHECK-NEXT: %[[to_bool:.*]] = icmp eq ptr %[[to_resume]], null
|
|
// CHECK-NEXT: br i1 %[[to_bool]], label %[[then:.*]], label %[[else:.*]]
|
|
|
|
// CHECK: [[then]]:
|
|
// We only access the coroutine frame conditionally as the sources did.
|
|
// CHECK: store i8 0,
|
|
// CHECK-NEXT: br label %[[else]]
|
|
|
|
// CHECK: [[else]]:
|
|
// No more access to the coroutine frame until suspended.
|
|
// CHECK-NOT: store
|
|
// CHECK: }
|