2014-07-29 Vincent Celier <celier@adacore.com>

	* gnat_ugn.texi: Document that configuration pragmas files are
	added to the dependencies, unless they contain only pragmas
	Source_File_Name_Project.

2014-07-29  Robert Dewar  <dewar@adacore.com>

	* frontend.adb: Minor reformatting.

2014-07-29  Robert Dewar  <dewar@adacore.com>

	* exp_ch6.adb (Add_Call_By_Copy_Code): Minor reformatting
	(Expand_Actuals): Make sure predicate checks are properly applied
	for the case of OUT or IN OUT parameters.
	* sem_res.adb: Minor reformatting (Resolve_Actuals): Skip
	predicate tests on arguments for Finalize
	* sem_util.adb (No_Predicate_Test_On_Arguments): Returns True
	if predicate tests on subprogram arguments should be skipped.
	* sem_util.ads (No_Predicate_Test_On_Arguments): New function

2014-07-29  Ed Schonberg  <schonberg@adacore.com>

	* sem_ch3.adb (Analyze_Object_Declaration): If there is an address
	clause for the object and the expression is an aggregate, defer
	resolution and expansion of the aggregate until the freeze point
	of the entity.
	* sem_aggr.adb (Resolve_Aggregate): An others_clause is legal if
	the parent node is an N_Reference generated during expansion.

2014-07-29  Vincent Celier  <celier@adacore.com>

	* prj.adb (Add_To_Buffer): Effectively double the size of the buffer.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@213209 138bc75d-0d04-0410-961f-82ee72b054a4

10 files changed, 174 insertions, 56 deletions

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 0a8e374ae83..eb218d687a3 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,37 @@
+2014-07-29  Vincent Celier  <celier@adacore.com>
+
+	* gnat_ugn.texi: Document that configuration pragmas files are
+	added to the dependencies, unless they contain only pragmas
+	Source_File_Name_Project.
+
+2014-07-29  Robert Dewar  <dewar@adacore.com>
+
+	* frontend.adb: Minor reformatting.
+
+2014-07-29  Robert Dewar  <dewar@adacore.com>
+
+	* exp_ch6.adb (Add_Call_By_Copy_Code): Minor reformatting
+	(Expand_Actuals): Make sure predicate checks are properly applied
+	for the case of OUT or IN OUT parameters.
+	* sem_res.adb: Minor reformatting (Resolve_Actuals): Skip
+	predicate tests on arguments for Finalize
+	* sem_util.adb (No_Predicate_Test_On_Arguments): Returns True
+	if predicate tests on subprogram arguments should be skipped.
+	* sem_util.ads (No_Predicate_Test_On_Arguments): New function
+
+2014-07-29  Ed Schonberg  <schonberg@adacore.com>
+
+	* sem_ch3.adb (Analyze_Object_Declaration): If there is an address
+	clause for the object and the expression is an aggregate, defer
+	resolution and expansion of the aggregate until the freeze point
+	of the entity.
+	* sem_aggr.adb (Resolve_Aggregate): An others_clause is legal if
+	the parent node is an N_Reference generated during expansion.
+
+2014-07-29  Vincent Celier  <celier@adacore.com>
+
+	* prj.adb (Add_To_Buffer): Effectively double the size of the buffer.
+
 2014-07-29  Robert Dewar  <dewar@adacore.com>
 
 	* frontend.adb, inline.adb, sem_util.adb, sem_res.adb,
diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb
index 724e82ae8d9..610aa170205 100644
--- a/gcc/ada/exp_ch6.adb
+++ b/gcc/ada/exp_ch6.adb
@@ -23,7 +23,6 @@
 --                                                                          --
 ------------------------------------------------------------------------------
 
-with Aspects;  use Aspects;
 with Atree;    use Atree;
 with Checks;   use Checks;
 with Debug;    use Debug;
@@ -190,6 +189,9 @@ package body Exp_Ch6 is
    --  For non-scalar objects that are possibly unaligned, add call by copy
    --  code (copy in for IN and IN OUT, copy out for OUT and IN OUT).
    --
