2018-07-17  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* checks.adb (Apply_Division_Check): Add provision for floating-point
	checks.

From-SVN: r262801

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_aggr.adb (Component_OK_For_Backend): If an array component of the
	enclosing record has a bound that is out of range (and that has been
	rewritten as a raise statement) the aggregate is not OK for any back
	end, and should be expanded into individual assignments.

From-SVN: r262800

Semantics not affected; the reused routine is exactly the same as the replaced
condition.

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* atree.adb (Relocate_Node): Simplify with Is_Rewrite_Substitution.

From-SVN: r262799

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* sem_util.ads (Denotes_Same_Object): Likewise.
	* sem_warn.adb (Warn_On_Overlapping_Actuals): Fix RM rule references.

From-SVN: r262798

The pragma Default_Scalar_Storage_Order cannot reliably be used to set the
non-default scalar storage order for a program that declares tagged types, if
it also declares user-defined primitives.

This is fixed by making Make_Tags use the same base array type as Make_DT and
Make_Secondary_DT when accessing the array of user-defined primitives.

2018-07-17  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* exp_disp.adb (Make_Tags): When the type has user-defined primitives,
	build the access type that is later used by Build_Get_Prim_Op_Address
	as pointing to a subtype of Ada.Tags.Address_Array.

gcc/testsuite/

	* gnat.dg/sso10.adb, gnat.dg/sso10_pkg.ads: New testcase.

From-SVN: r262797

This patch switches mingw32 targets to use the standard version of s-memory.adb
as Windows now has the capability of limiting the amount of memory used by
process.

2018-07-17  Patrick Bernardi  <bernardi@adacore.com>

gcc/ada/

	* libgnat/s-memory__mingw.adb: Remove.
	* Makefile.rtl: Remove s-memory.adb target pair from the Cygwin/Mingw32
	section.

gcc/testsuite/

	* gnat.dg/memorytest.adb: New testcase.

From-SVN: r262796

This patch ensures that removal of ignored Ghost code is the absolute last
operation performed on the tree. Previously the removal was performed prior to
issuing delayed warnings, however the warning mechanism may see a heavily
modified tree and fail.

No small reproducer available.

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* frontend.adb (Frontend): The removal of ignored Ghost code must be
	the last semantic operation performed on the tree.

From-SVN: r262795

This patch ensures that the processing of instantiated and inlined bodies uses
the proper configuration context available at the point of the instantiation or
inlining.

Previously configuration pragmas which appear prior to the context items of a
unit would lose their effect when a body is instantiated or inlined.

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* frontend.adb (Frontend): Update the call to Register_Config_Switches.
	* inline.ads: Add new component Config_Switches to record
	Pending_Body_Info which captures the configuration state of the pending
	body.  Remove components Version, Version_Pragma, SPARK_Mode, and
	SPARK_Mode_Pragma from record Pending_Body_Info because they are
	already captured in component Config_Switches.
	* opt.adb (Register_Opt_Config_Switches): Rename to
	Register_Config_Switches.
	(Restore_Opt_Config_Switches): Rename to Restore_Config_Switches.
	(Save_Opt_Config_Switches): Rename to Save_Config_Switches. This
	routine is now a function, and returns the saved configuration state as
	an aggregate to avoid missing an attribute.
	(Set_Opt_Config_Switches): Rename to Set_Config_Switches.
	* opt.ads (Register_Opt_Config_Switches): Rename to
	Register_Config_Switches.
	(Restore_Opt_Config_Switches): Rename to Restore_Config_Switches.
	(Save_Opt_Config_Switches): Rename to Save_Config_Switches. This
	routine is now a function.
	(Set_Opt_Config_Switches): Rename to Set_Config_Switches.
	* par.adb (Par): Update the calls to configuration switch-related
	subprograms.
	* sem.adb (Semantics): Update the calls to configuration switch-related
	subprograms.
	* sem_ch10.adb (Analyze_Package_Body_Stub): Update the calls to
	configuration switch-related subprograms.
	(Analyze_Protected_Body_Stub): Update the calls to configuration
	switch-related subprograms.
	(Analyze_Subprogram_Body_Stub): Update calls to configuration
	switch-related subprograms.
	* sem_ch12.adb (Add_Pending_Instantiation): Update the capture of
	pending instantiation attributes.
	(Inline_Instance_Body): Update the capture of pending instantiation
	attributes.  It is no longer needed to explicitly manipulate the SPARK
	mode.
	(Instantiate_Package_Body): Update the restoration of the context
	attributes.
	(Instantiate_Subprogram_Body): Update the restoration of context
	attributes.
	(Load_Parent_Of_Generic): Update the capture of pending instantiation
	attributes.
	(Set_Instance_Env): Update the way relevant configuration attributes
	are saved and restored.

