[Ada] Fix ICE on Component_Size clause with atomic type

[Eric Botcazou]

The compiler aborts on the assignment to an array component if the component 
type is an atomic type and the array is subject to a Component_Size clause 
that is too large for atomic access on the target.  A proper error message 
must be issued instead.

Tested on x86-64/Linux, applied on the mainline.


2018-01-10  Eric Botcazou  <ebotca...@adacore.com>

        * gcc-interface/decl.c (gnat_to_gnu_component_type): Apply the check
        for atomic access once the component size is taken into account and
        also do it if the component type is Atomic or Volatile_Full_Access.


2018-01-10  Eric Botcazou  <ebotca...@adacore.com>

        * gnat.dg/atomic10.adb: New test.

-- 
Eric Botcazou
Index: gcc-interface/decl.c
===================================================================
--- gcc-interface/decl.c	(revision 256275)
+++ gcc-interface/decl.c	(working copy)
@@ -5022,9 +5022,6 @@ gnat_to_gnu_component_type (Entity_Id gn
       && tree_fits_uhwi_p (TYPE_SIZE (gnu_type)))
     gnu_type = make_packable_type (gnu_type, false, max_align);
 
-  if (Has_Atomic_Components (gnat_array))
-    check_ok_for_atomic_type (gnu_type, gnat_array, true);
-
   /* Get and validate any specified Component_Size.  */
   gnu_comp_size
     = validate_size (Component_Size (gnat_array), gnu_type, gnat_array,
@@ -5071,6 +5068,9 @@ gnat_to_gnu_component_type (Entity_Id gn
 			  gnat_array);
     }
 
+  if (Has_Atomic_Components (gnat_array) || Is_Atomic_Or_VFA (gnat_type))
+    check_ok_for_atomic_type (gnu_type, gnat_array, true);
+
   /* If the component type is a padded type made for a non-bit-packed array
      of scalars with reverse storage order, we need to propagate the reverse
      storage order to the padding type since it is the innermost enclosing

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

with System.Multiprocessors;

procedure Atomic10 is

  type Atomic_Unsigned is mod 2 ** 32;
  pragma Atomic (Atomic_Unsigned);

  Max : Positive := Positive (System.Multiprocessors.Number_Of_CPUs);

  Comp_Size : constant := 64 * 8;

  subtype Index_Type is Positive range 1 .. Max;

  type Array_Type is array (Index_Type) of aliased Atomic_Unsigned; -- { dg-error "cannot be guaranteed" }
  for Array_Type'Component_Size use Comp_Size;

  Slots : Array_Type;
begin
  for Index in Index_Type loop
     Slots (Index) := 0;
   end loop;
end;