[Ada] Fix type consistency problem with slices

[Ada] Fix type consistency problem with slices

[Eric Botcazou]

[-- Attachment #1: Type: text/plain, Size: 983 bytes --]

The more strict type checking on mainline reveals that gigi builds non-type 
consistent slices in some cases, i.e. slices whose element type is not the 
same as the element type of the arrays they are part of.  This can happen 
when the original element type is a discriminated record type with default 
discriminant, because different padded types are built as effective element 
types for the array's type and for the slice's type.

Recycling padded types has turned to be quite tricky, so adding a conversion 
seems to be the best approach.

Tested on i586-suse-linux, applied on the mainline.


2009-10-17  Eric Botcazou  <ebotcazou@adacore.com>

	* gcc-interface/utils2.c (build_binary_op) <ARRAY_RANGE_REF>: Make
	sure the element type is consistent.


2009-10-17  Eric Botcazou  <ebotcazou@adacore.com>

	* gnat.dg/slice8.adb: New test.
	* gnat.dg/slice8_pkg1.ads: New helper.
	* gnat.dg/slice8_pkg2.ads: Likewise.
	* gnat.dg/slice8_pkg3.ad[sb]: Likewise.


-- 
Eric Botcazou

[-- Attachment #2: slice8.adb --]
[-- Type: text/x-adasrc, Size: 177 bytes --]

-- { dg-do compile }
-- { dg-options "-gnatws" }

with Slice8_Pkg1;
with Slice8_Pkg3;

procedure Slice8 is

   package Bp is new Slice8_Pkg3 (Slice8_Pkg1);

begin
   null;
end;

[-- Attachment #3: slice8_pkg1.ads --]
[-- Type: text/x-adasrc, Size: 99 bytes --]

with Slice8_Pkg2;

package Slice8_Pkg1 is new Slice8_Pkg2 (Line_Length => 132, Max_Lines => 1000);

[-- Attachment #4: slice8_pkg3.ads --]
[-- Type: text/x-adasrc, Size: 154 bytes --]

with Slice8_Pkg2;

generic

   with package Str is new Slice8_Pkg2 (<>);

package Slice8_Pkg3 is

   function Get return Str.Paragraph;

end Slice8_Pkg3;

[-- Attachment #5: slice8_pkg2.ads --]
[-- Type: text/x-adasrc, Size: 457 bytes --]

generic

   Line_Length : Natural;
   Max_Lines   : Natural;

package Slice8_Pkg2 is

   Subtype Index      is Natural Range 0..Line_length;
   Subtype Line_Count is Natural Range 0..Max_Lines;

   Type Line (Size : Index := 0) is
   Record
      Data : String (1..Size);
   End Record;

   Type Lines is Array (Line_Count Range <>) of Line;

   Type Paragraph (Size : Line_Count) is
   Record
      Data : Lines (1..Size);
   End Record;

end Slice8_Pkg2;

[-- Attachment #6: slice8_pkg3.adb --]
[-- Type: text/x-adasrc, Size: 391 bytes --]

-- { dg-do compile }
-- { dg-options "-gnatws" }

package body Slice8_Pkg3 is

   Current : Str.Lines (Str.Line_Count);
   Last    : Natural := 0;

   function Get return Str.Paragraph is
      Result : constant Str.Paragraph := (Size => Last,
                                          Data => Current (1..Last));
   begin
      Last := 0;
      return Result;
   end Get;

end Slice8_Pkg3;

[-- Attachment #7: p.diff --]
[-- Type: text/x-diff, Size: 777 bytes --]

Index: gcc-interface/utils2.c
===================================================================
--- gcc-interface/utils2.c	(revision 152917)
+++ gcc-interface/utils2.c	(working copy)
@@ -755,6 +755,12 @@ build_binary_op (enum tree_code op_code,
 	  left_type = TREE_TYPE (left_operand);
 	}
 
+      /* For a range, make sure the element type is consistent.  */
+      if (op_code == ARRAY_RANGE_REF
+	  && TREE_TYPE (operation_type) != TREE_TYPE (left_type))
+	operation_type = build_array_type (TREE_TYPE (left_type),
+					   TYPE_DOMAIN (operation_type));
+
       /* Then convert the right operand to its base type.  This will prevent
 	 unneeded sign conversions when sizetype is wider than integer.  */
       right_operand = convert (right_base_type, right_operand);