gcc/testsuite/

	* gnat.dg/config_pragma1.adb, gnat.dg/config_pragma1_pkg.ads: New testcase.

From-SVN: r262794

2018-07-17  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Variable>: Deal with
	more rvalues in the expression of a renaming.

From-SVN: r262793

2018-07-17  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* gcc-interface/ada-tree.h (TYPE_RETURN_BY_DIRECT_REF_P): Define for
	METHOD_TYPE too.
	(TYPE_RETURN_UNCONSTRAINED_P): Likewise.
	(TYPE_CI_CO_LIST): Likewise.
	* gcc-interface/gigi.h (is_cplusplus_method): Delete.
	(fntype_same_flags_p): Adjust comment.
	* gcc-interface/decl.c (Has_Thiscall_Convention): Delete.
	(gnat_to_gnu_entity) <E_Subprogram_Type>: Do not set the "thiscall"
	attribute directly.
	(is_cplusplus_method): Make static and adjust head comment.
	(gnat_to_gnu_param): Return a pointer for the "this" parameter of
	C++ constructors.
	(gnat_to_gnu_subprog_type): Turn imported C++ constructors into their
	callable form.  Generate a METHOD_TYPE node for imported C++ methods.
	Set param_list at the very end of the processing.
	(substitute_in_type) <METHOD_TYPE>: New case.
	* gcc-interface/misc.c (gnat_print_type) <METHOD_TYPE>: Likewise.
	(gnat_type_hash_eq): Accept METHOD_TYPE.
	* gcc-interface/trans.c (Identifier_to_gnu): Deal with METHOD_TYPE.
	(Attribute_to_gnu): Likewise.
	(Call_to_gnu): Likewise.
	(process_freeze_entity): Likewise.
	* gcc-interface/utils.c (create_subprog_decl): Adjust head comment.
	(fntype_same_flags_p): Likewise.

From-SVN: r262792

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* inline.adb (Expand_Inlined_Call): Remove extra parentheses.

From-SVN: r262791

C++ constructors are imported as functions and then internally rewritten into
procedures taking the "this" pointer as first parameter.  Now this parameter is
not of an access type but of the type directly, so it must be In/Out and not
just In.

2018-07-17  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* exp_disp.adb (Gen_Parameters_Profile): Make the _Init parameter an
	In/Out parameter.
	(Set_CPP_Constructors): Adjust comment accordingly.

From-SVN: r262790

This patch fixes the compiler to that class-wide preconditions on primitive
operations of interfaces are not checked at run time when the Assertion_Policy
indicates that they should be ignored. This is required by the RM.

2018-07-17  Bob Duff  <duff@adacore.com>

gcc/ada/

	* exp_disp.adb (Build_Class_Wide_Check): Return early if the
	precondition is supposed to be ignored.

From-SVN: r262789

In Ada2012 it is illegal to declare an equality operation on an untagged
type when the operation is primitive and the type is already frozem (see
RM 4.5.2 (9.8)). previously the test to detect this illegality only examined
declarations within a package. This patch covers the case where type and
operation are both declared within a subprogram body.

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_ch6.adb (Check_Untagged_Equality): Extend check to operations
	declared in the same scope as the operand type, when that scope is a
	procedure.

gcc/testsuite/

	* gnat.dg/equal3.adb: New testcase.

From-SVN: r262788

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_unst.adb (Unnest_Subprograms): Do nothing if the expander is not
	active.  Don't use Get_Actual_Subtype for record subtypes.  Ignore
	rewritten identifiers and uplevel references to bounds of types that
	come from the original type reference.

From-SVN: r262787

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* exp_ch13.adb, exp_ch7.adb, exp_unst.adb, freeze.adb,
	libgnat/s-os_lib.adb, sem_ch3.adb, sem_ch3.ads, sem_ch5.adb,
	sem_eval.adb, sem_res.adb, sem_util.adb: Minor reformatting.