+   --  For OUT and IN OUT parameters, add predicate checks after the call
+   --  based on the predicates of the actual type.
+   --
    --  The parameter N is IN OUT because in some cases, the expansion code
    --  rewrites the call as an expression actions with the call inside. In
    --  this case N is reset to point to the inside call so that the caller
@@ -1082,19 +1084,18 @@ package body Exp_Ch6 is
                Init := Empty;
                Indic :=
                  Make_Subtype_Indication (Loc,
-                   Subtype_Mark =>
-                     New_Occurrence_Of (F_Typ, Loc),
+                   Subtype_Mark => New_Occurrence_Of (F_Typ, Loc),
                    Constraint   =>
                      Make_Index_Or_Discriminant_Constraint (Loc,
                        Constraints => New_List (
                          Make_Range (Loc,
                            Low_Bound  =>
                              Make_Attribute_Reference (Loc,
-                               Prefix => New_Occurrence_Of (Var, Loc),
+                               Prefix         => New_Occurrence_Of (Var, Loc),
                                Attribute_Name => Name_First),
                            High_Bound =>
                              Make_Attribute_Reference (Loc,
-                               Prefix => New_Occurrence_Of (Var, Loc),
+                               Prefix         => New_Occurrence_Of (Var, Loc),
                                Attribute_Name => Name_Last)))));
 
             else
@@ -1720,7 +1721,7 @@ package body Exp_Ch6 is
                Add_Call_By_Copy_Code;
             end if;
 
-            --  RM 3.2.4 (23/3) : A predicate is checked on in-out and out
+            --  RM 3.2.4 (23/3): A predicate is checked on in-out and out
             --  by-reference parameters on exit from the call. If the actual
             --  is a derived type and the operation is inherited, the body
             --  of the operation will not contain a call to the predicate
@@ -1732,28 +1733,33 @@ package body Exp_Ch6 is
             --  for subtype conversion on assignment, but we can generate the
             --  required check now.
 
-            --  Note that this is needed only if the subtype of the actual has
-            --  an explicit predicate aspect, not if it inherits them from a
-            --  base type or ancestor. The check is also superfluous if the
-            --  subtype is elaborated before the body of the subprogram, but
-            --  this is harder to verify, and there may be a redundant check.
-
             --  Note also that Subp may be either a subprogram entity for
             --  direct calls, or a type entity for indirect calls, which must
             --  be handled separately because the name does not denote an
             --  overloadable entity.
 
-            if not Is_Init_Proc (Subp)
-              and then (Has_Aspect (E_Actual, Aspect_Predicate)
-                          or else
-                        Has_Aspect (E_Actual, Aspect_Dynamic_Predicate)
-                          or else
-                        Has_Aspect (E_Actual, Aspect_Static_Predicate))
-              and then Present (Predicate_Function (E_Actual))
-            then
-               Append_To (Post_Call,
-                 Make_Predicate_Check (E_Actual, Actual));
-            end if;
+            declare
+               Aund : constant Entity_Id := Underlying_Type (E_Actual);
+               Atyp : Entity_Id;
+
+            begin
+               if No (Aund) then
+                  Atyp := E_Actual;
+               else
+                  Atyp := Aund;
+               end if;
+
+               if Has_Predicates (Atyp)
+                 and then Present (Predicate_Function (Atyp))
+
+                 --  Skip predicate checks for special cases
+
+                 and then not No_Predicate_Test_On_Arguments (Subp)
+               then
+                  Append_To (Post_Call,
+                    Make_Predicate_Check (Atyp, Actual));
+               end if;
+            end;
 
          --  Processing for IN parameters
 
diff --git a/gcc/ada/frontend.adb b/gcc/ada/frontend.adb
index 292cab1339d..020fab44682 100644
--- a/gcc/ada/frontend.adb
+++ b/gcc/ada/frontend.adb
@@ -71,8 +71,8 @@ procedure Frontend is
    Config_Pragmas : List_Id;
    --  Gather configuration pragmas
 
