[Ada] Fix PR ada/53592

[Eric Botcazou <ebotcazou at adacore dot com>]

This is the ICE on the assignment to a component of a vector_type, which comes 
from the VIEW_CONVERT_EXPR generated to turn it into an array array.  Now that 
VECTOR_TYPEs can be GIMPLE registers, this construct breaks.

Fixed by marking the vector as addressable, as suggested by Richard.  Tested on 
i586-suse-linux, applied on mainline and 4.7 branch.


2012-06-15  Eric Botcazou  <ebotcazou@adacore.com>

	PR ada/53592
	* gcc-interface/gigi.h (maybe_vector_array): Make static inline.
	* gcc-interface/utils.c (maybe_vector_array): Delete.
	* gcc-interface/trans.c (gnat_to_gnu) <N_Indexed_Component>: Mark the
	array object as addressable if it has vector type and is on the LHS.


2012-06-15  Eric Botcazou  <ebotcazou@adacore.com>

	* gnat.dg/vect8.ad[sb]: New test.


-- 
Eric Botcazou

Index: gcc-interface/utils.c
===================================================================
--- gcc-interface/utils.c	(revision 188647)
+++ gcc-interface/utils.c	(working copy)
@@ -5149,20 +5149,6 @@ maybe_unconstrained_array (tree exp)
 
   return exp;
 }
-
-/* If EXP's type is a VECTOR_TYPE, return EXP converted to the associated
-   TYPE_REPRESENTATIVE_ARRAY.  */
-
-tree
-maybe_vector_array (tree exp)
-{
-  tree etype = TREE_TYPE (exp);
-
-  if (VECTOR_TYPE_P (etype))
-    exp = convert (TYPE_REPRESENTATIVE_ARRAY (etype), exp);
-
-  return exp;
-}
 
 /* Return true if EXPR is an expression that can be folded as an operand
    of a VIEW_CONVERT_EXPR.  See ada-tree.h for a complete rationale.  */
Index: gcc-interface/gigi.h
===================================================================
--- gcc-interface/gigi.h	(revision 188647)
+++ gcc-interface/gigi.h	(working copy)
@@ -783,10 +783,6 @@ extern tree remove_conversions (tree exp
    likewise return an expression pointing to the underlying array.  */
 extern tree maybe_unconstrained_array (tree exp);
 
-/* If EXP's type is a VECTOR_TYPE, return EXP converted to the associated
-   TYPE_REPRESENTATIVE_ARRAY.  */
-extern tree maybe_vector_array (tree exp);
-
 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
    If NOTRUNC_P is true, truncation operations should be suppressed.  */
 extern tree unchecked_convert (tree type, tree expr, bool notrunc_p);
@@ -1033,6 +1029,20 @@ extern void enumerate_modes (void (*f) (
 /* Convenient shortcuts.  */
 #define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE)
 
+/* If EXP's type is a VECTOR_TYPE, return EXP converted to the associated
+   TYPE_REPRESENTATIVE_ARRAY.  */
+
+static inline tree
+maybe_vector_array (tree exp)
+{
+  tree etype = TREE_TYPE (exp);
+
+  if (VECTOR_TYPE_P (etype))
+    exp = convert (TYPE_REPRESENTATIVE_ARRAY (etype), exp);
+
+  return exp;
+}
+
 static inline unsigned HOST_WIDE_INT
 ceil_pow2 (unsigned HOST_WIDE_INT x)
 {
Index: gcc-interface/trans.c
===================================================================
--- gcc-interface/trans.c	(revision 188647)
+++ gcc-interface/trans.c	(working copy)
@@ -5372,7 +5372,12 @@ gnat_to_gnu (Node_Id gnat_node)
 
 	/* Convert vector inputs to their representative array type, to fit
 	   what the code below expects.  */
-	gnu_array_object = maybe_vector_array (gnu_array_object);
+	if (VECTOR_TYPE_P (TREE_TYPE (gnu_array_object)))
+	  {
+	    if (present_in_lhs_or_actual_p (gnat_node))
+	      gnat_mark_addressable (gnu_array_object);
+	    gnu_array_object = maybe_vector_array (gnu_array_object);
+	  }
 
 	gnu_array_object = maybe_unconstrained_array (gnu_array_object);
 

package body Vect8 is

   function Foo (V : Vec) return Vec is
      Ret : Vec;
   begin
      Ret (1) := V (1) + V (2);
      Ret (2) := V (1) - V (2);
      return Ret;
   end;

end Vect8;

-- { dg-do compile }

package Vect8 is

   type Vec is array (1 .. 2) of Long_Float;
   pragma Machine_Attribute (Vec, "vector_type");

   function Foo (V : Vec) return Vec;

end Vect8;