From-SVN: r262786

The compiler may crash processing an aspect Part_Of used in a
package spec which has also an Initial_Condition aspect. After
this patch the following test compiles fine.

package P
with
  SPARK_Mode => On,
  Abstract_State => (Count_State),
  Initial_Condition => (Get_Count = 0)              -- Test
is
   type Count_Type is range 0 .. 16;

   function Get_Count return Count_Type;

   procedure Dummy;

private
   C: Count_Type := 0 with Part_Of => Count_State;  -- Test

   function Get_Count return Count_Type is (C);
end P;

package body P
with
  SPARK_Mode => On,
  Refined_State => (Count_State => C)
is
  procedure Dummy is null;
end P;

Command: gcc -c p.adb

2018-07-17  Javier Miranda  <miranda@adacore.com>

gcc/ada/

	* exp_ch13.adb (Expand_N_Freeze_Entity): Handle subtype declared for an
	iterator.
	* freeze.adb (Freeze_Expression): Handle freeze of an entity defined
	outside of a subprogram body. This case was previously handled during
	preanalysis; the frozen entities were remembered and left pending until
	we continued freezeing entities outside of the subprogram. Now, when
	climbing the parents chain to locate the correct placement for the
	freezeing node, we check if the entity can be frozen and only when no
	enclosing node is marked as Must_Not_Freeze the entity is frozen.
	* sem_ch3.ads (Preanalyze_Default_Expression): Declaration moved to the
	package body.
	* sem_ch3.adb (Preanalyze_Default_Expression): Code adjusted to invoke
	the new subprogram Preanalyze_With_Freezing_And_Resolve.
	* sem_ch6.adb (Preanalyze_Formal_Expression): New subprogram.
	(Analyze_Expression_Function, Process_Formals): Invoke
	Preanalyze_Formal_Expression instead of Preanalyze_Spec_Expression
	since the analysis of the formals may freeze entities.
	(Analyze_Subprogram_Body_Helper): Skip building the body of the
	class-wide clone for eliminated subprograms.
	* sem_res.ads, sem_res.adb (Preanalyze_And_Resolve): New subprogram.
	Its code is basically the previous version of this routine but extended
	with an additional parameter which is used to specify if during
	preanalysis we are allowed to freeze entities.  If the new parameter is
	True then the subtree root node is marked as Must_Not_Freeze and no
	entities are frozen during preanalysis.
	(Preanalyze_And_Resolve): Invokes the internal version of
	Preanalyze_And_Resolve without entity freezing.
	(Preanalyze_With_Freezing_And_Resolve): Invokes the internal version of
	Prenalyze_And_Resolve with freezing enabled.

From-SVN: r262785

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* einfo.ads, libgnat/g-comlin.ads: Minor change "ie" to "i.e." in docs
	and comments.

From-SVN: r262784

This patch corrects an issue whereby leading whitespace in a non-quoted
argument list passed to Argument_String_To_List caused extraneous empty
arguments to be returned.

2018-07-17  Justin Squirek  <squirek@adacore.com>

gcc/ada/

	* libgnat/s-os_lib.adb (Argument_String_To_List): Fix trimming of
	whitespace.

gcc/testsuite/

	* gnat.dg/split_args.adb: New testcase.

From-SVN: r262783

This patch modifies the verification of a missing Part_Of indicator to avoid
considering constants as visible state of a package instantiation because the
compiler cannot determine whether their values depend on variable input. This
diagnostic is left to GNATprove.

------------
-- Source --
------------

--  gnat.adc

pragma SPARK_Mode;

--  gen_pack.ads

generic
package Gen_Pack is
   Val : constant Integer := 123;
end Gen_Pack;

--  pack.ads

with Gen_Pack;

package Pack
  with Abstract_State => Pack_State
is
   procedure Force_Body;
private
   package Inst_1 is new Gen_Pack;                                   --  OK
   package Inst_2 is new Gen_Pack with Part_Of => Pack_State;        --  OK
end Pack;

--  pack.adb

package body Pack
  with Refined_State => (Pack_State => Inst_2.Val)
is
   procedure Force_Body is null;
end Pack;

-----------------
-- Compilation --
-----------------

