[2/2] c++/coroutines: handle (new-)extended alignment [PR104177]

  This patch implements support for frames and promises with new-extended
alignment.

There are two kinds of alignment to worry about here:
- Promise alignment, which causes "internal" padding inside the frame
  struct.  The reason this is a problem is because the (yet to be
  formalized, but agreed upon) coroutine ABI requires us to place the
  resume and destroy pointers right before the promise of a coroutine,
  so that they are at offset -sizeof(void*)B and -2*sizeof(void*)B.  To
  this end, we might need to insert padding to the start of the frame
  type in order to ensure that these pointers are aligned correctly.
- Frame alignment (either as a result of the above or some other field in
  the frame), which is the alignment of the entire finished frame type.
  This alignment currently (up to the standardization of P2014) requires
  us to over-allocate and then round the result.

In addition, this patch also alters __builtin_coro_promise, the builtin
that turns a promise pointer into a _M_fr_ptr of a coroutine handle.
This builtin took an additional alignment parameter it used to
compensate for the padding that'd happen between the resume/destroy
pointer and the promise.  This is no longer necessary, as now these
pointers directly precede the frame.

As a result of the resume pointer no longer being at the start of the
coroutine frame, our actors and destroys are changed.  They now take
&frame->_Coro_resume_fn as the argument ("resume pointer"), and need to
adjust it to be the start of the frame before use.

The way each of the kinds of padding above are handled is as follows:

- For promise alignment, we emit extra members before the resume
  pointer: an "allocation pointer", if there's room for it, and a char[]
  of appropriate size to ensure there's no room between the resume
  pointer and the padding, and
- For frame alignment, we allocate extra memory in order to perform
  alignment on our own and store the result in the allocation pointer,
  which is after the frame if it could not be placed as part of the
  process above.

The location and necessity of the allocation pointer is dictated by
coroutine_info::allocptr_expr and coroutine_info::alloc_store_pointer,
the former provides an lvalue for the allocation pointer based on the
frame pointer, iff rounding is to be performed (nullptr otherwise), and
the latter decides whether to allocate extra space for the allocation
pointer (if stored after the frame).  This allows us flexibility to
later add support for P2014.

PR c++/104177 - coroutine frame is not being allocated with the correct alignment

	PR c++/104177

gcc/ChangeLog:

	* coroutine-passes.cc (lower_coro_builtin): Remove the second
	argument to __builtin_coro_promise.

gcc/cp/ChangeLog:

	* coroutines.cc (coro_maybe_dump_transformed_functions): Add
	frame_type as an explicit argument rather than deriving it from
	the actor argument list.
	(build_resume_to_frame_expr): New function.  Computes an
	expression that converts a resume pointer (the pointer passed to
	__builtin_coro_{resume,destroy}) into a frame pointer, or
	vice-versa.
	(struct coroutine_info): Add members allocptr_expr and
	alloc_store_pointer.  The former specifies the approach by which
	locate storage for the allocation that we round from to get the
	aligned frame pointer, the latter specifies whether that
	approach requires allocating extra space.
	(coro_allocptr_id): New.  Populated with the identifier
	"_Coro_allocptr".
	(coro_padding_id): New.  Populated with the identifier
	"_Coro_padding".
	(coro_frame_ptr_id): New.  Populated with the identifier
	"frame_ptr".
	(coro_init_identifiers): Populate the above.
	(build_coroutine_frame_delete_expr): Require the ramp fndecl as
	an argument, to locate coroutine_info.
	(build_actor_fn): Rename frame_size argument to alloc_size.
	Pass the sole argument to the actor (resume_ptr) through
	build_resume_to_frame_expr in order to obtain the frame_ptr.
	Declare it as a new local variable.
	(build_destroy_fn): Pass the sole argument to destroy function
	through build_resume_to_frame_expr, use the op argument of
	cp_build_modify_expr rather than manually building a
	BIT_IOR_EXPR.  Update actor call to use the resume_ptr argument.
	(coro_build_actor_or_destroy_function): Change declarations to
	have a sole void* resume_ptr argument.  Do not take a
	coro_frame_ptr argument.
	(build_coroutine_frame_alloc_expr): Rename frame_size to
	alloc_size and take it by reference.  If alloc_store_pointer,
	extend that size to account for extra storage needed for the
	allocptr.  If allocptr_expr, extend it further to support
	rounding the allocation result.  After calling operator new, if
	need be, align the resulting pointer and store the original for
	later deletion.
	(allocptr_expr_member): New function.  Implements allocptr_expr
	for the case where we store the allocptr as a _Coro_allocptr
	member in the frame.
	(allocptr_expr_after_frame): New function.  Implements
	allocptr_expr for the case where we couldn't store the allocptr
	asa member of the frame, so we must place it after the frame.
	(cp_coroutine_transform::build_ramp_function): Update
	build_coro_frame_{alloc,delete}_expr calls as needed, pass
	argument to the actor through build_resume_to_frame_expr (with
	BACKWARDS_P set).
	(cp_coroutine_transform::apply_transforms): Update
	coro_build_actor_or_destroy_function.
	(cp_coroutine_transform::finish_transforms): Update calls to
	build_actor_fn so that it receives an unshared alloc_size.
	Update coro_maybe_dump_transformed_functions call.
	* coroutines.h (cp_coroutine_transform): Rename frame_size to
	alloc_size.