-   function Need_To_Be_In_The_Dependencies (Pragma_List : List_Id)
-     return Boolean;
+   function Need_To_Be_In_The_Dependencies
+     (Pragma_List : List_Id) return Boolean;
    --  Check if a configuration pragmas file that contains the Pragma_List
    --  should be a dependency for the source being compiled. Returns
    --  False if Pragma_List is Error_List or contains only pragmas
@@ -82,11 +82,12 @@ procedure Frontend is
    -- Need_To_Be_In_The_Dependencies --
    ------------------------------------
 
-   function Need_To_Be_In_The_Dependencies (Pragma_List : List_Id)
-     return Boolean
+   function Need_To_Be_In_The_Dependencies
+     (Pragma_List : List_Id) return Boolean
    is
       Prag  : Node_Id;
       Pname : Name_Id;
+
    begin
       if Pragma_List /= Error_List then
          Prag := First (Pragma_List);
@@ -104,6 +105,8 @@ procedure Frontend is
       return False;
    end Need_To_Be_In_The_Dependencies;
 
+--  Start of processing for Frontend
+
 begin
    --  Carry out package initializations. These are initializations which might
    --  logically be performed at elaboration time, were it not for the fact
@@ -272,7 +275,8 @@ begin
 
                declare
                   Pragma_List : constant List_Id :=
-                    Par (Configuration_Pragmas => True);
+                                  Par (Configuration_Pragmas => True);
+
                begin
                   if Need_To_Be_In_The_Dependencies (Pragma_List) then
                      Prepcomp.Add_Dependency (Source_Config_File);
diff --git a/gcc/ada/gnat_ugn.texi b/gcc/ada/gnat_ugn.texi
index 3b0394062ea..8834bae5424 100644
--- a/gcc/ada/gnat_ugn.texi
+++ b/gcc/ada/gnat_ugn.texi
@@ -12319,24 +12319,29 @@ directory is searched for a file whose name is @file{gnat.adc}. If
 this file is present, it is expected to contain one or more
 configuration pragmas that will be applied to the current compilation.
 However, if the switch @option{-gnatA} is used, @file{gnat.adc} is not
-considered.
+considered. When taken into account, @file{gnat.adc} is added to the
+dependencies, so that if @file{gnat.adc} is modified later, an invocation of
+@command{gnatmake} will recompile the source.
 
 Configuration pragmas may be entered into the @file{gnat.adc} file
 either by running @code{gnatchop} on a source file that consists only of
-configuration pragmas, or more conveniently  by
-direct editing of the @file{gnat.adc} file, which is a standard format
-source file.
+configuration pragmas, or more conveniently by direct editing of the
+@file{gnat.adc} file, which is a standard format source file.
 
 In addition to @file{gnat.adc}, additional files containing configuration
 pragmas may be applied to the current compilation using the switch
-@option{-gnatec}@var{path}. @var{path} must designate an existing file that
+@option{-gnatec=}@var{path}. @var{path} must designate an existing file that
 contains only configuration pragmas. These configuration pragmas are
 in addition to those found in @file{gnat.adc} (provided @file{gnat.adc}
 is present and switch @option{-gnatA} is not used).
 
-It is allowed to specify several switches @option{-gnatec}, all of which
+It is allowable to specify several switches @option{-gnatec=}, all of which
 will be taken into account.
 
+Files containing configuration pragmas specified with switches
+@option{-gnatec=} are added to the dependencies, unless they contain
+only pragmas Source_File_Name_Project.
+
 If you are using project file, a separate mechanism is provided using
 project attributes, see @ref{Specifying Configuration Pragmas} for more
 details.
diff --git a/gcc/ada/prj.adb b/gcc/ada/prj.adb
index 808325e3905..becab3eb8c5 100644
--- a/gcc/ada/prj.adb
+++ b/gcc/ada/prj.adb
@@ -141,7 +141,7 @@ package body Prj is
       while Last + S'Length > To'Last loop
          declare
             New_Buffer : constant  String_Access :=