$ gcc -c pack.adb

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* sem_prag.adb (Has_Visible_State): Do not consider constants as
	visible state because it is not possible to determine whether a
	constant depends on variable input.
	(Propagate_Part_Of): Add comment clarifying the behavior with respect
	to constant.

From-SVN: r262782

When compiling with the restriction No_Exception_Propagation, GNAT compiler
may issue a warning about exceptions not being propagated. This warning is
useless and confusing to users for GNATprove analysis, as GNATprove
precisely detects possible exceptions, so disable the warning in that mode.

2018-07-17  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* gnat1drv.adb (Gnat1drv): Do not issue warning about exception not
	being propagated in GNATprove mode.

From-SVN: r262781

2018-07-17  Dmitriy Anisimkov  <anisimko@adacore.com>

gcc/ada/

	* libgnat/g-socket.adb, libgnat/g-socket.ads: Reorganize and make
	public components of Inet_Addr_Type. Introduce public binary
	operations.

From-SVN: r262780

When a loop iterator has a block declaration containing statements that invoke
functions whose result is returned on the secondary stack (such as a
string-returning function), the compiler fails to generate code to release the
allocated memory when the loop terminates.

After this patch the following test works fine.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
pragma Warnings (Off);
with System.Secondary_Stack;
pragma Warnings (On);

procedure Small is
   procedure Info is new System.Secondary_Stack.Ss_Info (Put_Line);

   US : Unbounded_String;
begin
   Info;
   for J in 1 .. 100_000 loop
      Leaky_Block : declare
      begin
         if (J mod 20000) = 0 then
            Info;
         end if;

         Ada.Text_IO.Put_Line (To_String (US));  --  Test

         if (J mod 20000) = 0 then
            Info;
         end if;
      end Leaky_Block;
   end loop;
   Info;
end;

Command:
  gnatmake small.adb; small | grep "Current allocated space :" | uniq
Output:
  Current allocated space :  0 bytes

2018-07-17  Javier Miranda  <miranda@adacore.com>

gcc/ada/

	* exp_ch7.adb (Make_Transient_Block): When determining whether an
	enclosing scope already handles the secondary stack, take into account
	transient blocks nested in a block that do not manage the secondary
	stack and are located within a loop.

From-SVN: r262779

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_util.adb (Enclosing_Subprogram): Protected entries and task
	entries must be treated separately: task entries are within the
	enclosing subprogram of the task type, while protected entries are
	transformed into the corresponding Protected_Body_Subprogram, which is
	the enclosing_subprogram of any subprogram declared within the entry
	body.

From-SVN: r262778

This patch adds compiler switches -gnatH and -gnatJ to section "Alphabetical
list of all switches" of the GNAT User Guide for Native.

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* doc/gnat_ugn/building_executable_programs_with_gnat.rst: Add missing
	sections on -gnatH and -gnatJ compiler switches.
	* gnat_ugn.texi: Regenerate.

From-SVN: r262777

	PR middle-end/86539
	* gimplify.c (gimplify_omp_for): Ensure taskloop firstprivatized init
	and cond temporaries don't have reference type if iterator has
	pointer type.  For init use &for_pre_body instead of pre_p if
	for_pre_body is non-empty.

	* testsuite/libgomp.c++/pr86539.C: New test.

From-SVN: r262776

This patch reimplements the mechanism which removes ignored Ghost code from the
tree.

The previous mechanism proved to be unreliable because it assumed that no new
scoping constructs would be created after some ignored Ghost code had already
notified its enclosing scoping constructs that they contain such code. The
assumption can be broken by having a call to an ignored Ghost procedure within
the extended return statement of a function. The procedure call would signal
the enclosing function that it contains ignored Ghost code, however the return
statement would introduce an extra block, effectively hiding the procedure call
from the ignored Ghost code elimination pass.

The new mechanism implemented in this patch forgoes directed tree pruning in
favor of storing the actual ignored Ghost code, and later directly eliminating
it from the tree.

For this approach to operate efficiently, only "top level" ignored Ghost
constructs are stored. The top level constructs are essentially nodes which can
appear within a declarative or statement list and be safely rewritten into null
statements. This ensures that only "root" ignored Ghost construct need to be
processed, as opposed to all ignored Ghost nodes within a subtree.

