[Ada] Avoid copy operation for returns involving function calls

gcc/ada/

	* gcc-interface/decl.cc (gnat_to_gnu_entity) <E_Constant>: Deal with
	a constant related to a return in a function specially.
	* gcc-interface/trans.cc (Call_to_gnu): Use return slot optimization
	if the target is a return object.
	(gnat_to_gnu) <N_Object_Declaration>: Deal with a constant related
	to a return in a function specially.

2 files changed, 53 insertions, 0 deletions

diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc
index 2d9b41f..50d17f7 100644
--- a/gcc/ada/gcc-interface/decl.cc
+++ b/gcc/ada/gcc-interface/decl.cc
@@ -630,6 +630,17 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
       break;
 
     case E_Constant:
+      /* If this is a constant related to a return in a function returning by
+	 invisible reference without expression, get the return object.  */
+      if (Is_Related_To_Func_Return (gnat_entity)
+	  && current_function_decl
+	  && TREE_ADDRESSABLE (TREE_TYPE (current_function_decl))
+	  && !gnu_expr)
+	{
+	  gnu_decl = DECL_RESULT (current_function_decl);
+	  break;
+	}
+
       /* Ignore constant definitions already marked with the error node.  See
 	 the N_Object_Declaration case of gnat_to_gnu for the rationale.  */
       if (definition
diff --git a/gcc/ada/gcc-interface/trans.cc b/gcc/ada/gcc-interface/trans.cc
index 3e8842f..e80200e 100644
--- a/gcc/ada/gcc-interface/trans.cc
+++ b/gcc/ada/gcc-interface/trans.cc
@@ -5281,6 +5281,15 @@ Call_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, tree gnu_target,
 		   && return_slot_opt_for_pure_call_p (gnu_target, gnu_call))
 	    op_code = INIT_EXPR;
 
+	  /* If this is the initialization of a return object in a function
+	     returning by invisible reference, we can always use the return
+	     slot optimization.  */
+	  else if (TREE_CODE (gnu_target) == INDIRECT_REF
+		   && TREE_CODE (TREE_OPERAND (gnu_target, 0)) == RESULT_DECL
+		   && current_function_decl
+		   && TREE_ADDRESSABLE (TREE_TYPE (current_function_decl)))
+	    op_code = INIT_EXPR;
+
 	  else
 	    op_code = MODIFY_EXPR;
 
@@ -6380,6 +6389,39 @@ gnat_to_gnu (Node_Id gnat_node)
 	      || Is_Concurrent_Type (Etype (gnat_temp))))
 	break;
 
+      /* If this is a constant related to a return initialized by a reference
+	 to a function call in a function returning by invisible reference:
+
+	   type Ann is access all Result_Type;
+	   Rnn : constant Ann := Func'reference;
+	   [...]
+	   return Rnn.all;
+
+	 then elide the temporary by forwarding the return object to Func:
+
+	   *<retval> = Func (); [return slot optimization]
+	   [...]
+	   return <retval>;
+
+	 That's necessary if the result type needs finalization because the
+	 temporary would never be adjusted as Expand_Simple_Function_Return
+	 also elides the temporary in this case.  */
+      if (Ekind (gnat_temp) == E_Constant
+	  && Is_Related_To_Func_Return (gnat_temp)
+	  && Nkind (Expression (gnat_node)) == N_Reference
+	  && Nkind (Prefix (Expression (gnat_node))) == N_Function_Call
+	  && current_function_decl
+	  && TREE_ADDRESSABLE (TREE_TYPE (current_function_decl)))
+	{
+	  gnu_result = gnat_to_gnu_entity (gnat_temp, NULL_TREE, true);
+	  gnu_result = build_unary_op (INDIRECT_REF, NULL_TREE, gnu_result);
+	  gnu_result
+	    = Call_to_gnu (Prefix (Expression (gnat_node)),
+			   &gnu_result_type, gnu_result,
+			   NOT_ATOMIC, false);
+	  break;
+	}
+
       if (Present (Expression (gnat_node))
 	  && !(kind == N_Object_Declaration && No_Initialization (gnat_node))
 	  && (!type_annotate_only