-                           new String (1 .. 2 * Last);
+                           new String (1 .. 2 * To'Length);
 
          begin
             New_Buffer (1 .. Last) := To (1 .. Last);
diff --git a/gcc/ada/sem_aggr.adb b/gcc/ada/sem_aggr.adb
index 1f72ed9f555..157b2024149 100644
--- a/gcc/ada/sem_aggr.adb
+++ b/gcc/ada/sem_aggr.adb
@@ -1055,6 +1055,10 @@ package body Sem_Aggr is
             --  formal parameter. Consequently we also need to test for
             --  N_Procedure_Call_Statement or N_Function_Call.
 
+            --  The context may be an N_Reference node, created by expansion.
+            --  Legality of the others clause was established in the source,
+            --  so the context is legal.
+
             Set_Etype (N, Aggr_Typ);  --  May be overridden later on
 
             if Pkind = N_Assignment_Statement
@@ -1070,6 +1074,7 @@ package body Sem_Aggr is
                            Pkind = N_Component_Declaration     or else
                            Pkind = N_Parameter_Specification   or else
                            Pkind = N_Qualified_Expression      or else
+                           Pkind = N_Reference                 or else
                            Pkind = N_Aggregate                 or else
                            Pkind = N_Extension_Aggregate       or else
                            Pkind = N_Component_Association))
diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb
index 0a75c5cad24..b94a1f2f1f0 100644
--- a/gcc/ada/sem_ch3.adb
+++ b/gcc/ada/sem_ch3.adb
@@ -3493,7 +3493,21 @@ package body Sem_Ch3 is
          --  early usage within E is properly diagnosed.
 
          Set_Etype (Id, T);
-         Resolve (E, T);
+
+         --  If the expression is an aggregate we must look ahead to detect
+         --  the possible presence of an address clause, and defer resolution
+         --  and expansion of the aggregate to the freeze point of the entity.
+
+         if Comes_From_Source (N)
+           and then Expander_Active
+           and then Has_Following_Address_Clause (N)
+           and then Nkind (E) = N_Aggregate
+         then
+            Set_Etype (E, T);
+
+         else
+            Resolve (E, T);
+         end if;
 
          --  No further action needed if E is a call to an inlined function
          --  which returns an unconstrained type and it has been expanded into
diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb
index e8051e7dce2..f559ec3b6d3 100644
--- a/gcc/ada/sem_res.adb
+++ b/gcc/ada/sem_res.adb
@@ -4044,35 +4044,29 @@ package body Sem_Res is
                return;
             end if;
 
-            --  Apply appropriate range checks for in, out, and in-out
-            --  parameters. Out and in-out parameters also need a separate
-            --  check, if there is a type conversion, to make sure the return
-            --  value meets the constraints of the variable before the
-            --  conversion.
-
-            --  Gigi looks at the check flag and uses the appropriate types.
-            --  For now since one flag is used there is an optimization which
-            --  might not be done in the In Out case since Gigi does not do
-            --  any analysis. More thought required about this ???
+            --  Apply appropriate constraint/predicate checks for IN [OUT] case
 
             if Ekind_In (F, E_In_Parameter, E_In_Out_Parameter) then
 
-               --  Apply predicate checks, unless this is a call to the
-               --  predicate check function itself, which would cause an
-               --  infinite recursion, or it is a call to an initialization
-               --  procedure whose operand is of course an unfinished object.
+               --  Apply predicate tests except in certain special cases. Note
+               --  that it might be more consistent to apply these only when
+               --  expansion is active (in Exp_Ch6.Expand_Actuals), as we do
+               --  for the outbound predicate tests.
 
-               if not (Ekind (Nam) = E_Function
-                        and then (Is_Predicate_Function (Nam)
-                                    or else
-                                  Is_Predicate_Function_M (Nam)))
-                 and then not Is_Init_Proc (Nam)
-               then
+               if not No_Predicate_Test_On_Arguments (Nam) then
                   Apply_Predicate_Check (A, F_Typ);
                end if;
 
                --  Apply required constraint checks
 
