ada-tree.h (TYPE_RETURN_BY_DIRECT_REF_P): Change from using TYPE_LANG_FLAG_4 to using TYPE_LANG_FLAG_0.

	* gcc-interface/ada-tree.h (TYPE_RETURN_BY_DIRECT_REF_P): Change from
	using TYPE_LANG_FLAG_4 to using TYPE_LANG_FLAG_0.
	(TYPE_ALIGN_OK): Move around.
	(TYPE_PADDING_FOR_COMPONENT): Remove superfluous parentheses.
	* gcc-interface/decl.c (change_qualified_type): Move to...
	(gnat_to_gnu_entity): Adjust comment.
	* gcc-interface/gigi.h (change_qualified_type): ...here; make inline.
	(ceil_pow2): Use ceil_log2.
	* gcc-interface/utils.c (finish_subprog_decl): Add couple of comments
	and do not set TREE_SIDE_EFFECTS.
	(handle_noreturn_attribute): Use change_qualified_type.

From-SVN: r261486

decl.c (gnat_to_gnu_entity): Do not get the expression of a dispatch table that is not being defined.

	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Constant>: Do not get
	the expression of a dispatch table that is not being defined.
	<E_Record_Subtype>: Remove obsolete kludge.

From-SVN: r261483

	* gcc-interface/decl.c (warn_on_field_placement): Use specific wording
	for discriminants.
	(warn_on_list_placement): New static function.
	(components_to_record): Use it to warn on multiple fields in list.

From-SVN: r261480

	* gcc-interface/decl.c (variant_desc): Add AUX field.
	(gnat_to_gnu_entity) <discrete_type>: Do not call compute_record_mode
	directly.
	(reverse_sort_field_list): New static function.
	(components_to_record): Place the variant part at the beginning of the
	field list when there is an obvious order of increasing position.
	(build_variant_list): Initialize it.
	(create_variant_part_from): Do not call compute_record_mode directly.
	(copy_and_substitute_in_layout): Likewise.  Always sort the fields with
	fixed position in order of increasing position, in the record and all
	the variants, in any.  Call reverse_sort_field_list.
	* gcc-interface/utils.c (make_packable_type): Compute the sizes before
	calling finish_record_type.  Do not call compute_record_mode directly.
	(finish_record_type): Overhaul final processing depending on REP_LEVEL
	and call finish_bitfield_layout if it is equal to one or two.

From-SVN: r261479

2018-06-11  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Array_Type>: Reuse the
	existing fields of a dummy fat pointer type, if any.  Clear the
	TYPE_DECL_SUPPRESS_DEBUG on the fat pointer type after completing it.

From-SVN: r261431

This patch suppresses the expansion of ignored assertion pragmas.

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* contracts.adb (Process_Body_Postconditions): Expand only checked
	postconditions.
	(Process_Contract_Cases_For): Expand only checked contract cases.
	(Process_Inherited_Preconditions): Ignored class-wide preconditions are
	partially expanded because some of their semantic checks are tied to
	the expansion.
	(Process_Preconditions_For): Expand only checked preconditions.
	(Process_Spec_Postconditions): Expand only checked preconditions.
	Ignored class-wide preconditions are partially expanded because some of
	their semantic checks are tied to the expansion.
	* exp_prag.adb (Expand_N_Pragma): Suppress the expansion of ignored
	assertion pragmas.
	* exp_util.adb (Add_Inherited_Invariants): Code clean up.
	* sem_util.adb (Propagate_Invariant_Attributes): Code clean up.

gcc/testsuite/

	* gnat.dg/assertion_policy1.adb, gnat.dg/assertion_policy1_pkg.adb,
	gnat.dg/assertion_policy1_pkg.ads: New testcase.

From-SVN: r261430

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* exp_ch9.adb, exp_unst.adb, inline.adb, libgnat/a-ciorma.adb,
	libgnat/a-ciormu.adb, libgnat/a-ciorse.adb, libgnat/a-coorma.adb,
	libgnat/a-coormu.adb, libgnat/a-coorse.adb, sem_prag.adb: Minor
	reformatting.

From-SVN: r261429

2018-06-11  Gary Dismukes  <dismukes@adacore.com>

gcc/ada/

	* exp_unst.ads, exp_unst.adb: Typo fixes and minor reformatting.

From-SVN: r261428

