1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
10#define _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
11
12#include <__assert>
13#include <__config>
14#include <__functional/hash.h>
15#include <__memory/addressof.h>
16#include <__type_traits/remove_cv.h>
17#include <compare>
18#include <cstddef>
19
20#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
21#  pragma GCC system_header
22#endif
23
24#if _LIBCPP_STD_VER > 17
25
26_LIBCPP_BEGIN_NAMESPACE_STD
27
28// [coroutine.handle]
29template <class _Promise = void>
30struct _LIBCPP_TEMPLATE_VIS coroutine_handle;
31
32template <>
33struct _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
34public:
35    // [coroutine.handle.con], construct/reset
36    _LIBCPP_HIDE_FROM_ABI
37    constexpr coroutine_handle() noexcept = default;
38
39    _LIBCPP_HIDE_FROM_ABI
40    constexpr coroutine_handle(nullptr_t) noexcept {}
41
42    _LIBCPP_HIDE_FROM_ABI
43    coroutine_handle& operator=(nullptr_t) noexcept {
44        __handle_ = nullptr;
45        return *this;
46    }
47
48    // [coroutine.handle.export.import], export/import
49    _LIBCPP_HIDE_FROM_ABI
50    constexpr void* address() const noexcept { return __handle_; }
51
52    _LIBCPP_HIDE_FROM_ABI
53    static constexpr coroutine_handle from_address(void* __addr) noexcept {
54        coroutine_handle __tmp;
55        __tmp.__handle_ = __addr;
56        return __tmp;
57    }
58
59    // [coroutine.handle.observers], observers
60    _LIBCPP_HIDE_FROM_ABI
61    constexpr explicit operator bool() const noexcept {
62        return __handle_ != nullptr;
63    }
64
65    _LIBCPP_HIDE_FROM_ABI
66    bool done() const {
67        _LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
68        return __builtin_coro_done(__handle_);
69    }
70
71    // [coroutine.handle.resumption], resumption
72    _LIBCPP_HIDE_FROM_ABI
73    void operator()() const { resume(); }
74
75    _LIBCPP_HIDE_FROM_ABI
76    void resume() const {
77        _LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
78        _LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
79        __builtin_coro_resume(__handle_);
80    }
81
82    _LIBCPP_HIDE_FROM_ABI
83    void destroy() const {
84        _LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
85        __builtin_coro_destroy(__handle_);
86    }
87
88private:
89    bool __is_suspended() const {
90        // FIXME actually implement a check for if the coro is suspended.
91        return __handle_ != nullptr;
92    }
93
94    void* __handle_ = nullptr;
95};
96
97// [coroutine.handle.compare]
98inline _LIBCPP_HIDE_FROM_ABI
99constexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
100    return __x.address() == __y.address();
101}
102inline _LIBCPP_HIDE_FROM_ABI
103constexpr strong_ordering operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
104    return compare_three_way()(__x.address(), __y.address());
105}
106
107template <class _Promise>
108struct _LIBCPP_TEMPLATE_VIS coroutine_handle {
109public:
110    // [coroutine.handle.con], construct/reset
111    _LIBCPP_HIDE_FROM_ABI
112    constexpr coroutine_handle() noexcept = default;
113
114    _LIBCPP_HIDE_FROM_ABI
115    constexpr coroutine_handle(nullptr_t) noexcept {}
116
117    _LIBCPP_HIDE_FROM_ABI
118    static coroutine_handle from_promise(_Promise& __promise) {
119        using _RawPromise = __remove_cv_t<_Promise>;
120        coroutine_handle __tmp;
121        __tmp.__handle_ =
122            __builtin_coro_promise(_VSTD::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true);
123        return __tmp;
124    }
125
126    _LIBCPP_HIDE_FROM_ABI
127    coroutine_handle& operator=(nullptr_t) noexcept {
128        __handle_ = nullptr;
129        return *this;
130    }
131
132    // [coroutine.handle.export.import], export/import
133    _LIBCPP_HIDE_FROM_ABI
134    constexpr void* address() const noexcept { return __handle_; }
135
136    _LIBCPP_HIDE_FROM_ABI
137    static constexpr coroutine_handle from_address(void* __addr) noexcept {
138        coroutine_handle __tmp;
139        __tmp.__handle_ = __addr;
140        return __tmp;
141    }
142
143    // [coroutine.handle.conv], conversion
144    _LIBCPP_HIDE_FROM_ABI
145    constexpr operator coroutine_handle<>() const noexcept {
146        return coroutine_handle<>::from_address(address());
147    }
148
149    // [coroutine.handle.observers], observers
150    _LIBCPP_HIDE_FROM_ABI
151    constexpr explicit operator bool() const noexcept {
152        return __handle_ != nullptr;
153    }
154
155    _LIBCPP_HIDE_FROM_ABI
156    bool done() const {
157        _LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
158        return __builtin_coro_done(__handle_);
159    }
160
161    // [coroutine.handle.resumption], resumption
162    _LIBCPP_HIDE_FROM_ABI
163    void operator()() const { resume(); }
164
165    _LIBCPP_HIDE_FROM_ABI
166    void resume() const {
167        _LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
168        _LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
169        __builtin_coro_resume(__handle_);
170    }
171
172    _LIBCPP_HIDE_FROM_ABI
173    void destroy() const {
174        _LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
175        __builtin_coro_destroy(__handle_);
176    }
177
178    // [coroutine.handle.promise], promise access
179    _LIBCPP_HIDE_FROM_ABI
180    _Promise& promise() const {
181        return *static_cast<_Promise*>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));
182    }
183
184private:
185    bool __is_suspended() const {
186        // FIXME actually implement a check for if the coro is suspended.
187        return __handle_ != nullptr;
188    }
189    void* __handle_ = nullptr;
190};
191
192// [coroutine.handle.hash]
193template <class _Tp>
194struct hash<coroutine_handle<_Tp>> {
195    _LIBCPP_HIDE_FROM_ABI
196    size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); }
197};
198
199_LIBCPP_END_NAMESPACE_STD
200
201#endif // __LIBCPP_STD_VER > 17
202
203#endif // _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
204