+               --  Gigi looks at the check flag and uses the appropriate types.
+               --  For now since one flag is used there is an optimization
+               --  which might not be done in the IN OUT case since Gigi does
+               --  not do any analysis. More thought required about this ???
+
+               --  In fact is this comment obsolete??? doesn't the expander now
+               --  generate all these tests anyway???
+
                if Is_Scalar_Type (Etype (A)) then
                   Apply_Scalar_Range_Check (A, F_Typ);
 
@@ -4138,7 +4132,13 @@ package body Sem_Res is
                end if;
             end if;
 
+            --  Checks for OUT parameters and IN OUT parameters
+
             if Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter) then
+
+               --  If there is a type conversion, to make sure the return value
+               --  meets the constraints of the variable before the conversion.
+
                if Nkind (A) = N_Type_Conversion then
                   if Is_Scalar_Type (A_Typ) then
                      Apply_Scalar_Range_Check
@@ -4148,6 +4148,9 @@ package body Sem_Res is
                        (Expression (A), Etype (Expression (A)), A_Typ);
                   end if;
 
+               --  If no conversion apply scalar range checks and length checks
+               --  base on the subtype of the actual (NOT that of the formal).
+
                else
                   if Is_Scalar_Type (F_Typ) then
                      Apply_Scalar_Range_Check (A, A_Typ, F_Typ);
@@ -4159,6 +4162,10 @@ package body Sem_Res is
                      Apply_Range_Check (A, A_Typ, F_Typ);
                   end if;
                end if;
+
+               --  Note: we do not apply the predicate checks for the case of
+               --  OUT and IN OUT parameters. They are instead applied in the
+               --  Expand_Actuals routine in Exp_Ch6.
             end if;
 
             --  An actual associated with an access parameter is implicitly
diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb
index fd7fbea627a..e8131cb4031 100644
--- a/gcc/ada/sem_util.adb
+++ b/gcc/ada/sem_util.adb
@@ -13785,6 +13785,44 @@ package body Sem_Util is
       Actual_Id := Next_Actual (Actual_Id);
    end Next_Actual;
 
+   ------------------------------------
+   -- No_Predicate_Test_On_Arguments --
+   ------------------------------------
+
+   function No_Predicate_Test_On_Arguments (Subp : Entity_Id) return Boolean is
+   begin
+      --  Do not test predicates on call to generated default Finalize, since
+      --  we are not interested in whether something we are finalizing (and
+      --  typically destroying) satisfies its predicates.
+
+      if Chars (Subp) = Name_Finalize
+        and then not Comes_From_Source (Subp)
+      then
+         return True;
+
+      --  Do not test predicates on call to Init_Proc, since if needed the
+      --  predicate test will occur at some other point.
+
+      elsif Is_Init_Proc (Subp) then
+         return True;
+
+      --  Do not test predicates on call to predicate function, since this
+      --  would cause infinite recursion.
+
+      elsif Ekind (Subp) = E_Function
+        and then (Is_Predicate_Function (Subp)
+                    or else
+                  Is_Predicate_Function_M (Subp))
+      then
+         return True;
+
+      --  For now, no other cases
+
+      else
+         return False;
+      end if;
+   end No_Predicate_Test_On_Arguments;
+
    ---------------------
    -- No_Scalar_Parts --
    ---------------------
diff --git a/gcc/ada/sem_util.ads b/gcc/ada/sem_util.ads
index 6a0e126888a..62d995e422d 100644
--- a/gcc/ada/sem_util.ads
+++ b/gcc/ada/sem_util.ads
@@ -1582,6 +1582,11 @@ package Sem_Util is
    --  Note that the result produced is always an expression, not a parameter
    --  association node, even if named notation was used.
 
+   function No_Predicate_Test_On_Arguments (Subp : Entity_Id) return Boolean;
+   --  Subp is the entity for a subprogram call. This function returns True to
+   --  eliminate predicate tests on the input or output arguments in a call to
+   --  this subprogram. See body for exact cases currently covered.
+
    function No_Scalar_Parts (T : Entity_Id) return Boolean;
    --  Tests if type T can be determined at compile time to have no scalar
    --  parts in the sense of the Valid_Scalars attribute. Returns True if