[multiple changes]

2014-10-17  Robert Dewar  <dewar@adacore.com>

	* sem_attr.adb (Eval_Attribute): Ensure that attribute
	reference is not marked as being a static expression if the
	prefix evaluation raises CE.

2014-10-17  Robert Dewar  <dewar@adacore.com>

	* exp_pakd.adb: Move bit packed entity tables to spec.
	* exp_pakd.ads: Move bit packed entity tables here from body.
	* freeze.adb (Freeze_Array_Type): Check that packed array type
	is supported.
	* rtsfind.adb (PRE_Id_Table): New table (Entity_Not_Defined):
	Specialize messages using PRE_Id_Table.
	* uintp.ads, uintp.adb (UI_Image): New functional form.

2014-10-17  Robert Dewar  <dewar@adacore.com>

	* aspects.ads, aspects.adb: Add Suppress_Initialization aspect.
	* einfo.ads, einfo.adb (Suppress_Initialization): Now applies to
	E_Variable.
	* exp_ch3.adb (Default_Initialize_Object): Handle
	Suppress_Initialization.
	* exp_prag.adb (Expand_Pragma_Suppress_Initialization): New
	procedure (Expand_N_Pragma): Handle Suppress_Initialization
	(Expand_Pragma_Import_Or_Interface): Use Undo_Initialization
	(Undo_Initialization): New procedure.
	* sem_prag.adb (Analyze_Pragma, case Suppress_Initialization):
	This is now allowed for E_Variable case.
	* gnat_rm.texi: Document new aspect Suppress_Initialization
	Suppress_Initialization aspect/pragma can apply to variable.
	* einfo.ads: Minor reformatting.

2014-10-17  Arnaud Charlet  <charlet@adacore.com>

	* spark_xrefs.ads: Add documentation pointer to Flow_Computed_Globals.

2014-10-17  Robert Dewar  <dewar@adacore.com>

	* cstand.adb (Create_Standard): Mark Short_Integer as
	implementation defined.
	* sem_util.adb (Set_Entity_With_Checks): Avoid blow up for
	compiler built with assertions for No_Implementation_Identifiers test.

From-SVN: r216379

1 files changed, 363 insertions, 1 deletions

diff --git a/gcc/ada/exp_pakd.ads b/gcc/ada/exp_pakd.ads
index 586d806..80b6324 100644
--- a/gcc/ada/exp_pakd.ads
+++ b/gcc/ada/exp_pakd.ads
@@ -25,7 +25,8 @@
 
 --  Expand routines for manipulation of packed arrays
 
-with Types; use Types;
+with Rtsfind; use Rtsfind;
+with Types;   use Types;
 
 package Exp_Pakd is
 
@@ -203,6 +204,367 @@ package Exp_Pakd is
    --   and now, we do indeed have the same representation for the memory
    --   version in the constrained and unconstrained cases.
 