This patch disables a build-in-place optimization when a function returns a
limited controlled result because the optimization may violate the semantics of
finalizable types by performing illegal calls to Finalize.

In general, the optimization causes the result object of a build-in-place
function to be allocated at the caller site, with a pointer to the object
passed to the function. The function then simply initializes the caller-
allocated object.

This mode of operation however violates semantics of finalizable types when
the context of the call is allocation. The act of allocating the controlled
object at the caller site will place it on the associated access type's
finalization master. If the function fails the initialization of the object,
the malformed object will still be finalized when the finalization master
goes out of scope. This is dangerous, and must not happen.

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

--  pack.ads

with Ada.Finalization; use Ada.Finalization;

package Pack is
   type Lim_Ctrl is new Limited_Controlled with null record;
   procedure Finalize (Obj : in out Lim_Ctrl);

   type Lim_Ctrl_Ptr is access all Lim_Ctrl;

   function Make_Lim_Ctrl_Bad_Init return Lim_Ctrl;
   function Make_Lim_Ctrl_OK_Init return Lim_Ctrl;
end Pack;

--  pack.adb

with Ada.Text_IO; use Ada.Text_IO;

package body Pack is
   procedure Finalize (Obj : in out Lim_Ctrl) is
   begin
      Put_Line ("     Finalize");
   end Finalize;

   function Make_Lim_Ctrl_Bad_Init return Lim_Ctrl is
   begin
      return Result : Lim_Ctrl := raise Program_Error do
         null;
      end return;
   end Make_Lim_Ctrl_Bad_Init;

   function Make_Lim_Ctrl_OK_Init return Lim_Ctrl is
   begin
      return Result : Lim_Ctrl do
         raise Program_Error;
      end return;
   end Make_Lim_Ctrl_OK_Init;
end Pack;

--  main.adb

with Ada.Text_IO; use Ada.Text_IO;
with Pack;        use Pack;

procedure Main is
begin
   begin
      Put_Line ("1) Heap-allocated bad init");

      declare
         Obj : Lim_Ctrl_Ptr := new Lim_Ctrl'(Make_Lim_Ctrl_Bad_Init);
      begin
         Put_Line ("1) ERROR: Heap-allocated bad init: exception not raised");
      end;

   exception
      when Program_Error =>
         Put_Line ("1) Heap-allocated bad init: Program_Error raised");
      when others =>
         Put_Line ("1) ERROR: Heap-allocatd bad init: unexpected exception");
   end;

   begin
      Put_Line ("2) Stack-allocated bad init");

      declare
         Obj : Lim_Ctrl := Make_Lim_Ctrl_Bad_Init;
      begin
         Put_Line ("2) ERROR: Stack-allocated bad init: exception not raised");
      end;

   exception
      when Program_Error =>
         Put_Line ("2) Stack-allocated bad init: Program_Error raised");
      when others =>
         Put_Line ("2) ERROR: Stack-allocated bad init: unexpected exception");
   end;

   begin
      Put_Line ("3) Heap-allocated OK init");

      declare
         Obj : Lim_Ctrl_Ptr := new Lim_Ctrl'(Make_Lim_Ctrl_OK_Init);
      begin
         Put_Line ("3) ERROR: Heap-allocated OK init: exception not raised");
      end;

   exception
      when Program_Error =>
         Put_Line ("3) Heap-allocated OK init: Program_Error raised");
      when others =>
         Put_Line ("3) ERROR: Heap-allocatd OK init: unexpected exception");
   end;

   begin
      Put_Line ("4) Stack-allocated OK init");

      declare
         Obj : Lim_Ctrl := Make_Lim_Ctrl_OK_Init;
      begin
         Put_Line ("4) ERROR: Stack-allocated OK init: exception not raised");
      end;

   exception
      when Program_Error =>
         Put_Line ("4) Stack-allocated OK init: Program_Error raised");
      when others =>
         Put_Line ("4) ERROR: Stack-allocated OK init: unexpected exception");
   end;
end Main;

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

$ gnatmake -q main.adb
$ ./main
1) Heap-allocated bad init
1) Heap-allocated bad init: Program_Error raised
2) Stack-allocated bad init
2) Stack-allocated bad init: Program_Error raised
3) Heap-allocated OK init
     Finalize
3) Heap-allocated OK init: Program_Error raised
4) Stack-allocated OK init
     Finalize