The approach has one drawback however. Due to the generation and analysis of
ignored Ghost code, a construct may be recorded multiple times (usually twice).
The mechanism simply deals with this artefact instead of employing expensive
solutions such as hash tables or a common flag shared by all nodes to eliminate
the duplicates.

------------
-- Source --
------------

--  main.adb

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   procedure Ghost_Proc with Ghost;
   procedure Ghost_Proc is
   begin
      Put_Line ("ERROR: Ghost_Proc called");
   end Ghost_Proc;

   function Func return Integer is
   begin
      return Res : Integer := 123 do
         Ghost_Proc;
      end return;
   end Func;

   Val : Integer with Ghost;

begin
   Val := Func;
end Main;

----------------------------
-- Compilation and output --
----------------------------

$ gcc -c -gnatDG main.adb
$ grep -c "ghost" main.adb.dg
0

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* alloc.ads: Update the allocation metrics of the ignored Ghost nodes
	table.
	* atree.adb: Add a soft link for a procedure which is invoked whenever
	an ignored Ghost node or entity is created.
	(Change_Node): Preserve relevant attributes which come from the Flags
	table.
	(Mark_New_Ghost_Node): Record a newly created ignored Ghost node or
	entity.
	(Rewrite): Preserve relevant attributes which come from the Flags
	table.
	(Set_Ignored_Ghost_Recording_Proc): New routine.
	* atree.ads: Define an access-to-suprogram type for a soft link which
	records a newly created ignored Ghost node or entity.
	(Set_Ignored_Ghost_Recording_Proc): New routine.
	* ghost.adb: Remove with and use clause for Lib.  Remove table
	Ignored_Ghost_Units.  Add new table Ignored_Ghost_Nodes.
	(Add_Ignored_Ghost_Unit): Removed.
	(Initialize): Initialize the table which stores ignored Ghost nodes.
	Set the soft link which allows Atree.Mark_New_Ghost_Node to record an
	ignored Ghost node.
	(Is_Ignored_Ghost_Unit): Use the ultimate original node when checking
	an eliminated ignored Ghost unit.
	(Lock): Release and lock the table which stores ignored Ghost nodes.
	(Mark_And_Set_Ghost_Assignment): Record rather than propagate ignored
	Ghost nodes.
	(Mark_And_Set_Ghost_Procedure_Call): Record rather than propagate
	ignored Ghost nodes.
	(Mark_Ghost_Clause): Record rather than propagate ignored Ghost nodes.
	(Mark_Ghost_Declaration_Or_Body): Record rather than propagate ignored
	Ghost nodes.
	(Mark_Ghost_Pragma): Record rather than propagate ignored Ghost nodes.
	(Propagate_Ignored_Ghost_Code): Removed.
	(Record_Ignored_Ghost_Node): New routine.
	(Remove_Ignored_Ghost_Code): Reimplemented.
	(Remove_Ignored_Ghost_Node): New routine.
	(Ultimate_Original_Node): New routine.
	* ghost.ads (Check_Ghost_Completion): Removed.
	* sem_ch8.adb (Analyze_Use_Package): Remove obsolete code. Mark a use
	package clause as ignored Ghost if applicable.
	* sem_util.adb (Is_Body_Or_Package_Declaration): Reimplemented.

From-SVN: r262775

When the evaluation of the loop iterator invokes a function whose
result relies on the secondary stack the compiler does not generate
code to release the consumed memory as soon as the loop terminates.

After this patch the following test works fine.

with Text_IO; use Text_IO;
pragma Warnings (Off);
with System.Secondary_Stack;
pragma Warnings (On);
procedure Sec_Stack_Leak is
   function F (X : String) return Integer is
   begin
      return 10;
   end F;

   function G (X : Integer) return String is
   begin
      return (1 .. X => 'x');
   end G;

   procedure Info is new System.Secondary_Stack.Ss_Info (Put_Line);

   procedure Nest is
   begin
      for I in Integer range 1 .. 100 loop
         for J in Integer range 1 .. F (G (10_000)) loop
            null;
         end loop;
         Info;
      end loop;
      Info;
   end Nest;

begin
   Info;
   Nest;
   Info;
end Sec_Stack_Leak;

Commands:
  gnatmake -q sec_stack_leak.adb
  sec_stack_leak | grep "Current allocated space :" | uniq