+   ----------------------------------------------
+   -- Entity Tables for Packed Access Routines --
+   ----------------------------------------------
+
+   --  For the cases of component size = 3,5-7,9-15,17-31,33-63 we call library
+   --  routines. These tables provide the entity for the proper routine. They
+   --  are exposed in the spec to allow checking for the presence of the needed
+   --  routine when an array is subject to pragma Pack.
+
+   type E_Array is array (Int range 01 .. 63) of RE_Id;
+
+   --  Array of Bits_nn entities. Note that we do not use library routines
+   --  for the 8-bit and 16-bit cases, but we still fill in the table, using
+   --  entries from System.Unsigned, because we also use this table for
+   --  certain special unchecked conversions in the big-endian case.
+
+   Bits_Id : constant E_Array :=
+     (01 => RE_Bits_1,
+      02 => RE_Bits_2,
+      03 => RE_Bits_03,
+      04 => RE_Bits_4,
+      05 => RE_Bits_05,
+      06 => RE_Bits_06,
+      07 => RE_Bits_07,
+      08 => RE_Unsigned_8,
+      09 => RE_Bits_09,
+      10 => RE_Bits_10,
+      11 => RE_Bits_11,
+      12 => RE_Bits_12,
+      13 => RE_Bits_13,
+      14 => RE_Bits_14,
+      15 => RE_Bits_15,
+      16 => RE_Unsigned_16,
+      17 => RE_Bits_17,
+      18 => RE_Bits_18,
+      19 => RE_Bits_19,
+      20 => RE_Bits_20,
+      21 => RE_Bits_21,
+      22 => RE_Bits_22,
+      23 => RE_Bits_23,
+      24 => RE_Bits_24,
+      25 => RE_Bits_25,
+      26 => RE_Bits_26,
+      27 => RE_Bits_27,
+      28 => RE_Bits_28,
+      29 => RE_Bits_29,
+      30 => RE_Bits_30,
+      31 => RE_Bits_31,
+      32 => RE_Unsigned_32,
+      33 => RE_Bits_33,
+      34 => RE_Bits_34,
+      35 => RE_Bits_35,
+      36 => RE_Bits_36,
+      37 => RE_Bits_37,
+      38 => RE_Bits_38,
+      39 => RE_Bits_39,
+      40 => RE_Bits_40,
+      41 => RE_Bits_41,
+      42 => RE_Bits_42,
+      43 => RE_Bits_43,
+      44 => RE_Bits_44,
+      45 => RE_Bits_45,
+      46 => RE_Bits_46,
+      47 => RE_Bits_47,
+      48 => RE_Bits_48,
+      49 => RE_Bits_49,
+      50 => RE_Bits_50,
+      51 => RE_Bits_51,
+      52 => RE_Bits_52,
+      53 => RE_Bits_53,
+      54 => RE_Bits_54,
+      55 => RE_Bits_55,
+      56 => RE_Bits_56,
+      57 => RE_Bits_57,
+      58 => RE_Bits_58,
+      59 => RE_Bits_59,
+      60 => RE_Bits_60,
+      61 => RE_Bits_61,
+      62 => RE_Bits_62,
+      63 => RE_Bits_63);
+
+   --  Array of Get routine entities. These are used to obtain an element from
+   --  a packed array. The N'th entry is used to obtain elements from a packed
+   --  array whose component size is N. RE_Null is used as a null entry, for
+   --  the cases where a library routine is not used.
+
+   Get_Id : constant E_Array :=
+     (01 => RE_Null,
+      02 => RE_Null,
+      03 => RE_Get_03,
+      04 => RE_Null,
+      05 => RE_Get_05,
+      06 => RE_Get_06,
+      07 => RE_Get_07,
+      08 => RE_Null,
+      09 => RE_Get_09,
+      10 => RE_Get_10,
+      11 => RE_Get_11,
+      12 => RE_Get_12,
+      13 => RE_Get_13,
+      14 => RE_Get_14,
+      15 => RE_Get_15,
+      16 => RE_Null,
+      17 => RE_Get_17,
+      18 => RE_Get_18,
+      19 => RE_Get_19,
+      20 => RE_Get_20,
+      21 => RE_Get_21,
+      22 => RE_Get_22,
+      23 => RE_Get_23,
+      24 => RE_Get_24,
+      25 => RE_Get_25,
+      26 => RE_Get_26,
+      27 => RE_Get_27,
+      28 => RE_Get_28,
+      29 => RE_Get_29,
+      30 => RE_Get_30,
+      31 => RE_Get_31,
+      32 => RE_Null,
+      33 => RE_Get_33,
+      34 => RE_Get_34,
+      35 => RE_Get_35,
+      36 => RE_Get_36,
+      37 => RE_Get_37,
+      38 => RE_Get_38,
+      39 => RE_Get_39,
+      40 => RE_Get_40,
+      41 => RE_Get_41,
+      42 => RE_Get_42,
+      43 => RE_Get_43,
+      44 => RE_Get_44,
+      45 => RE_Get_45,
+      46 => RE_Get_46,
+      47 => RE_Get_47,
+      48 => RE_Get_48,
+      49 => RE_Get_49,
+      50 => RE_Get_50,
+      51 => RE_Get_51,
+      52 => RE_Get_52,
+      53 => RE_Get_53,
+      54 => RE_Get_54,
+      55 => RE_Get_55,
+      56 => RE_Get_56,
+      57 => RE_Get_57,
+      58 => RE_Get_58,
+      59 => RE_Get_59,
+      60 => RE_Get_60,
+      61 => RE_Get_61,
+      62 => RE_Get_62,
+      63 => RE_Get_63);
+
+   --  Array of Get routine entities to be used in the case where the packed
+   --  array is itself a component of a packed structure, and therefore may not
+   --  be fully aligned. This only affects the even sizes, since for the odd
+   --  sizes, we do not get any fixed alignment in any case.
+
+   GetU_Id : constant E_Array :=
+     (01 => RE_Null,
+      02 => RE_Null,
+      03 => RE_Get_03,
+      04 => RE_Null,
+      05 => RE_Get_05,
+      06 => RE_GetU_06,
+      07 => RE_Get_07,
+      08 => RE_Null,
+      09 => RE_Get_09,
+      10 => RE_GetU_10,
+      11 => RE_Get_11,
+      12 => RE_GetU_12,
+      13 => RE_Get_13,
+      14 => RE_GetU_14,
+      15 => RE_Get_15,
+      16 => RE_Null,
+      17 => RE_Get_17,
+      18 => RE_GetU_18,
+      19 => RE_Get_19,
+      20 => RE_GetU_20,
+      21 => RE_Get_21,
+      22 => RE_GetU_22,
+      23 => RE_Get_23,
+      24 => RE_GetU_24,
+      25 => RE_Get_25,
+      26 => RE_GetU_26,
+      27 => RE_Get_27,
+      28 => RE_GetU_28,
+      29 => RE_Get_29,
+      30 => RE_GetU_30,
+      31 => RE_Get_31,
+      32 => RE_Null,
+      33 => RE_Get_33,
+      34 => RE_GetU_34,
+      35 => RE_Get_35,
+      36 => RE_GetU_36,
+      37 => RE_Get_37,
+      38 => RE_GetU_38,
+      39 => RE_Get_39,
+      40 => RE_GetU_40,
+      41 => RE_Get_41,
+      42 => RE_GetU_42,
+      43 => RE_Get_43,
+      44 => RE_GetU_44,
+      45 => RE_Get_45,
+      46 => RE_GetU_46,
+      47 => RE_Get_47,
+      48 => RE_GetU_48,
+      49 => RE_Get_49,
+      50 => RE_GetU_50,
+      51 => RE_Get_51,
+      52 => RE_GetU_52,
+      53 => RE_Get_53,
+      54 => RE_GetU_54,
+      55 => RE_Get_55,
+      56 => RE_GetU_56,
+      57 => RE_Get_57,
+      58 => RE_GetU_58,
+      59 => RE_Get_59,
+      60 => RE_GetU_60,
+      61 => RE_Get_61,
+      62 => RE_GetU_62,
+      63 => RE_Get_63);
+
+   --  Array of Set routine entities. These are used to assign an element of a
+   --  packed array. The N'th entry is used to assign elements for a packed
+   --  array whose component size is N. RE_Null is used as a null entry, for
+   --  the cases where a library routine is not used.
+
+   Set_Id : constant E_Array :=
+     (01 => RE_Null,
+      02 => RE_Null,
+      03 => RE_Set_03,
+      04 => RE_Null,
+      05 => RE_Set_05,
+      06 => RE_Set_06,
+      07 => RE_Set_07,
+      08 => RE_Null,
+      09 => RE_Set_09,
+      10 => RE_Set_10,
+      11 => RE_Set_11,
+      12 => RE_Set_12,
+      13 => RE_Set_13,
+      14 => RE_Set_14,
+      15 => RE_Set_15,
+      16 => RE_Null,
+      17 => RE_Set_17,
+      18 => RE_Set_18,
+      19 => RE_Set_19,
+      20 => RE_Set_20,
+      21 => RE_Set_21,
+      22 => RE_Set_22,
+      23 => RE_Set_23,
+      24 => RE_Set_24,
+      25 => RE_Set_25,
+      26 => RE_Set_26,
+      27 => RE_Set_27,
+      28 => RE_Set_28,
+      29 => RE_Set_29,
+      30 => RE_Set_30,
+      31 => RE_Set_31,
+      32 => RE_Null,
+      33 => RE_Set_33,
+      34 => RE_Set_34,
+      35 => RE_Set_35,
+      36 => RE_Set_36,
+      37 => RE_Set_37,
+      38 => RE_Set_38,
+      39 => RE_Set_39,
+      40 => RE_Set_40,
+      41 => RE_Set_41,
+      42 => RE_Set_42,
+      43 => RE_Set_43,
+      44 => RE_Set_44,
+      45 => RE_Set_45,
+      46 => RE_Set_46,
+      47 => RE_Set_47,
+      48 => RE_Set_48,
+      49 => RE_Set_49,
+      50 => RE_Set_50,
+      51 => RE_Set_51,
+      52 => RE_Set_52,
+      53 => RE_Set_53,
+      54 => RE_Set_54,
+      55 => RE_Set_55,
+      56 => RE_Set_56,
+      57 => RE_Set_57,
+      58 => RE_Set_58,
+      59 => RE_Set_59,
+      60 => RE_Set_60,
+      61 => RE_Set_61,
+      62 => RE_Set_62,
+      63 => RE_Set_63);
+
+   --  Array of Set routine entities to be used in the case where the packed
+   --  array is itself a component of a packed structure, and therefore may not
+   --  be fully aligned. This only affects the even sizes, since for the odd
+   --  sizes, we do not get any fixed alignment in any case.
+
+   SetU_Id : constant E_Array :=
+     (01 => RE_Null,
+      02 => RE_Null,
+      03 => RE_Set_03,
+      04 => RE_Null,
+      05 => RE_Set_05,
+      06 => RE_SetU_06,
+      07 => RE_Set_07,
+      08 => RE_Null,
+      09 => RE_Set_09,
+      10 => RE_SetU_10,
+      11 => RE_Set_11,
+      12 => RE_SetU_12,
+      13 => RE_Set_13,
+      14 => RE_SetU_14,
+      15 => RE_Set_15,
+      16 => RE_Null,
+      17 => RE_Set_17,
+      18 => RE_SetU_18,
+      19 => RE_Set_19,
+      20 => RE_SetU_20,
+      21 => RE_Set_21,
+      22 => RE_SetU_22,
+      23 => RE_Set_23,
+      24 => RE_SetU_24,
+      25 => RE_Set_25,
+      26 => RE_SetU_26,
+      27 => RE_Set_27,
+      28 => RE_SetU_28,
+      29 => RE_Set_29,
+      30 => RE_SetU_30,
+      31 => RE_Set_31,
+      32 => RE_Null,
+      33 => RE_Set_33,
+      34 => RE_SetU_34,
+      35 => RE_Set_35,
+      36 => RE_SetU_36,
+      37 => RE_Set_37,
+      38 => RE_SetU_38,
+      39 => RE_Set_39,
+      40 => RE_SetU_40,
+      41 => RE_Set_41,
+      42 => RE_SetU_42,
+      43 => RE_Set_43,
+      44 => RE_SetU_44,
+      45 => RE_Set_45,
+      46 => RE_SetU_46,
+      47 => RE_Set_47,
+      48 => RE_SetU_48,
+      49 => RE_Set_49,
+      50 => RE_SetU_50,
+      51 => RE_Set_51,
+      52 => RE_SetU_52,
+      53 => RE_Set_53,
+      54 => RE_SetU_54,
+      55 => RE_Set_55,
+      56 => RE_SetU_56,
+      57 => RE_Set_57,
+      58 => RE_SetU_58,
+      59 => RE_Set_59,
+      60 => RE_SetU_60,
+      61 => RE_Set_61,
+      62 => RE_SetU_62,
+      63 => RE_Set_63);
+
    -----------------
    -- Subprograms --
    -----------------