tree 50e5c1ee012575dfc83ce6eed648792a3c7dfc87
parent a169a4718b5b621f1770789e55eb8c441f7d0fcd
author Iain Sandoe <iain@sandoe.co.uk> 1748717944 +0100
committer Iain Sandoe <iain@sandoe.co.uk> 1753801796 +0100

c++, coroutines: CWG2563 promise lifetime extension [PR115908].

This implements the final piece of the revised CWG2563 wording;
"It exits the scope of promise only if the coroutine completed
 without suspending."

Considering the coroutine to be made up of two components; a
'ramp' and a 'body' where the body represents the user's original
code and the ramp is responsible for setup of that and for
returning some object to the original caller.

Coroutine state, and responsibility for its release.

A coroutine has some state that persists across suspensions.

The state has two components:
  * State that is specified by the standard and persists for the entire
    life of the coroutine.
  * Local state that is constructed/destructed as scopes in the original
    function body are entered/exited.  The destruction of local state is
    always the responsibility of the body code.

The persistent state (and the overall storage for the state) must be
managed in two places:
  * The ramp function (which allocates and builds this - and can, in some
    cases, be responsible for destroying it)
  * The re-written function body which can destroy it when that body
    completes its final suspend - or when the handle.destroy () is called.

In all cases the ramp holds responsibility for constructing the standard-
mandated persistent state.

There are four ways in which the ramp might be re-entered after starting
the function body:
  A The body could suspend (one might expect that to be the 'normal' case
    for most coroutines).
  B The body might complete either synchronously or via continuations.
  C An exception might be thrown during the setup of the initial await
    expression, before the initial awaiter resumes.
  D An exception might be processed by promise.unhandled_exception () and
    that, in turn, might re-throw it (or throw something else).  In this
    case, the coroutine is considered suspended at the final suspension
    point.

Once the coroutine has passed initial suspend (i.e. the initial awaiter
await_resume() has been called) the body is considered to have a use of
the state.

Until the ramp return value has been constructed, the ramp is considered
to have a use of the state.

To manage these interacting conditions we allocate a reference counter
for the frame state.  This is initialised to 1 by the ramp as part of its
startup (note that failures/exceptions in the startup code are handled
locally to the ramp).

When the body returns (either normally, or by exception) the ramp releases
its use.

Once the rewritten coroutine body is started, the body is considered to
have a use of the frame.  This use (potentially) needs to be released if
an exception is thrown from the body.  We implement this using an eh-only
cleanup around the initial await.  If we have the case D above, then we
do not release the body use.

In case:

  A, typically the ramp would be re-entered with the body holding a use,
  and therefore the ramp should not destroy the state.

  B, both the body and ramp will have released their uses, and the ramp
  should destroy the state.

  C, we must arrange for the body to release its use, because we require
  the ramp to cleanup in this circumstance.

  D is an outlier, since the responsibility for destruction of the state
  now rests with the user's code (via a handle.destroy() call).

  NOTE: In the case that the body has never suspended before such an
  exception occurs, the only reasonable way for the user code to obtain the
  necessary handle is if unhandled_exception() throws the handle or some
  object that contains the handle.  That is outside of the designs here -
  if the user code might need this corner-case, then such provision will
  have to be made.

In the ramp, we implement destruction for the persistent frame state by
means of cleanups.  These are run conditionally when the reference count
is 0 signalling that both the body and the ramp have completed.

In the body, once we pass the final suspend, then we test the use and
delete the state if the use is 0.

	PR c++/115908
	PR c++/118074
	PR c++/95615

gcc/cp/ChangeLog:

	* coroutines.cc (coro_frame_refcount_id): New.
	(coro_init_identifiers): Initialise coro_frame_refcount_id.
	(build_actor_fn): Set up initial_await_resume_called.  Handle
	decrementing of the frame reference count.  Return directly to
	the caller if that is non-zero.
	(cp_coroutine_transform::wrap_original_function_body): Use a
	conditional eh-only cleanup around the initial await expression
	to release the body use on exception before initial await
	resume.
	(cp_coroutine_transform::build_ramp_function): Wrap the called
	body in a cleanup that releases a use of the frame when we
	return to the ramp.  Implement frame, promise and argument copy
	destruction via conditional cleanups when the frame use count
	is zero.

gcc/testsuite/ChangeLog:

	* g++.dg/coroutines/pr115908.C: Move to...
	* g++.dg/coroutines/torture/pr115908.C: ...here.
	* g++.dg/coroutines/torture/pr95615-02.C: Move to...
	* g++.dg/coroutines/torture/pr95615-01-promise-ctor-throws.C: ...here.
	* g++.dg/coroutines/torture/pr95615-03.C: Move to...
	* g++.dg/coroutines/torture/pr95615-02-get-return-object-throws.C: ...here.
	* g++.dg/coroutines/torture/pr95615-01.C: Move to...
	* g++.dg/coroutines/torture/pr95615-03-initial-suspend-throws.C: ...here.
	* g++.dg/coroutines/torture/pr95615-04.C: Move to...
	* g++.dg/coroutines/torture/pr95615-04-initial-await-ready-throws.C: ...here.
	* g++.dg/coroutines/torture/pr95615-05.C: Move to...
	* g++.dg/coroutines/torture/pr95615-05-initial-await-suspend-throws.C: ...here.
	* g++.dg/coroutines/torture/pr95615.inc: Add more cases and ensure that the
	code completes properly when no exceptions are thrown.
	* g++.dg/coroutines/torture/pr95615-00-nothing-throws.C: New test.
	* g++.dg/coroutines/torture/pr95615-06-initial-await-resume-throws.C: New test.
	* g++.dg/coroutines/torture/pr95615-07-body-throws.C: New test.
	* g++.dg/coroutines/torture/pr95615-08-initial-suspend-throws-uhe-throws.C: New test.
	* g++.dg/coroutines/torture/pr95615-09-body-throws-uhe-throws.C: New test.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>
(cherry picked from commit 43e408f675f8e998c94462346f4306cd4716e138)