Output:
  Current allocated space :  0 bytes

2018-07-17  Javier Miranda  <miranda@adacore.com>

gcc/ada/

	* sem_ch5.adb (Has_Call_Using_Secondary_Stack): Moved to library level
	to reuse it.
	(Analyze_Loop_Statement): Wrap the loop in a block when the evaluation
	of the loop iterator relies on the secondary stack.

From-SVN: r262774

The GNATprove backend needs to apply antialiasing checks to subprogram
calls that have been rewritten into null statements while "inlining for
proof". This requires the First_Actual/Next_Actual to use the Original_Node
and not the N_Null_Statement that rewriting leaves as a parent.

Only effective in GNATprove mode, so no frontend test provided.

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* sem_util.adb (Next_Actual): If the parent is a N_Null_Statement,
	which happens for inlined calls, then fetch the next actual from the
	original AST.

From-SVN: r262773

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* einfo.ads: Update documentation for Scalar_Range.

From-SVN: r262772

In GNATprove mode we use frontend cross-references to synthesize the
Global contract of subprograms with SPARK_Mode => Off and represent
a read/write via a pointer as a read/write of a special entity called
HEAP. This entity is now attached to the Standard package, so that we can
safely check the Ekind of its Scope, which now happens in Scope_Within.

This only affects GNATprove, so no frontend test provided.

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* lib-xref-spark_specific.adb (Create_Heap): Attach the HEAP entity to
	the Standard package.

From-SVN: r262771

2018-07-17  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* einfo.adb (Is_Wrapper_Package): Remove extra parentheses.

From-SVN: r262770

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_util.adb (Enclosing_Subprogram): Handle properly entries, and
	synchronized types that are completions of limited types or private
	extensions.
	(Scope_Within): Handle properly accept statements in task bodies.

From-SVN: r262769

This patch updates the analysis of indicator Part_Of (or the lack thereof), to
ignore generic formal parameters for purposes of determining the visible state
space because they are not visible outside the generic and related instances.

------------
-- Source --
------------

--  gen_pack.ads

generic
   In_Formal     : in     Integer := 0;
   In_Out_Formal : in out Integer;

package Gen_Pack is
   Exported_In_Formal     : Integer renames In_Formal;
   Exported_In_Out_Formal : Integer renames In_Out_Formal;

end Gen_Pack;

--  pack.ads

with Gen_Pack;

package Pack
  with Abstract_State => State
is
   procedure Force_Body;

   Val : Integer;

private
   package OK_1 is
     new Gen_Pack (In_Out_Formal => Val)
   with Part_Of => State;                                            --  OK

   package OK_2 is
     new Gen_Pack (In_Formal => 1, In_Out_Formal => Val)
   with Part_Of => State;                                            --  OK

   package Error_1 is                                                --  Error
     new Gen_Pack (In_Out_Formal => Val);
   package Error_2 is                                                --  Error
     new Gen_Pack (In_Formal => 2, In_Out_Formal => Val);
end Pack;

--  pack.adb

package body Pack
  with Refined_State =>                                              --  Error
         (State => (OK_1.Exported_In_Formal,
                    OK_1.Exported_In_Out_Formal))
is
   procedure Force_Body is null;
end Pack;

--  gen_pack.ads

generic
   In_Formal     : in     Integer := 0;
   In_Out_Formal : in out Integer;

package Gen_Pack is
   Exported_In_Formal     : Integer renames In_Formal;
   Exported_In_Out_Formal : Integer renames In_Out_Formal;

end Gen_Pack;

--  pack.ads

with Gen_Pack;

package Pack
  with Abstract_State => State
is
   procedure Force_Body;

   Val : Integer;

private
   package OK_1 is
     new Gen_Pack (In_Out_Formal => Val)
   with Part_Of => State;                                            --  OK

   package OK_2 is
     new Gen_Pack (In_Formal => 1, In_Out_Formal => Val)
   with Part_Of => State;                                            --  OK

   package Error_1 is                                                --  Error
     new Gen_Pack (In_Out_Formal => Val);
   package Error_2 is                                                --  Error
     new Gen_Pack (In_Formal => 2, In_Out_Formal => Val);
end Pack;

--  pack.adb

