1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
// This tests that the coroutine heap allocation elision optimization could happen succesfully.
// RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux-gnu -std=c++20 -O2 -emit-llvm %s -o - | FileCheck %s
#include "Inputs/coroutine.h"
#include "Inputs/numeric.h"
template <typename T> struct generator {
struct promise_type {
T current_value;
std::suspend_always yield_value(T value) {
this->current_value = value;
return {};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
generator get_return_object() { return generator{this}; };
void unhandled_exception() {}
void return_void() {}
};
struct iterator {
std::coroutine_handle<promise_type> _Coro;
bool _Done;
iterator(std::coroutine_handle<promise_type> Coro, bool Done)
: _Coro(Coro), _Done(Done) {}
iterator &operator++() {
_Coro.resume();
_Done = _Coro.done();
return *this;
}
bool operator==(iterator const &_Right) const {
return _Done == _Right._Done;
}
bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
T const &operator*() const { return _Coro.promise().current_value; }
T const *operator->() const { return &(operator*()); }
};
iterator begin() {
p.resume();
return {p, p.done()};
}
iterator end() { return {p, true}; }
generator(generator const &) = delete;
generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~generator() {
if (p)
p.destroy();
}
private:
explicit generator(promise_type *p)
: p(std::coroutine_handle<promise_type>::from_promise(*p)) {}
std::coroutine_handle<promise_type> p;
};
template <typename T>
generator<T> seq() {
for (T i = {};; ++i)
co_yield i;
}
template <typename T>
generator<T> take_until(generator<T> &g, T limit) {
for (auto &&v : g)
if (v < limit)
co_yield v;
else
break;
}
template <typename T>
generator<T> multiply(generator<T> &g, T factor) {
for (auto &&v : g)
co_yield v *factor;
}
template <typename T>
generator<T> add(generator<T> &g, T adder) {
for (auto &&v : g)
co_yield v + adder;
}
int main() {
auto s = seq<int>();
auto t = take_until(s, 10);
auto m = multiply(t, 2);
auto a = add(m, 110);
return std::accumulate(a.begin(), a.end(), 0);
}
// CHECK-LABEL: define{{.*}} i32 @main(
// CHECK: ret i32 1190
// CHECK-NOT: call{{.*}}_Znwm
|