4) Stack-allocated OK init: Program_Error raised

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* exp_ch6.adb (Add_Unconstrained_Actuals_To_Build_In_Place_Call): Do
	not add any actuals when the size of the object is known, and the
	caller will allocate it.
	(Build_Heap_Allocator): Rename to Build_Heap_Or_Pool_Allocator to
	better illustrate its functionality. Update the comment on the
	generated code.  Generate a branch for the heap and pool cases where
	the object is not necessarity controlled.
	(Expand_N_Extended_Return_Statement): Expand the extended return
	statement into four branches depending the requested mode if the caller
	will not allocate the object on its side.
	(Make_Build_In_Place_Call_In_Allocator): Do not allocate a controlled
	object on the caller side because this will violate the semantics of
	finalizable types. Instead notify the function to allocate the object
	on the heap or a user-defined storage pool.
	(Needs_BIP_Alloc_Form): A build-in-place function needs to be notified
	which of the four modes to employ when returning a limited controlled
	result.
	* exp_util.adb (Build_Allocate_Deallocate_Proc): Remove a redundant
	guard which is already covered in Needs_Finalization.

From-SVN: r261427

The Most_Recent_Exception service failed to provide accurate information on an
Ada exception caught by a C++ handler for foreign exceptions. The service
relies on updates of a "current exception buffer" from live exception objects
at various points of the propagation process and this update was not performed
early enough for the case of foreign exception handlers in non-Ada handlers.

The correction applied here consists in moving one of the updates earlier in
the raise process, just before unwinding starts, then refine the update API to
prevent a redundant copy during the unwinding search phase for the same
exception.

The example below, compiled with

gcc -c b.cc
gnatmake -g main.adb -largs b.o --LINK=g++

is expected to run and display

ada info:
Checking Most_Recent_Exception for CONSTRAINT_ERROR ... OK!

// b.cc

extern "C" {
 void foo ();
 extern void _ada_trigger ();
 extern void _ada_occurrence_info ();
}

void foo ()
{
 try {
   _ada_trigger ();
 } catch (const abi::__foreign_exception &e) {
   printf ("ada info:\n");
   _ada_occurrence_info();
 }
}

-- main.adb

with EH;
procedure Main is
begin
  EH.Foo;
end;

-- eh.adb

with Gnat.Most_Recent_Exception;
with Ada.Text_IO; use Ada.Text_IO;

package body EH is

  procedure Ada_Trigger is
  begin
     raise Constraint_Error;
  end;

  procedure Ada_Occurrence_Info is
  begin
     Check_MRE ("CONSTRAINT_ERROR");
  end;

  function Pre_Check_MRE (Ename : String) return Exception_Id is
     MROA : Exception_Occurrence_Access :=
       GNAT.Most_Recent_Exception.Occurrence_Access;
  begin
     Put ("Checking Most_Recent_Exception for " & Ename & " ... ");

     if MROA = null then
        Put_Line ("Most recent exception occurrence access is NULL");
        return Null_Id;
     else
        return Exception_Identity (MROA.all);
     end if;
  end;

  procedure Diagnose_MRE (MRID : Exception_Id; Ok : Boolean) is
  begin
     if Ok then
        Put_Line ("OK!");
     else
        Put_Line ("Err, Most_Recent_Exception was " & Exception_Name (MRID));
     end if;
  end;

  procedure Check_MRE (Eid : Exception_Id) is
     MRID : Exception_Id := Pre_Check_MRE (Ename => Exception_Name (Eid));
  begin
     Diagnose_MRE (MRID, Ok => Eid = MRID);
  end;

  procedure Check_MRE (Ename : String) is
     MRID : Exception_Id := Pre_Check_MRE (Ename => Ename);
  begin
     Diagnose_MRE (MRID, Ok => Ename = Exception_Name (MRID));
  end;

end;

-- eh.ads

with Ada.Exceptions; use Ada.Exceptions;
package EH is
  procedure Ada_Trigger with
    Export, Convention => C, External_Name => "_ada_trigger";

  procedure Ada_Occurrence_Info with
    Export, Convention => C, External_Name => "_ada_occurrence_info";

  procedure Foo with Import, Convention => C, External_Name => "foo";

  procedure Check_MRE (Eid : Exception_Id);
  procedure Check_MRE (Ename : String);

end;