package body Pack
  with Refined_State =>                                              --  Error
         (State => (OK_1.Exported_In_Formal,
                    OK_1.Exported_In_Out_Formal))
is
   procedure Force_Body is null;
end Pack;

----------------------------
-- Compilation and output --
----------------------------

$ gcc -c pack.adb
pack.adb:3:11: state "State" has unused Part_Of constituents
pack.adb:3:11: constant "Exported_In_Formal" defined at gen_pack.ads:6,
  instance at pack.ads:15
pack.adb:3:11: variable "Exported_In_Out_Formal" defined at gen_pack.ads:7,
  instance at pack.ads:15
pack.ads:19:12: indicator Part_Of is required in this context (SPARK RM
  7.2.6(2))
pack.ads:19:12: "Error_1" is declared in the private part of package "Pack"
pack.ads:21:12: indicator Part_Of is required in this context (SPARK RM
  7.2.6(2))
pack.ads:21:12: "Error_2" is declared in the private part of package "Pack"

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* sem_prag.adb (Has_Visible_State): Do not consider generic formals
	because they are not part of the visible state space. Add constants to
	the list of acceptable visible states.
	(Propagate_Part_Of): Do not consider generic formals when propagating
	the Part_Of indicator.
	* sem_util.adb (Entity_Of): Do not follow renaming chains which go
	through a generic formal because they are not visible for SPARK
	purposes.
	* sem_util.ads (Entity_Of): Update the comment on usage.

From-SVN: r262768

2018-07-17  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_util.adb (Gather_Components): A discriminant of an ancestor may
	have been constrained by a later ancestor, so when looking for the
	value of that hidden discriminant we must examine the stored constraint
	of other ancestors than the immediate parent type.

gcc/testsuite/

	* gnat.dg/discr54.adb, gnat.dg/discr54_pkg.ads: New testcase.

From-SVN: r262767

This patch modifies the recursive tree replication routine New_Copy_Tree to
create new entities and remap old entities to the new ones for constructs in
N_Expression_With_Actions nodes when requested by a caller. This in turn allows
the build-in-place mechanism to avoid sharing entities between the 4 variants
of returns it generates.

2018-07-17  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* exp_ch6.adb (Build_Heap_Or_Pool_Allocator): Ensure that scoping
	constructs and entities within receive new entities when replicating a
	tree.
	(Expand_N_Extended_Return_Statement): Ensure that scoping constructs
	and entities within receive new entities when replicating a tree.
	* sem_util.adb (New_Copy_Tree): Add new formal Scopes_In_EWA_OK.
	(Visit_Entity): Visit entities within scoping constructs inside
	expression with actions nodes when requested by the caller. Add blocks,
	labels, and procedures to the list of entities which need replication.
	* sem_util.ads (New_Copy_Tree): Add new formal Scopes_In_EWA_OK. Update
	the comment on usage.

gcc/testsuite/

	* gnat.dg/bip_case_expr.adb, gnat.dg/bip_case_expr_pkg.ads: New testcase.

From-SVN: r262766

2018-07-17  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* doc/gnat_ugn/about_this_guide.rst,
	doc/gnat_ugn/gnat_and_program_execution.rst: Remove references to gcov.
	* gnat_ugn.texi: Regenerate.

From-SVN: r262765

From-SVN: r262764

gcc/testsuite/ChangeLog:

2018-07-16  Carl Love  <cel@us.ibm.com>

Forgot the PR number on the commit log.
PR target/86414

       2018-07-16  Carl Love  <cel@us.ibm.com>

 	PR target/86414
	* gcc.target/powerpc/divkc3-2.c: Add dg-require-effective-target
	longdouble128.
	* gcc.target/powerpc/divkc3-3.c: Ditto.
 	* gcc.target/powerpc/mulkc3-2.c: Ditto.
	* gcc.target/powerpc/mulkc3-3.c: Ditto.
	* gcc.target/powerpc/fold-vec-mergehl-double.c: Update counts.
	* gcc.target/powerpc/pr85456.c: Make check Linux and AIX specific.

From-SVN: r262758

This tests the generated code for all conversions between floating point
point types, binary and decimal.


gcc/testsuite/
	* gcc.target/powerpc/convert-fp-128.c: New testcase.
	* gcc.target/powerpc/convert-fp-64.c: New testcase.

From-SVN: r262757