[gcc r11-11542] coroutines: Pass lvalues to user-defined operator new [PR 100772].

[Iain D Sandoe]

https://gcc.gnu.org/g:f647906ef227bc22af224d955a408d776cfddb04

commit r11-11542-gf647906ef227bc22af224d955a408d776cfddb04
Author: Iain Sandoe <iain@sandoe.co.uk>
Date:   Sun Oct 3 19:46:09 2021 +0100

    coroutines: Pass lvalues to user-defined operator new [PR 100772].
    
    The wording of the standard has been clarified to be explicit that
    the the parameters to any user-defined operator-new in the promise
    class should be lvalues.
    
    Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>
    
            PR c++/100772
    
    gcc/cp/ChangeLog:
    
            * coroutines.cc (morph_fn_to_coro): Convert function parms
            from reference before constructing any operator-new args
            list.
    
    gcc/testsuite/ChangeLog:
    
            * g++.dg/coroutines/pr100772-a.C: New test.
            * g++.dg/coroutines/pr100772-b.C: New test.
    
    (cherry picked from commit 921942a8a106cb53994c21162922e4934eb3a3e0)

Diff:
---
 gcc/cp/coroutines.cc                         |  8 +--
 gcc/testsuite/g++.dg/coroutines/pr100772-a.C | 77 +++++++++++++++++++++++
 gcc/testsuite/g++.dg/coroutines/pr100772-b.C | 93 ++++++++++++++++++++++++++++
 3 files changed, 174 insertions(+), 4 deletions(-)

diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index 71246e99a6f..04c72ddd48b 100644
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -4613,8 +4613,8 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer)
 	If the lookup finds an allocation function in the scope of the promise
 	type, overload resolution is performed on a function call created by
 	assembling an argument list.  The first argument is the amount of space
-	requested, and has type std::size_t.  The succeeding arguments are
-	those of the original function.  */
+	requested, and has type std::size_t.  The lvalues p1...pn are the
+	succeeding arguments..  */
       vec<tree, va_gc> *args = make_tree_vector ();
       vec_safe_push (args, resizeable); /* Space needed.  */
 
@@ -4632,10 +4632,10 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer)
 	      this_ref = convert_to_reference (tt, this_ref, CONV_STATIC,
 					       LOOKUP_NORMAL , NULL_TREE,
 					       tf_warning_or_error);
-	      vec_safe_push (args, this_ref);
+	      vec_safe_push (args, convert_from_reference (this_ref));
 	    }
 	  else
-	    vec_safe_push (args, arg);
+	    vec_safe_push (args, convert_from_reference (arg));
 	}
 
       /* Note the function selected; we test to see if it's NOTHROW.  */
diff --git a/gcc/testsuite/g++.dg/coroutines/pr100772-a.C b/gcc/testsuite/g++.dg/coroutines/pr100772-a.C
new file mode 100644
index 00000000000..a325d384fc3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr100772-a.C
@@ -0,0 +1,77 @@
+//  { dg-additional-options "-fsyntax-only " }
+#ifdef __clang__
+#include <experimental/coroutine>
+namespace std {
+  using namespace std::experimental;
+}
+#else
+#include <coroutine>
+#endif
+
+struct Task
+{
+    struct promise_type
+    {        
+		void return_void() const noexcept {}
+
+		void* operator new(std::size_t, auto &&...args) noexcept
+		{
+            static_assert(sizeof...(args) > 0);
+            static_assert(sizeof...(args) == 2);
+
+			return nullptr;
+		}
+
+		void operator delete(void *, std::size_t) noexcept
+		{
+		}
+
+        static Task get_return_object_on_allocation_failure() noexcept
+        {
+            return {};
+        }
+
+        Task get_return_object() noexcept
+        {
+            return Task{ *this };
+        }
+
+        std::suspend_always initial_suspend() noexcept
+        {
+            return {};
+        }
+
+        std::suspend_always final_suspend() noexcept
+        {
+            return {};
+        }
+
+        void unhandled_exception() noexcept {}
+    };
+
+    using promise_handle = std::coroutine_handle<promise_type>;
+
+    Task() = default;
+    Task(promise_type & promise) noexcept
+        : m_handle{ promise_handle::from_promise(promise) }
+    {}
+
+    ~Task()
+    {
+        if (m_handle.address()) { m_handle.destroy(); }
+    }
+    
+    promise_handle m_handle{};
+};
+
+
+Task Foo(auto && ... args) noexcept
+{
+    co_return;
+}
+
+int main()
+{
+    int v;
+    Foo(v, 2134);
+}
diff --git a/gcc/testsuite/g++.dg/coroutines/pr100772-b.C b/gcc/testsuite/g++.dg/coroutines/pr100772-b.C
new file mode 100644
index 00000000000..6cdf8d1e529
--- /dev/null
+++ b/gcc/testsuite/g++.dg/coroutines/pr100772-b.C
@@ -0,0 +1,93 @@
+#ifdef __clang__
+#include <experimental/coroutine>
+namespace std {
+  using namespace std::experimental;
+}
+#else
+#include <coroutine>
+#endif
+#include <cstdio>
+#include <typeinfo>
+#include <cxxabi.h>  // needed for abi::__cxa_demangle
+#include <memory>
+
+std::shared_ptr<char> cppDemangle(const char *abiName)
+{
+  int status;    
+  char *ret = abi::__cxa_demangle(abiName, 0, 0, &status);  
+
+  /* NOTE: must free() the returned char when done with it! */
+  std::shared_ptr<char> retval;
+  retval.reset( (char *)ret, [](char *mem) { if (mem) free((void*)mem); } );
+  return retval;
+}
+
+template <typename T>
+struct Id{};
+struct Task
+{
+  struct promise_type
+  {        
+    void return_void() const noexcept {}
+
+    static void is_int (std::string x) {
+      if (x != "Id<int>")
+	abort() ;
+    }
+    template <typename ... Args>
+    void* operator new(std::size_t len, Args ...args) noexcept
+      {
+	(is_int (cppDemangle(typeid(Id<Args>).name()).get()), ...);
+	(std::puts (cppDemangle(typeid(Id<Args>).name()).get()), ...);
+	return nullptr;
+      }
+
+        static Task get_return_object_on_allocation_failure() noexcept
+        {
+            return {};
+        }
+
+        Task get_return_object() noexcept
+        {
+            return Task{ *this };
+        }
+
+        std::suspend_always initial_suspend() noexcept
+        {
+            return {};
+        }
+
+        std::suspend_always final_suspend() noexcept
+        {
+            return {};
+        }
+
+        void unhandled_exception() noexcept {}
+    };
+
+    using promise_handle = std::coroutine_handle<promise_type>;
+
+    Task() = default;
+    Task(promise_type & promise) noexcept
+        : m_handle{ promise_handle::from_promise(promise) }
+    {}
+
+    ~Task()
+    {
+        if (m_handle.address()) { m_handle.destroy(); }
+    }
+    
+    promise_handle m_handle{};
+};
+
+
+Task Foo(auto && ... args) noexcept
+{
+    co_return;
+}
+
+int main()
+{
+    int v;
+    Foo(v, 2134);
+}