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