[Ada] Crash on limited array object with address clause

gcc/ada/

	* exp_aggr.adb (Convert_Aggr_In_Object_Decl): After expansion of
	the aggregate, the expression can be removed from the
	declaration, except if the object is class-wide, in which case
	the aggregate provides the actual type. In other cases the
	presence of the expression may lead to spurious freezing issue.
	* exp_ch3.adb (Expand_N_Object_Declaration): If the expression
	in the declaration is an aggregate with delayed expansion (as is
	the case for objects of a limited type, or a subsequent address
	specification) the aggregate must be resolved at this point.
	This resolution must not include expansion, because the
	expansion of the enclosing declaration will construct the
	necessary aggregate expansion.

diff --git a/gcc/ada/exp_aggr.adb b/gcc/ada/exp_aggr.adb
index 85e2abb07323db6295cbb49f3faf9bf94cf15057..56ec1be5d7fbf0a24118f6da4edca6669f7a021d 100644 (file)
--- a/gcc/ada/exp_aggr.adb
+++ b/gcc/ada/exp_aggr.adb
@@ -4437,6 +4437,15 @@ package body Exp_Aggr is
       end;
 
       Set_No_Initialization (N);
+
+      --  After expansion the expression can be removed from the declaration
+      --  except if the object is class-wide, in which case the aggregate
+      --  provides the actual type.
+
+      if not Is_Class_Wide_Type (Etype (Obj)) then
+         Set_Expression (N, Empty);
+      end if;
+
       Initialize_Discriminants (N, Typ);
    end Convert_Aggr_In_Object_Decl;
 

diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb
index 6a8b33073cf560f71fe0572de7c50223232540df..4dbaadd637d0c87ea68af7fb8cfe80d6b16cc652 100644 (file)
--- a/gcc/ada/exp_ch3.adb
+++ b/gcc/ada/exp_ch3.adb
@@ -30,6 +30,7 @@ with Einfo;          use Einfo;
 with Einfo.Entities; use Einfo.Entities;
 with Einfo.Utils;    use Einfo.Utils;
 with Errout;         use Errout;
+with Expander;       use Expander;
 with Exp_Aggr;       use Exp_Aggr;
 with Exp_Atag;       use Exp_Atag;
 with Exp_Ch4;        use Exp_Ch4;
@@ -6985,12 +6986,16 @@ package body Exp_Ch3 is
             --  happen when the aggregate is limited and the declared object
             --  has a following address clause; it happens also when generating
             --  C code for an aggregate that has an alignment or address clause
-            --  (see Analyze_Object_Declaration).
+            --  (see Analyze_Object_Declaration). Resolution is done without
+            --  expansion because it will take place when the declaration
+            --  itself is expanded.
 
             if (Is_Limited_Type (Typ) or else Modify_Tree_For_C)
               and then not Analyzed (Expr)
             then
+               Expander_Mode_Save_And_Set (False);
                Resolve (Expr, Typ);
+               Expander_Mode_Restore;
             end if;
 
             Convert_Aggr_In_Object_Decl (N);