gcc/testsuite/ChangeLog:

	* g++.dg/coroutines/frame-alignment-4.C: New test.
	* g++.dg/coroutines/torture/frame-alignment-1.C: New test.
	* g++.dg/coroutines/torture/frame-alignment-2.C: New test.
	* g++.dg/coroutines/torture/frame-alignment-3.C: New test.
---
 gcc/coroutine-passes.cc                       |   8 +-
 gcc/cp/coroutines.cc                          | 430 +++++++++++++++---
 gcc/cp/coroutines.h                           |   2 +-
 .../g++.dg/coroutines/frame-alignment-4.C     |  35 ++
 .../coroutines/torture/frame-alignment-1.C    |  73 +++
 .../coroutines/torture/frame-alignment-2.C    | 101 ++++
 .../coroutines/torture/frame-alignment-3.C    |  87 ++++
 7 files changed, 671 insertions(+), 65 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/coroutines/frame-alignment-4.C
 create mode 100644 gcc/testsuite/g++.dg/coroutines/torture/frame-alignment-1.C
 create mode 100644 gcc/testsuite/g++.dg/coroutines/torture/frame-alignment-2.C
 create mode 100644 gcc/testsuite/g++.dg/coroutines/torture/frame-alignment-3.C

Message ID	20240918210202.192478-3-arsen@aarsen.me
State	New
Headers	DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org CDDF33858430 From: =?utf-8?q?Arsen_Arsenovi=C4=87?= <arsen@aarsen.me> To: Jason Merrill <jason@redhat.com> Cc: gcc-patches@gcc.gnu.org, Iain Sandoe <iain@sandoe.co.uk>, Jonathan Wakely <jwakely.gcc@gmail.com>, =?utf-8?q?Arsen_Arsenovi=C4=87?= <arsen@aarsen.me> Subject: [PATCH 2/2] c++/coroutines: handle (new-)extended alignment [PR104177] Date: Wed, 18 Sep 2024 22:36:13 +0200 Message-ID: <20240918210202.192478-3-arsen@aarsen.me> In-Reply-To: <20240918210202.192478-1-arsen@aarsen.me> References: <20240918210202.192478-1-arsen@aarsen.me> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: list Errors-To: gcc-patches-bounces~patchwork=sourceware.org@gcc.gnu.org
Series	Support for coroutine frames with new-extended alignment \| [0/2] Support for coroutine frames with new-extended alignment [1/2] c++: Implement a coroutine language debug dump [2/2] c++/coroutines: handle (new-)extended alignment [PR104177]

Context	Check	Description
linaro-tcwg-bot/tcwg_gcc_build--master-arm	success	Build passed
linaro-tcwg-bot/tcwg_gcc_build--master-aarch64	success	Build passed
linaro-tcwg-bot/tcwg_gcc_check--master-aarch64	success	Test passed
linaro-tcwg-bot/tcwg_gcc_check--master-arm	success	Test passed

[2/2] c++/coroutines: handle (new-)extended alignment [PR104177]

Checks

Commit Message

Patch