2018-06-11  Olivier Hainque  <hainque@adacore.com>

gcc/ada/

	* libgnat/s-excmac*.ads: Factorize Unwind_Action definitions ...
	* libgnat/a-exexpr.adb: ... Here, then add comments describing the
	major datastructures associated with the current exception raised.
	(Setup_Current_Excep): Accept a "Phase" argument conveying the
	unwinding phase during which this subprogram is called.  For an Ada
	exception, don't update the current exception buffer from the raised
	exception object during SEARCH_PHASE, as this is redundant with the
	call now issued just before propagation starts.
	(Propagate_GCC_Exception): Move call to Setup_Current_Excep ahead of
	the unwinding start, conveying Phase 0.
	(Unhandled_Except_Handler): Pass UA_CLEANUP_PHASE as the Phase value on
	the call to Setup_Current_Excep.
	* raise-gcc.c (personality_body): Pass uw_phases as the Phase argument
	on calls to Setup_Current_Excep.

From-SVN: r261426

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_unst.ads, exp_unst.adb (Needs_Fat_Pointer,
	Build_Access_Type_Decl): New subprograms to handle uplevel references
	to formals of an unconstrained array type. The activation record
	component for these is an access type, and the reference is rewritten
	as an explicit derefenrence of that component.

From-SVN: r261425

In Ada.Containers.Ordered_Maps, if a dangling cursor is passed to the Element
function, execution is erroneous. Therefore, the compiler is not obligated to
detect this error. However, this patch inserts code that will detect this error
in some cases, and raise Program_Error. The same applies to Ordered_Sets,
Ordered_Multisets, Indefinite_Ordered_Maps, Indefinite_Ordered_Sets, and
Indefinite_Ordered_Multisets. No test available for erroneous execution.

2018-06-11  Bob Duff  <duff@adacore.com>

gcc/ada/

	* libgnat/a-ciorma.adb, libgnat/a-ciormu.adb, libgnat/a-ciorse.adb,
	libgnat/a-coorma.adb, libgnat/a-coormu.adb, libgnat/a-coorse.adb:
	(Element): Add code to detect dangling cursors in some cases.

From-SVN: r261424

When building a separate subprogram declaration for possible inlining of
local subprograms in GNATprove mode, correctly mark subprogram parameters
as coming from source.

This has no impact on compilation.

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* sem_ch6.adb (Build_Subprogram_Declaration): Mark parameters as coming
	from source.

From-SVN: r261423

This patch fixes a bug in the construction of predicate functions.  For a
derived type, we must ensure that the parent type is already frozen so that its
predicate function has been constructed already. This is necessary if the
parent is declared in a nested package and its own freeze point has not been
reached when the derived type is frozen by a local object declaration.

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_ch13.adb (Build_Predicate_Functions): For a derived type, ensure
	that its parent is already frozen so that its predicate function, if
	any, has already been constructed.

gcc/testsuite/

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

From-SVN: r261422

SPARK 6.1.4(12) applies both to enclosing subprograms and enclosing task
units, but the latter was not correctly rejected.

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* sem_prag.adb (Check_Mode_Restriction_In_Enclosing_Context): Adapt for
	possible task unit as the enclosing context.

gcc/testsuite/

	* gnat.dg/spark1.adb, gnat.dg/spark1.ads: New testcase.

From-SVN: r261421

2018-06-11  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* gnat1drv.adb: Remove use clause for Repinfo.
	(Gnat1drv): Beef up comment about the interplay between -gnatc and
	back-end annotations.  Use full qualified name for List_Rep_Info.

From-SVN: r261420

This patch makes GNAT.Array_Split a preelaborable unit. As a result, it can be
withed by other preelaborated untis.

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* libgnat/g-arrspl.ads: Add pragma Preelaborate.

gcc/testsuite/

	* gnat.dg/gnat_array_split1.adb, gnat.dg/gnat_array_split1.ads: New
	testcase.

From-SVN: r261419

2018-06-11  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* exp_ch4.adb (Expand_Record_Equality): Remove extraneous "True and
	then" and general logical "ada" in codepeer mode.

From-SVN: r261418

The compiler may blow up compiling a the body of a protected type that has a
family entry whose entry index specification contains a call to a function.

2018-06-11  Javier Miranda  <miranda@adacore.com>

