ada: Implement full relaxed finalization semantics for controlled objects

These semantics state that the compiler is permitted to enforce none of
the guarantees specified by the RM 7.6.1(14/1) and following subclauses,
and to instead just let the exception be propagated upward.

The guarantees impose a significant overhead in terms of complexity and
run-time performance compared to similar constructs in other languages,
and the goal is to reduce it significantly, if not eliminate it totally:
for example, untagged record types declared with the Finalizable aspect,
the relaxed finalization semantics and inline Initialize/Adjust/Finalize
primitives, and used with abort disabled:

  pragma Restrictions (No_Abort_Statements);
  pragma Restrictions (Max_Asynchronous_Select_Nesting => 0);
  pragma Restrictions (No_Asynchronous_Control);

should behave like simple C++ classes.

The implementation morally boils down to undoing the changes made a few
months ago to the support of finalization for controlled objects, i.e.
to getting rid of the added linked list and the associated indirection
for controlled objects with relaxed finalization semantics.

But, in order to keep a unified processing for both kinds of controlled
objects and not to bring back the issues addressed by the aforementioned
changes, the work is split between the front-end and the code generator:
the front-end drops the linked list and the code generator is in charge
of eliminating the indirection with the help of the optimizer.

gcc/ada/

	* doc/gnat_rm/gnat_language_extensions.rst (Generalized
	Finalization): Update status.
	* einfo.ads (Has_Relaxed_Finalization): Add more details.
	* exp_ch4.adb (Process_Transients_In_Expression): Invoke
	Make_Finalize_Call_For_Node instead of building the call.
	* exp_ch5.adb (Expand_N_Assignment_Statement): Do not set up an
	exception handler around the assignment for a controlled type with
	relaxed finalization semantics. Streamline the code implementing
	the protection against aborts and do not use an At_End handler for
	a controlled type with relaxed finalization semantics.
	* exp_ch7.ads (Make_Finalize_Call_For_Node): New function.
	* exp_ch7.adb (Finalize_Address_For_Node): New function renaming.
	(Set_Finalize_Address_For_Node): New procedure renaming.
	(Attach_Object_To_Master_Node): Also attach the Finalize_Address
	primitive to the Master_Node statically.
	(Build_Finalizer): Add Has_Strict_Ctrl_Objs local variable. Insert
	back the body of the finalizer at the end of the statement list in
	the non-package case and restore the associated support code to
	that effect. When all the controlled objects have the relaxed
	finalization semantics, do not create a Finalization_Master and
	finalize the objects directly instead.
	(Processing_Actions): Add Strict parameter and use it to set the
	Has_Strict_Ctrl_Objs variable.
	(Process_Declarations): Make main loop more robust and adjust
	calls to Processing_Actions.
	(Make_Finalize_Address_Body): Mark the primitive as inlined if the
	type has relaxed finalization semantics.
	(Make_Finalize_Call_For_Node): New function.
	* sem_ch6.adb (Check_Statement_Sequence): Skip subprogram bodies.
	* libgnat/s-finpri.ads (Finalize_Object): Add Finalize_Address
	parameter.
	(Master_Node): Remove superfluous qualification.
	* libgnat/s-finpri.adb (Attach_Object_To_Node): Likewise.
	(Finalize_Master): Adjust calls to Finalize_Object.
	(Finalize_Object): Add Finalize_Address parameter and assert that
	it is equal to the component of the node. Use the Object_Address
	component as guard.
	(Suppress_Object_Finalize_At_End): Clear Object_Address component.
	* gnat_rm.texi: Regenerate.
	* gnat_ugn.texi: Regenerate.

1 files changed, 1 insertions, 2 deletions

diff --git a/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst b/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
index fc3ca5f..feceff2 100644
--- a/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
+++ b/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
@@ -590,8 +590,7 @@ Example:
     procedure Finalize   (Obj : in out Ctrl);
     procedure Initialize (Obj : in out Ctrl);
 
-As of this writing, the relaxed semantics for finalization operations are
-only implemented for dynamically allocated objects.
+As of this writing, the RFC is implemented except for the `No_Raise` aspect.
 
 Link to the original RFC:
 https://github.com/AdaCore/ada-spark-rfcs/blob/topic/finalization-rehaul/considered/rfc-generalized-finalization.md