15.0.0: add two coro patches

Bug: https://gcc.gnu.org/PR116506
Bug: https://gcc.gnu.org/PR116914
Closes: https://bugs.gentoo.org/941147
Closes: https://bugs.gentoo.org/941148
Signed-off-by: Sam James <sam@gentoo.org>

3 files changed, 351 insertions, 0 deletions

diff --git a/15.0.0/gentoo/70_all_PR116506-coro.patch b/15.0.0/gentoo/70_all_PR116506-coro.patch
new file mode 100644
index 0000000..4e670fc
--- /dev/null
+++ b/15.0.0/gentoo/70_all_PR116506-coro.patch
@@ -0,0 +1,295 @@
+From 06475fcc5b72fdb9b24e7e39703942e1e3f2f0d5 Mon Sep 17 00:00:00 2001
+From: Iain Sandoe <iain@sandoe.co.uk>
+Date: Thu, 29 Aug 2024 11:18:24 +0100
+Subject: [PATCH] c++, coroutines: Fix awaiter var creation [PR116506].
+
+Awaiters always need to have a coroutine state frame copy since
+they persist across potential supensions.  It simplifies the later
+analysis considerably to assign these early which we do when
+building co_await expressions.
+
+The cleanups in r15-3146-g47dbd69b1, unfortunately elided some of
+processing used to cater for cases where the var created from an
+xvalue, or is a pointer/reference type.
+
+Corrected thus.
+
+	PR c++/116506
+	PR c++/116880
+
+gcc/cp/ChangeLog:
+
+	* coroutines.cc (build_co_await): Ensure that xvalues are
+	materialised.  Handle references/pointer values in awaiter
+	access expressions.
+
+gcc/testsuite/ChangeLog:
+
+	* g++.dg/coroutines/pr116506.C: New test.
+	* g++.dg/coroutines/pr116880.C: New test.
+
+Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>
+---
+ gcc/cp/coroutines.cc                       | 82 +++++++++++++++++-----
+ gcc/testsuite/g++.dg/coroutines/pr116506.C | 53 ++++++++++++++
+ gcc/testsuite/g++.dg/coroutines/pr116880.C | 36 ++++++++++
+ 3 files changed, 154 insertions(+), 17 deletions(-)
+ create mode 100644 gcc/testsuite/g++.dg/coroutines/pr116506.C
+ create mode 100644 gcc/testsuite/g++.dg/coroutines/pr116880.C
+
+diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
+index 86a5ac8999a..ba6ee41a4e7 100644
+--- a/gcc/cp/coroutines.cc
++++ b/gcc/cp/coroutines.cc
+@@ -1071,6 +1071,30 @@ build_template_co_await_expr (location_t kw, tree type, tree expr, tree kind)
+   return aw_expr;
+ }
+ 
++/* For a component ref that is not a pointer type, decide if we can use
++   this directly.  */
++static bool
++usable_component_ref (tree comp_ref)
++{
++  if (TREE_CODE (comp_ref) != COMPONENT_REF
++      || TREE_SIDE_EFFECTS (comp_ref))
++    return false;
++
++  while (TREE_CODE (comp_ref) == COMPONENT_REF)
++    {
++      comp_ref = TREE_OPERAND (comp_ref, 0);
++      STRIP_NOPS (comp_ref);
++      /* x-> */
++      if (INDIRECT_REF_P (comp_ref))
++	return false;
++      /* operator-> */
++      if (TREE_CODE (comp_ref) == CALL_EXPR)
++	return false;
++      STRIP_NOPS (comp_ref);
++    }
++  gcc_checking_assert (VAR_P (comp_ref) || TREE_CODE (comp_ref) == PARM_DECL);
++  return true;
++}
+ 
+ /*  This performs [expr.await] bullet 3.3 and validates the interface obtained.
+     It is also used to build the initial and final suspend points.
+@@ -1133,13 +1157,12 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+   if (o_type && !VOID_TYPE_P (o_type))
+     o_type = complete_type_or_else (o_type, o);
+ 
+-  if (!o_type)
++  if (!o_type || o_type == error_mark_node)
+     return error_mark_node;
+ 
+   if (TREE_CODE (o_type) != RECORD_TYPE)
+     {
+-      error_at (loc, "awaitable type %qT is not a structure",
+-		o_type);
++      error_at (loc, "awaitable type %qT is not a structure", o_type);
+       return error_mark_node;
+     }
+ 
+@@ -1165,20 +1188,47 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+   if (!glvalue_p (o))
+     o = get_target_expr (o, tf_warning_or_error);
+ 
+-  tree e_proxy = o;
+-  if (glvalue_p (o))
++  /* We know that we need a coroutine state frame variable for the awaiter,
++     since it must persist across suspension; so where one is needed, build
++     it now.  */
++  tree e_proxy = STRIP_NOPS (o);
++  if (INDIRECT_REF_P (e_proxy))
++    e_proxy = TREE_OPERAND (e_proxy, 0);
++  o_type = TREE_TYPE (e_proxy);
++  bool is_ptr = TYPE_PTR_P (o_type);
++  if (!is_ptr
++      && (TREE_CODE (e_proxy) == PARM_DECL
++	  || usable_component_ref (e_proxy)
++	  || (VAR_P (e_proxy) && !is_local_temp (e_proxy))))
+     o = NULL_TREE; /* Use the existing entity.  */
+-  else /* We need to materialise it.  */
++  else /* We need a non-temp var.  */
+     {
+-      e_proxy = get_awaitable_var (suspend_kind, o_type);
+-      o = cp_build_init_expr (loc, e_proxy, o);
+-      e_proxy = convert_from_reference (e_proxy);
++      tree p_type = o_type;
++      tree o_a = o;
++      if (lvalue_p (o) && !TREE_SIDE_EFFECTS (o))
++	{
++	  if (is_ptr)
++	    p_type = TREE_TYPE (p_type);
++	  p_type = cp_build_reference_type (p_type, false);
++	  o_a = build_address (o);
++	}
++      if (INDIRECT_REF_P (o_a))
++	o_a = TREE_OPERAND (o_a, 0);
++      e_proxy = get_awaitable_var (suspend_kind, p_type);
++      o = cp_build_init_expr (loc, e_proxy, o_a);
+     }
+ 
++  /* Build an expression for the object that will be used to call the awaitable
++     methods.  */
++  tree e_object = convert_from_reference (e_proxy);
++  if (TYPE_PTR_P (TREE_TYPE (e_object)))
++    e_object = cp_build_indirect_ref (input_location, e_object, RO_UNARY_STAR,
++				      tf_warning_or_error);
++
+   /* I suppose we could check that this is contextually convertible to bool.  */
+   tree awrd_func = NULL_TREE;
+   tree awrd_call
+-    = build_new_method_call (e_proxy, awrd_meth, NULL, NULL_TREE, LOOKUP_NORMAL,
++    = build_new_method_call (e_object, awrd_meth, NULL, NULL_TREE, LOOKUP_NORMAL,
+ 			     &awrd_func, tf_warning_or_error);
+ 
+   if (!awrd_func || !awrd_call || awrd_call == error_mark_node)
+@@ -1192,7 +1242,7 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+   tree h_proxy = get_coroutine_self_handle_proxy (current_function_decl);
+   vec<tree, va_gc> *args = make_tree_vector_single (h_proxy);
+   tree awsp_call
+-    = build_new_method_call (e_proxy, awsp_meth, &args, NULL_TREE,
++    = build_new_method_call (e_object, awsp_meth, &args, NULL_TREE,
+ 			     LOOKUP_NORMAL, &awsp_func, tf_warning_or_error);
+ 
+   release_tree_vector (args);
+@@ -1224,7 +1274,7 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+   /* Finally, the type of e.await_resume() is the co_await's type.  */
+   tree awrs_func = NULL_TREE;
+   tree awrs_call
+-    = build_new_method_call (e_proxy, awrs_meth, NULL, NULL_TREE, LOOKUP_NORMAL,
++    = build_new_method_call (e_object, awrs_meth, NULL, NULL_TREE, LOOKUP_NORMAL,
+ 			     &awrs_func, tf_warning_or_error);
+ 
+   if (!awrs_func || !awrs_call || awrs_call == error_mark_node)
+@@ -1238,7 +1288,7 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+ 	return error_mark_node;
+       if (coro_diagnose_throwing_fn (awrs_func))
+ 	return error_mark_node;
+-      if (tree dummy = cxx_maybe_build_cleanup (e_proxy, tf_none))
++      if (tree dummy = cxx_maybe_build_cleanup (e_object, tf_none))
+ 	{
+ 	  if (CONVERT_EXPR_P (dummy))
+ 	    dummy = TREE_OPERAND (dummy, 0);
+@@ -1249,7 +1299,8 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+     }
+ 
+   /* We now have three call expressions, in terms of the promise, handle and
+-     'e' proxies.  Save them in the await expression for later expansion.  */
++     'e' proxy expression.  Save them in the await expression for later
++     expansion.  */
+ 
+   tree awaiter_calls = make_tree_vec (3);
+   TREE_VEC_ELT (awaiter_calls, 0) = awrd_call; /* await_ready().  */
+@@ -1262,9 +1313,6 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
+     }
+   TREE_VEC_ELT (awaiter_calls, 2) = awrs_call; /* await_resume().  */
+ 
+-  if (REFERENCE_REF_P (e_proxy))
+-    e_proxy = TREE_OPERAND (e_proxy, 0);
+-
+   tree awrs_type = TREE_TYPE (TREE_TYPE (awrs_func));
+   tree suspend_kind_cst = build_int_cst (integer_type_node,
+ 					 (int) suspend_kind);
+diff --git a/gcc/testsuite/g++.dg/coroutines/pr116506.C b/gcc/testsuite/g++.dg/coroutines/pr116506.C
+new file mode 100644
+index 00000000000..57a6e360566
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/coroutines/pr116506.C
+@@ -0,0 +1,53 @@
++// { dg-do run }
++// { dg-additional-options "-fno-exceptions" }
++                                                       
++#include <coroutine>
++
++bool g_too_early = true;
++std::coroutine_handle<> g_handle;
++
++struct Awaiter {
++    Awaiter() {}
++    ~Awaiter() {
++        if (g_too_early) {
++            __builtin_abort ();
++        }
++    }
++
++    bool await_ready() { return false; }
++    void await_suspend(std::coroutine_handle<> handle) {
++        g_handle = handle;
++    }
++
++    void await_resume() {}
++};
++
++struct SuspendNever {
++    bool await_ready() noexcept { return true; }
++    void await_suspend(std::coroutine_handle<>) noexcept {}
++    void await_resume() noexcept {}
++};
++
++struct Coroutine {
++    struct promise_type {
++        Coroutine get_return_object() { return {}; }
++        SuspendNever initial_suspend() { return {}; }
++        SuspendNever final_suspend() noexcept { return {}; }
++        void return_void() {}
++        void unhandled_exception() {}
++
++        Awaiter&& await_transform(Awaiter&& u) {
++            return static_cast<Awaiter&&>(u);
++        }
++    };
++};
++
++Coroutine foo() {
++    co_await Awaiter{};
++}
++
++int main() {
++    foo();
++    g_too_early = false;
++    g_handle.destroy();
++}
+diff --git a/gcc/testsuite/g++.dg/coroutines/pr116880.C b/gcc/testsuite/g++.dg/coroutines/pr116880.C
+new file mode 100644
+index 00000000000..f0db6a26044
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/coroutines/pr116880.C
+@@ -0,0 +1,36 @@
++#include <coroutine>
++
++struct promise_type;
++using handle_type = std::coroutine_handle<promise_type>;
++
++struct Co {
++    handle_type handle;
++    using promise_type = ::promise_type;
++
++    explicit Co(handle_type handle) : handle(handle) {}
++
++    bool await_ready() { return false; }
++    std::coroutine_handle<> await_suspend(handle_type handle);
++    void await_resume() {}
++};
++
++struct Done {};
++
++struct promise_type {
++    Co get_return_object();
++
++    std::suspend_always initial_suspend() { return {}; };
++    std::suspend_always final_suspend() noexcept { return {}; };
++    void return_value(Done) {}
++    void return_value(Co&&);
++    void unhandled_exception() { throw; };
++    Co&& await_transform(Co&& co) { return static_cast<Co&&>(co); }
++};
++
++Co tryToRun();
++
++Co init()
++{
++    co_await tryToRun();
++    co_return Done{};
++}
+-- 
+2.39.2 (Apple Git-143)
diff --git a/15.0.0/gentoo/71_all_PR116914-coro.patch b/15.0.0/gentoo/71_all_PR116914-coro.patch
new file mode 100644
index 0000000..100d2bb
--- /dev/null
+++ b/15.0.0/gentoo/71_all_PR116914-coro.patch
@@ -0,0 +1,51 @@
+From 1035866a75b27bb2cac49bac1070877d95f7d3c0 Mon Sep 17 00:00:00 2001
+From: Iain Sandoe <iain@sandoe.co.uk>
+Date: Sun, 29 Sep 2024 10:04:39 +0100
+Subject: [PATCH] c++, coroutines: stmt expressions some progress
+
+---
+ gcc/cp/coroutines.cc | 22 ++++++++++++++++++++++
+ 1 file changed, 22 insertions(+)
+
+diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
+index af8798b04ba..94bfa6ac450 100644
+--- a/gcc/cp/coroutines.cc
++++ b/gcc/cp/coroutines.cc
+@@ -2131,6 +2131,14 @@ await_statement_expander (tree *stmt, int *do_subtree, void *d)
+     }
+   else if (EXPR_P (*stmt))
+     {
++      /* Look for ({}) at the top level - just recurse into these.  */
++      if (TREE_CODE (*stmt) == EXPR_STMT)
++	{
++	  tree inner = EXPR_STMT_EXPR (*stmt);
++	  if (TREE_CODE (inner) == STATEMENT_LIST
++	      || TREE_CODE (inner) == BIND_EXPR)
++	    return NULL_TREE; // process contents
++	}
+       process_one_statement (stmt, d);
+       *do_subtree = 0; /* Done subtrees.  */
+     }
+@@ -3860,6 +3868,20 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d)
+       if (!(cp_walk_tree (stmt, find_any_await, &await_ptr, &visited)))
+ 	return NULL_TREE; /* Nothing special to do here.  */
+ 
++      /* Handle statement expressions.  */
++      if (TREE_CODE (expr) == EXPR_STMT)
++	{
++	  tree inner = EXPR_STMT_EXPR (expr);
++	  if (TREE_CODE (inner) == STATEMENT_LIST
++	      || TREE_CODE (inner) == BIND_EXPR)
++	    {
++	      res = cp_walk_tree (&EXPR_STMT_EXPR (expr),
++				  await_statement_walker, d, NULL);
++	      *do_subtree = 0;
++	      return res;
++	    }
++	}
++
+       visited.empty ();
+       awpts->saw_awaits = 0;
+       hash_set<tree> truth_aoif_to_expand;
+-- 
+2.39.2 (Apple Git-143)
diff --git a/15.0.0/gentoo/README.history b/15.0.0/gentoo/README.history
index a6954a6..073283d 100644
--- a/15.0.0/gentoo/README.history
+++ b/15.0.0/gentoo/README.history
@@ -1,3 +1,8 @@
+16	13 October 2024
+
+	+ 70_all_PR116506-coro.patch
+	+ 71_all_PR116914-coro.patch
+
 15	7 October 2024
 
 	- 71_all_c-Allow-references-to-internal-linkage-vars-in-C-11-.patch