gcc/ada/

	* exp_ch9.adb (Expand_N_Protected_Body): Add missing handling of
	N_Call_Marker nodes.

gcc/testsuite/

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

From-SVN: r261417

2018-06-11  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* exp_ch3.adb, exp_unst.adb, inline.adb, sem_prag.adb: Minor
	reformatting.

From-SVN: r261416

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* doc/gnat_rm/implementation_defined_pragmas.rst: Add Suppressible
	argument to Assertion_Policy
	* gnat_rm.texi: Regenerate.

From-SVN: r261415

Representation information generated when user calls the compiler with -gnatR
switch is not available when running the frontend inside CodePeer or GNATprove.
Do not query such information in that case, as this leads to spurious messages
that it is not available.

There is no impact on compilation.

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* gnat1drv.adb: Do not check representation information in CodePeer and
	GNATprove modes, as these modes call a special backend instead of gigi,
	so do not have the information.

From-SVN: r261414

Calls to subprograms whose body was an extended return of an unconstrained
type were marked as not inlined, while the subprogram itself was marked as
always inlined. This was inconsistent and could lead to crash in GNATprove.
Now such subprograms are marked as not candidates for inlining.

This mostly impacts GNATprove, as it relates to frontend inlining which is
not used anymore in normal compilation.

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* inline.adb (Build_Body_To_Inline): Consider case of extended return
	of unconstrained type as one case where inlining is not supported.
	(Expand_Inlined_Call): Remove special case for body as extended return
	of unconstrained type.

From-SVN: r261413

This fixes the code checking SPARK RM 7.2.6(3) so that generic child units
are not forced to use Part_Of to relate their abstract state to the state
of their parent.

2018-06-11  Yannick Moy  <moy@adacore.com>

gcc/ada/

	* sem_prag.adb (Analyze_Part_Of): Only allow Part_Of on non-generic
	unit.
	(Check_Missing_Part_Of): Do not force Part_Of on generic unit.

gcc/testsuite/

	* gnat.dg/part_of1-instantiation.adb,
	gnat.dg/part_of1-instantiation.ads,
	gnat.dg/part_of1-private_generic.adb,
	gnat.dg/part_of1-private_generic.ads, gnat.dg/part_of1.ads: New
	testcase.

From-SVN: r261412

Splitting AND THEN expressions in contracts into separate pragma Check
is only useful for compilation when the error message points to a failed
conjunct. For proof it is of no use; for flow analysis it is annoying.
Also, it makes debugging harder. Now it is disabled in GNATprove_Mode.

Compilation is not affected, so no test provided.

2018-06-11  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* sem_ch13.adb (Analyze_Aspect_Specifications): Don't split AND THEN
	expressions in Pre/Post contracts while in GNATprove_Mode.

From-SVN: r261411

Pre- and postconditions with top-level AND THEN expressions are broken down
into checks of indivudial conjuncts for more precise error reporting. This
rewrite interfers with detection of potentially unevaluadted use of 'Old,
e.g. a contract like "Pre => Foo and then Bar" is rewritten into a two
pragmas Check, for expressions "Foo" and "Bar", but the latter remains
potentially unevaluted. This patch fixes detection of the AND THEN rewrite.

This fixes inlining in the GNATprove mode, i.e. the following testc case must
not emit a warning like:

contract1.adb:14:07: info:
  no contextual analysis of "Foo" (in potentially unevaluated context)

2018-06-11  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

	* sem_util.adb (Is_Potentially_Unevaluated): Fix detection of contracts
	with AND THEN expressions broken down into individual conjuncts.

gcc/testsuite/

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

From-SVN: r261410

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_ch7.adb (Check_Unnesting_Elaboration_Code): Add guard.

From-SVN: r261409

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_unst.adb (Visit_Node): Skip generic associations.

From-SVN: r261408

2018-06-11  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* libgnat/memtrack.adb (fwrite): Remove second definition.

From-SVN: r261407

The compiler generates wrong code when an array aggregate with an others choice
whose expression has nested object allocations (ie. others => new R (new S)) is
used to initialize an array of access to discriminated types whose discriminant
is an access type.

2018-06-11  Javier Miranda  <miranda@adacore.com>

gcc/ada/

	* sinfo.ads (Is_Dynamic_Coextension): Adding documentation.
	(Is_Static_Coextension): Adding documentation.
	* sinfo.adb (Is_Dynamic_Coextension): Extending the assertion.
	(Is_Static_Coextension): Extending the assertion.
	* sem_util.adb (Mark_Allocator): Clear Is_Static_Coextension when
	setting flag Is_Dynamic_Coextension (and vice versa).

gcc/testsuite/

	* gnat.dg/aggr23.adb, gnat.dg/aggr23_q.adb, gnat.dg/aggr23_tt.ads: New
	testcase.

From-SVN: r261406

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* exp_unst.adb (Search_Subprograms): Handle explicitly stubs at the top
	level of a compilation unit, becuase they may contain nested
	subprograms that need an activation record.

From-SVN: r261405

2018-06-11  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* Makefile.rtl: Compile Ada files with $(ADAC) instead of $(CC).

From-SVN: r261404

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* exp_ch11.adb, exp_unst.adb, inline.adb, sem_ch12.adb, sem_util.adb:
	Minor reformatting.
	* sinfo.ads: Fix a typo.

From-SVN: r261403

This patch fixes a crash on a unit with a function with the GNAT-specific
Inline_Always pragma whose body is an extended return statement, when compiling
with no optimization level specified.

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* inline.adb (Expand_Inlined_Call): If no optimization level is
	specified, the expansion of a call to an Inline_Always function is
	fully performed in the front-end even on a target that support back-end
	inlining.

gcc/testsuite/

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

From-SVN: r261402

2018-06-11  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/
	* bindgen.adb (Gen_Adainit): Protect reference to System.Parameters
	with Sec_Stack_Used.

From-SVN: r261401

This patch modifies the creation of markers for variable references in the
context of SPARK elaboration checks. Previously, prior to checking whether a
reference requires such a marker, the compiler performed a logarithmic look up
to determine whether the reference appears within a call. This action caused
the compiler to degrade when a source program contains multiple (100,000s)
references. Now, the compiler no longer performs the look up immediately.

2018-06-11  Hristian Kirtchev  <kirtchev@adacore.com>

gcc/ada/

	* sem_ch8.adb (Find_Direct_Name): Mode the declaration of
	Is_Assignment_LHS further in. Use predicate
	Needs_Variable_Reference_Marker to determine whether to create a
	variable marker.
	(Find_Expanded_Name): Mode the declaration of Is_Assignment_LHS further
	in.  Use predicate Needs_Variable_Reference_Marker to determine whether
	to create a variable marker.
	* sem_elab.adb (Build_Variable_Reference_Marker): Remove the various
	checks that determine whether the identifier or expanded name is a
	suitable variable reference.  The checks are now performed by
	Needs_Variable_Reference_Marker.
	* sem_res.adb (Resolve_Actuals): Use predicate
	Needs_Variable_Reference_Marker to determine whether to create a
	variable marker.
	* sem_util.adb (Needs_Variable_Reference_Marker): New routine.
	* sem_util.ads (Needs_Variable_Reference_Marker): New routine.

From-SVN: r261400

2018-06-11  Valentine Reboul  <reboul@adacore.com>

gcc/ada/

	* doc/gnat_rm.rst, doc/gnat_ugn.rst: Rename "GPL Edition" into
	"Community Edition".

From-SVN: r261399

This patch fixes a compiler abort on an instantiation of a generic nested
within another instance, when the outer instance is declared in the visible
part of a package and the inner intance is in the private part of the same
package.

2018-06-11  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_ch12.adb (Install_Body): In order to determine the placement of
	the freeze node for an instance of a generic nested within another
	instance, take into account that the outer instance may be declared in
	the visible part of a package and the inner intance may be in the
	private part of the same package.

gcc/testsuite/

	* gnat.dg/nested_generic2.adb, gnat.dg/nested_generic2.ads,
	gnat.dg/nested_generic2_g1.adb, gnat.dg/nested_generic2_g1.ads,
	gnat.dg/nested_generic2_g2.ads: New testcase.

From-SVN: r261398

This just removes obsolete code.  No functional changes.

2018-06-11  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

	* errout.adb (Special_Msg_Delete): Remove handling of Atomic and VFA.

From-SVN: r261397

2018-06-11  Nicolas Roche  <roche@adacore.com>

gcc/ada/

	* libgnat/s-valuti.adb (Bad_Value): Ensure that we do not generate a
	stack overflow while raising a constraint error.

From-SVN: r261396