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

gcc/ada/

	* sigtramp-vxworks-target.inc: Fix stack checking test errors in
	ACATS, now that GCC can emit CFI rules referring to sp in
	absence of a frame pointer.

From-SVN: r266134

N_Quantified_Expression and N_Iterated_Component_Association are
unrelated nodes that cannot appear in the same context: the former can
appear wherever an expression node is acceptable whereas the latter can
appear only as an element of a component association list.  So a test
combining both most likely contains a dead arm and this change removes a
couple of them.

No functional changes.

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

gcc/ada/

	* exp_aggr.adb (Check_Static_Components): Remove dead test.
	(Flatten): Likewise.  Move comment around.

From-SVN: r266133

This patch modifies the analysis (which is really expansion) of null
procedures to set the Ghost mode of the spec when the null procedure
acts as a completion.  This ensures that all nodes and entities
generated by the expansion are marked as Ghost, and provide a proper
context for references to Ghost entities.

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

gcc/ada/

	* sem_ch6.adb (Analyze_Null_Procedure): Capture Ghost and
	SPARK-related global state at the start of the routine. Set the
	Ghost mode of the completed spec if any.  Restore the saved
	Ghost and SPARK-related global state on exit from the routine.

gcc/testsuite/

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

From-SVN: r266132

This adds a 4th information level for the -gnatR output, where relevant
compiler-generated types are listed in addition to the information
already output by -gnatR3.

For the following package P:

package P is

  type Arr0 is array (Positive range <>) of Boolean;

    type Rec (D1 : Positive; D2 : Boolean) is record
       C1 : Integer;
       C2 : Arr0 (1 .. D1);

       case D2 is
          when False =>
             C3 : Character;
          when True =>
             C4 : String (1 .. 3);
             C5 : Float;
       end case;
    end record;

    type Arr1 is array (1 .. 8) of Rec (1, True);

end P;

the output generated by -gnatR4 must be:

Representation information for unit P (spec)
--------------------------------------------

for Arr0'Alignment use 1;
for Arr0'Component_Size use 8;

for Rec'Object_Size use 17179869344;
for Rec'Value_Size use (if (#2 != 0) then ((((#1 + 15) & -4) + 8) * 8)
else ((((#1 + 15) & -4) + 1) * 8) end);
for Rec'Alignment use 4;
for Rec use record
   D1 at  0 range  0 .. 31;
   D2 at  4 range  0 ..  7;
   C1 at  8 range  0 .. 31;
   C2 at 12 range  0 .. ((#1 * 8)) - 1;
   C3 at ((#1 + 15) & -4) range  0 ..  7;
   C4 at ((#1 + 15) & -4) range  0 .. 23;
   C5 at (((#1 + 15) & -4) + 4) range  0 .. 31;
end record;

for Arr1'Size use 1536;
for Arr1'Alignment use 4;
for Arr1'Component_Size use 192;

for Tarr1c'Size use 192;
for Tarr1c'Alignment use 4;
for Tarr1c use record
   D1 at  0 range  0 .. 31;
   D2 at  4 range  0 ..  7;
   C1 at  8 range  0 .. 31;
   C2 at 12 range  0 ..  7;
   C4 at 16 range  0 .. 23;
   C5 at 20 range  0 .. 31;
end record;

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

gcc/ada/

	* doc/gnat_ugn/building_executable_programs_with_gnat.rst
	(-gnatR): Document new -gnatR4 level.
	* gnat_ugn.texi: Regenerate.
	* opt.ads (List_Representation_Info): Bump upper bound to 4.
	* repinfo.adb: Add with clause for GNAT.HTable.
	(Relevant_Entities_Size): New constant.
	(Entity_Header_Num): New type.
	(Entity_Hash): New function.
	(Relevant_Entities): New set implemented with GNAT.HTable.
	(List_Entities): Also list compiled-generated entities present
	in the Relevant_Entities set. Consider that the Component_Type
	of an array type is relevant.
	(List_Rep_Info): Reset Relevant_Entities for each unit.
	* switch-c.adb (Scan_Front_End_Switches): Add support for -gnatR4.
	* switch-m.adb (Normalize_Compiler_Switches): Likewise
	* usage.adb (Usage): Likewise.

From-SVN: r266131

The frontend crashes processing a tagged type that implements an
interface which has an equality primitive (that is, "=") and covers such
primitive by means of a renaming declaration.

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

gcc/ada/

	* exp_disp.adb (Expand_Interface_Thunk): Extend handling of
	renamings of the predefined equality primitive.
	(Make_Secondary_DT): When calling Expand_Interface_Thunk() pass
	it the primitive, instead of its Ultimate_Alias; required to
	allow the called routine to identify renamings of the predefined
	equality operation.

gcc/testsuite/

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

From-SVN: r266130

This patch allows for aspect/pragma Suppress_Initialization to be an
acceptable form of missing initialization with respect to the semantics
of pragma Thread_Local_Storage.

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

--  gnat.adc

pragma Initialize_Scalars;

--  pack.ads

with System;

package Pack is
   Addr : System.Address
      with Thread_Local_Storage, Suppress_Initialization;
end Pack;

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

$ gcc -c pack.ads

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

gcc/ada/

	* freeze.adb (Check_Pragma_Thread_Local_Storage): New routine. A
	variable with suppressed initialization has no initialization
	for purposes of the pragma.
	(Freeze_Object_Declaration): Remove variable
	Has_Default_Initialization as it is no longer used. Use routine
	Check_Pragma_Thread_Local_Storage to verify the semantics of
	pragma Thread_Local_Storage.

From-SVN: r266129

If the context of an if-expression is constrained, its dependent
expressions must obey the constraints of the expected type. Prior to
this patch, this check was performed only for scalar types, by means of
an added conversion.  This is now enforced on all types by means of a
qualified expression on each dependent expression.

Compiling ce.adb must yield:

  ce.adb:33:21: warning: string length wrong for type "T" defined at line 5
  ce.adb:33:21: warning: "Constraint_Error" will be raised at run time
  ce.adb:37:39: warning: string length wrong for type "T" defined at line 5
  ce.adb:37:39: warning: "Constraint_Error" will be raised at run time
  ce.adb:38:39: warning: too few elements for type "T" defined at line 5
  ce.adb:38:39: warning: "Constraint_Error" will be raised at run time
  ce.adb:39:39: warning: too few elements for type "T" defined at line 5
  ce.adb:39:39: warning: "Constraint_Error" will be raised at run time
----
with Text_IO;
procedure Ce is

  package Aerodrome_Identifier is
    subtype T is String (1 .. 4);
  end;

  package Flight_Identifier is
    type T is
     record
       ADEP                : Aerodrome_Identifier.T;
       Counter             : Positive;
     end record;
  end;

  procedure Assign (X : Flight_Identifier.T) is
  begin
    Text_IO.Put_Line (X.ADEP); -- outputs the 4 zero bytes
  end;

  function Env_Aerodrome_Value return String is ("ABCD");
  function Void return String is ("What?");
  function Void2 return String is
  begin
    return "who knows";
  end;
  Here : Aerodrome_Identifier.T;
  type Four is range 1 .. 4;
  Nothing : String := "";
begin
  Assign((ADEP =>
       (if (Void'Length = 5)
               then "" --!! This value should always raise Constraint_Error !!
                  else Env_Aerodrome_Value & "!"),
        Counter=> 17));

   Here := (if (Void'Length = 5) then "" else Env_Aerodrome_Value);
   Here := (if (Void'Length = 5) then Nothing else Env_Aerodrome_Value);
   Here := (if (Void'Length = 5) then Void2 (1..3) else Void2 & Void);
end;
----

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

gcc/ada/

	* sem_res.adb (Resolve_If_Expression): Verify that the subtypes
	of all dependent expressions obey the constraints of the
	expected type for the if-expression.
	(Analyze_Expression): Only add qualificiation to the dependent
	expressions when the context type is constrained. Small
	adjustment to previous patch.

From-SVN: r266128

There is no point in validating 'Alignment or 'Size of an entity
declared in a generic unit after the back-end has been run, since such
an entity is not passed to the back-end, and this can even lead to an
assertion failure.

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

gcc/ada/

	* sem_prag.adb (Process_Compile_Time_Warning_Or_Error): Don't
	register a compile-time warning or error for 'Alignment or 'Size
	of an entity declared in a generic unit.

gcc/testsuite/

	* gnat.dg/compile_time_error1.adb,
	gnat.dg/compile_time_error1.ads,
	gnat.dg/compile_time_error1_pkg.ads: New testcase.

From-SVN: r266127

This patch fixes an issue whereby a complicated set of generic formal
packages in conjunction with use_clauses may cause a crash during
visibility checking due to a homonym being out of scope during the
checking stage.

2018-11-14  Justin Squirek  <squirek@adacore.com>

gcc/ada/

	* sem_ch8.adb (Use_One_Package): Add test for out-of-scope
	homonyms.

gcc/testsuite/

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

From-SVN: r266126

This patch fixes a compiler abort on an object declaration whose
expression is an aggregate, when the type of the object is limited and
the declaration is followed by an address clause for the declared
object.

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

gcc/ada/

	* exp_ch3.adb: (Expand_N_Object_Declaration): If the expression
	is a limited aggregate its resolution is delayed until the
	object declaration is expanded.
	* sem_ch3.adb: (Analyze_Object_Declaration): If the expression
	is a limited aggregate and the declaration has a following
	address clause indicate that resolution of the aggregate (which
	must be built in place) must be delayed.

gcc/testsuite/

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

From-SVN: r266125

System'To_Address is supposed to be static when its parameter is static.
This patch fixes a bug in which it is considered nonstatic when used as
the initial value of a variable with the Thread_Local_Storage aspect, so
the compiler incorrectly gives an error when initializing such a
variable with System'To_Address (0).

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

gcc/ada/

	* sem_attr.adb (To_Address): Simplify setting of
	Is_Static_Expression. Remove second (unconditional) call to
	Set_Is_Static_Expression -- surely it's not static if the
	operand is not.  Initialize Static on declaration.  Do not try
	to fold 'To_Address, even though it's static.
	* exp_attr.adb (To_Address): Preserve Is_Static_Expression.
	* sinfo.ads, sem_eval.ads, sem_eval.adb (Is_Static_Expression,
	Is_OK_Static_Expression, Raises_Constraint_Error): Simplify
	documentation.  There was too much repetition and redundancy.

From-SVN: r266124

This patch recognizes additional object declarations whose defining
identifier is known statically to be valid. This allows additional
optimizations to be performed by the front-end.

Executing:

   gcc -c -gnatDG p.ads

On the following sources:

----
with G;
With Q;

package P is

  Val : constant Positive := Q.Config_Value ("Size");

  package My_G is new G (Val);

end P;
----
generic

  Num : Natural := 0;

package G is

  Multi : constant Boolean := Num > 0;

  type Info is array (True .. Multi) of Integer;

  type Arr is array (Natural range <>) of Boolean;

  type Rec (D : Natural) is record
    C : character;
    I : Info;
    E : Arr (0 .. D);
  end record;

end G;
----
package Q is

  function Config_Value (S : String) return Integer;

end Q;
----

Must yield (note that variable Multi has been statically optimized to
true):

----
with g;
with q;
p_E : short_integer := 0;

package p is
   p__R2s : constant integer := q.q__config_value ("Size");
   [constraint_error when
     not (p__R2s >= 1)
     "range check failed"]
   p__val : constant positive := p__R2s;

   package p__my_g is
      p__my_g__num : constant natural := p__val;
      package p__my_g__g renames p__my_g;
      package p__my_g__gGH renames p__my_g__g;
      p__my_g__multi : constant boolean := true;
      type p__my_g__info is array (true .. p__my_g__multi) of integer;
      type p__my_g__arr is array (0 .. 16#7FFF_FFFF# range <>) of
        boolean;
      type p__my_g__rec (d : natural) is record
         c : character;
         i : p__my_g__info;
         e : p__my_g__arr (0 .. d);
      end record;
      [type p__my_g__TinfoB is array (true .. p__my_g__multi range <>) of
        integer]
      freeze p__my_g__TinfoB [
         procedure p__my_g__TinfoBIP (_init : in out p__my_g__TinfoB) is
         begin
            null;
            return;
         end p__my_g__TinfoBIP;
      ]
      freeze p__my_g__info []
      freeze p__my_g__arr [
         procedure p__my_g__arrIP (_init : in out p__my_g__arr) is
         begin
            null;
            return;
         end p__my_g__arrIP;
      ]
      freeze p__my_g__rec [
         procedure p__my_g__recIP (_init : in out p__my_g__rec; d :
           natural) is
         begin
            _init.d := d;
            null;
            return;
         end p__my_g__recIP;
      ]
   end p__my_g;

   package my_g is new g (p__val);
end p;

freeze_generic info
[subtype TinfoD1 is boolean range true .. multi]
freeze_generic TinfoD1
[type TinfoB is array (true .. multi range <>) of integer]
freeze_generic TinfoB
freeze_generic arr
freeze_generic rec
----

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

gcc/ada/

	* sem_ch3.adb (Analyze_Object_Declaration): Use the
	Actual_Subtype to preserve information about a constant
	initialized with a non-static entity that is known to be valid,
	when the type of the entity has a narrower range than that of
	the nominal subtype of the constant.
	* checks.adb (Determine_Range): If the expression is a constant
	entity that is known-valid and has a defined Actual_Subtype, use
	it to determine the actual bounds of the value, to enable
	additional optimizations.

From-SVN: r266123

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

gcc/ada/

	* back_end.adb, checks.adb, exp_ch3.adb, exp_ch4.adb,
	exp_ch7.adb, exp_disp.adb, exp_unst.adb, exp_util.adb,
	freeze.adb, sem_ch13.adb, sem_ch6.adb, sem_ch7.adb,
	sem_prag.adb, sem_spark.adb, sem_util.adb: Minor reformatting.

From-SVN: r266122

The following patch corrects the search for the equality function to
handle cases where the equality could be a renaming of another routine.
No simple reproducer possible because this requires PolyORB.

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

gcc/ada/

	* exp_ch4.adb (Find_Aliased_Equality): New routine.
	(Find_Equality): Reimplemented.
	(Is_Equality): New routine.

From-SVN: r266121

This patch modifies the way analysis determine whether an assignment is
an ignored Ghost assignment. This is now achieved by preanalyzing a copy
of the left hand side in order to account for potential code generated
by the left hand side itself.

No small reproducer possible.

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

gcc/ada/

	* ghost.adb (Ghost_Entity): New routine.
	(Mark_And_Set_Ghost_Assignment): Reimplemented.
	* sem_ch5.adb (Analyze_Assignment): Assess whether the target of
	the assignment is an ignored Ghost entity before analyzing the
	left hand side.
	* sem_ch8.adb (Find_Direct_Name): Update the subprogram
	signature. Do not generate markers and references when they are
	not desired.
	(Nvis_Messages): Do not execute when errors are not desired.
	(Undefined): Do not emit errors when they are not desired.
	* sem_ch8.ads (Find_Direct_Name): Update the subprogram
	signature and comment on usage.
	* sem_util.adb (Ultimate_Prefix): New routine.
	* sem_util.ads (Ultimate_Prefix): New routine.

From-SVN: r266120

This patch fixes an issue whereby the freezing of a nested package
containing an enumerated type declaration would cause visibility errors
on literals of such type when a use_all_type_clause for it appears
within the same declarative region.

2018-11-14  Justin Squirek  <squirek@adacore.com>

gcc/ada/

	* sem_ch7.adb (Uninstall_Declarations): Add conditional to avoid
	uninstalling potential visibility during freezing on enumeration
	literals.

gcc/testsuite/

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

From-SVN: r266119

2018-11-14  Jerome Lambourg  <lambourg@adacore.com>

gcc/ada/

	* env.c: Do not include crt_externs.h on iOS, as it does not
	exist there. This is also true for the iPhone Simulator SDK.

From-SVN: r266118

The declarations in the package body may have created blocks with nested
subprograms. Such a block must be transformed into a procedure followed
by a call to it, so that unnesting can handle uplevel references within
these nested subprograms (typically generated subprograms to handle
finalization actions).

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

gcc/ada/

	* exp_ch7.adb (Check_Unnesting_In_Declarations): New procedure
	to transform blocks that appear in the declarative part of a
	package body into subprograms if they contain generated
	subprograms (such as finalization routines). Needed to generate
	the proper upward references in unnesting mode.

From-SVN: r266117

If the given Delta of an ordinariy fixed-point type is not a machine
number and there is no specified 'Small for the type, the compiler
chooses the actual bounds of the type using the nearest model numbers
that include the given bounds, but it is free to exclude those bounds if
a size clause restricts the number of bits to use for the type. This
patch fixes an error in the case where the bounds of the type can be
chosen to be larger than the bounds specified in the type declaration:
prior to this patch the lower bounds could be chosen to be one delta
smaller that the given bound, when that given bound was smaller than the
nearest machine number,

Compiling rep2.adb must yield:

   rep2.adb:7:24:
       warning: value not in range of type "Test_Type" defined at line 4
   rep2.adb:7:24:
       warning: "Constraint_Error" will be raised at run time

----
with Ada.Text_IO; use Ada.Text_IO;
procedure Rep2 is

   type    Test_Type is delta 0.1 range 0.1 .. 100.0 with Size => 16;
   subtype Next_Type is Test_Type range 0.1 .. 100.0;

   Item : Test_Type := 0.0;                        -- Why is this allowed?
   Next : Next_Type with Address => Item'Address;

begin

   Put_Line (Item'Img & " - " & Item'Valid'Img);  -- Returns "0.0 - TRUE"
   Put_Line (Next'Img & " - " & Next'Valid'Img);  -- Returns "0.0 - FALSE"

end Rep2;

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

gcc/ada/

	* freeze.adb (Freeze_Fixed_Point_Type): If the given low bound
	of the type is less than the nearest model number, do not expand
	the range of the type to include the model number below the
	bound. Similar adjustment if the upper bound is larger than the
	nearest model number.

From-SVN: r266116

This patch suppresses the generation of raise statements in the context
of build-in-place and elaboration checks for primitives of tagged types
when exceptions cannot be used.

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

gcc/ada/

	* checks.adb (Install_Primitive_Elaboration_Check): Do not
	create the check when exceptions cannot be used.
	* exp_ch6.adb (Expand_N_Extended_Return_Statement): Do not raise
	Program_Errror when exceptions cannot be used. Analyze the
	generated code with all checks suppressed.
	* exp_ch7.adb (Build_Finalizer): Remove the declaration of
	Exceptions_OK.
	(Make_Deep_Array_Body): Remove the declaration of Exceptions_OK.
	(Make_Deep_Record_Body): Remove the declaration of
	Exceptions_OK.
	(Process_Transients_In_Scope): Remove the declaration of
	Exceptions_OK.
	* exp_util.adb (Exceptions_In_Finalization_OK): Renamed to
	Exceptions_OK.
	* exp_util.ads (Exceptions_In_Finalization_OK): Renamed to
	Exceptions_OK.

gcc/testsuite/

	* gnat.dg/bip_exception.adb, gnat.dg/bip_exception.ads,
	gnat.dg/bip_exception_pkg.ads: New testcase.

From-SVN: r266115

This patch corrects the retrieval of the equality function when it is
inherited from a parent tagged type.

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

gcc/ada/

	* exp_ch4.adb (Expand_N_Op_Eq): Remove duplicated code and use
	routine Find_Equality instead.
	(Find_Equality): New routine.

gcc/testsuite/

	* gnat.dg/equal4.adb, gnat.dg/equal4.ads,
	gnat.dg/equal4_controlled_filter.ads,
	gnat.dg/equal4_full_selector_filter.ads,
	gnat.dg/equal4_smart_pointers.ads: New testcase.

From-SVN: r266114

In the Global contract there can be only entire objects, which are
represented either as N_Identifier or N_Expanded_Name. The test for
record components was dead. Now removed. Semantics unaffected.

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

gcc/ada/

	* sem_util.adb (First_From_Global_List): Do not expect
	N_Selected_Component in the Global contract; simplify assertion
	with Nam_In.

From-SVN: r266113

Both in the GNAT frontend and in the GNATprove backend we have
several checks related to generic actuals of mode IN that rely on the
Corresponding_Generic_Association flag. However, this flag was only set
for actuals with explicit expressions from the generic instance and unset
for actuals with implicit expressions from the generic unit.

For example, the code from the added testcase was wrongly rejected with
a message that Y (which is an actual with a default expression) cannot
appear in the Initializes contract. Now this code is accepted.

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

gcc/ada/

	* sem_ch12.adb (Instantiate_Object): Set
	Corresponding_Generic_Association on generic actuals with
	default expression.
	* sinfo.ads (Corresponding_Generic_Association): Update comment.

gcc/testsuite/

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

From-SVN: r266112

The following patch ensures that loops generated for aggregates as part
of ignored Ghost assignments are correctly eliminated from the generated
code.

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

--  pack.ads

package Pack is
   type addr4k is new Integer range 0 .. 100 with Size => 32;

   type Four_KB_Page_Property is record
      Is_Scrubbed : Boolean := False;
   end record with Ghost;

   type Four_KB_Page_Array is
     array (addr4k range <>) of Four_KB_Page_Property with Ghost;

   type Base_Memory is tagged record
      Four_KB_Pages : Four_KB_Page_Array (addr4k) :=
                        (others => (Is_Scrubbed => False));
   end record with Ghost;

   subtype Memory is Base_Memory with Ghost;
   Global_Memory : Memory with Ghost;

   procedure Assign;
end Pack;

--  pack.adb

package body Pack is
   procedure Assign is
   begin
      Global_Memory.Four_KB_Pages := (others => (Is_Scrubbed => True));
   end Assign;
end Pack;

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

$ gcc -c -gnatDG pack.adb
$ grep -c "loop" pack.adb.dg
0

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

gcc/ada/

	* exp_ch4.adb (Expand_Concatenate): Use the proper routine to
	set the need for debug info.
	* exp_dbug.adb (Build_Subprogram_Instance_Renamings): Use the
	proper routine to set the need for debug info.
	* exp_prag.adb (Expand_Pragma_Initial_Condition): Use the proper
	routine to set the need for debug info.
	* exp_util.adb (Build_DIC_Procedure_Declaration): Use the proper
	routine to set the need for debug info.
	(Build_Invariant_Procedure_Declaration): Use the proper routine
	to set the need for debug info.
	* ghost.adb (Record_Ignored_Ghost_Node): Add statements as a
	whole class to the list of top level ignored Ghost nodes.
	* sem_util.adb (Set_Debug_Info_Needed): Do not generate debug
	info for an ignored Ghost entity.

From-SVN: r266111

I believe Cancel_Special_Output is easier to read and thus preferred;
otherwise, it wouldn't be introduced, so let's use it where possible.

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

gcc/ada/

	* bindgen.adb, exp_cg.adb, repinfo.adb, sprint.adb: Minor reuse
	Cancel_Special_Output where possible.

From-SVN: r266110

When acting as an adjective, it is "library-level something"; when
acting as a noun, it is "something at the library level".

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

gcc/ada/

	* exp_dbug.ads, sem_util.ads: Minor fixes in comments.

From-SVN: r266109

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

gcc/ada/

	* adabkend.adb (Scan_Back_End_Switches): Handle -gx switches
	explicitly.

From-SVN: r266108

2018-11-14  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/88019
	* graphite-isl-ast-to-gimple.c (ternary_op_to_tree): Rewrite
	COND_EXPR arguments to non-trapping overflow.

From-SVN: r266105

LP_COUNT register cannot be freely allocated by the compiler as it
size, and/or content may change depending on the ARC hardware
configuration. Thus, make this register fixed.

Remove register classes and unused constraint letters.

Cleanup the implementation of conditional_register_usage hook by using
macros instead of magic constants and removing all references to
reg_class_contents which are bringing so much grief when lra is enabled.

gcc/
xxxx-xx-xx  Claudiu Zissulescu  <claziss@synopsys.com>

	* config/arc/arc.h (reg_class): Reorder registers classes, remove
	unused register classes.
	(REG_CLASS_NAMES): Likewise.
	(REG_CLASS_CONTENTS): Likewise.
	(FIXED_REGISTERS): Make lp_count fixed.
	(BASE_REG_CLASS): Remove ACC16_BASE_REGS reference.
	(PROGRAM_COUNTER_REGNO): Remove.
	* config/arc/arc.c (arc_conditional_register_usage): Remove unused
	register classes, use constants for register numbers, remove
	reg_class_contents references.
	(arc_process_double_reg_moves): Add asserts.
	(arc_secondary_reload): Remove LPCOUNT_REG reference, use
	lra_in_progress predicate.
	(arc_init_reg_tables): Remove unused register classes.
	(arc_register_move_cost): Likewise.
	(arc_preferred_reload_class): Likewise.
	(hwloop_optimize): Update rtx patterns involving lp_count
	register.
	(arc_return_address_register): Rename ILINK1, INLINK2 regnums
	macros.
	* config/arc/constraints.md ("c"): Choose between GENERAL_REGS and
	CHEAP_CORE_REGS.  Former one will be used for LRA.
	("Rac"): Choose between GENERAL_REGS and ALL_CORE_REGS.  Former
	one will be used for LRA.
	("w"): Choose between GENERAL_REGS and WRITABLE_CORE_REGS.  Former
	one will be used for LRA.
	("W"): Choose between GENERAL_REGS and MPY_WRITABLE_CORE_REGS.
	Former one will be used for LRA.
	("f"): Delete constraint.
	("k"): Likewise.
	("e"): Likewise.
	("l"): Change it from register constraint to constraint.
	* config/arc/arc.md (movqi_insn): Remove unsed lp_count constraints.
	(movhi_insn): Likewise.
	(movsi_insn): Update pattern.
	(arc_lp): Likewise.
	(dbnz): Likewise.
	(stack_tie): Remove 'b' constraint letter.
	(R4_REG): Define.
	(R9_REG, R15_REG, R16_REG, R25_REG): Likewise.
	(R32_REG, R40_REG, R41_REG, R42_REG, R43_REG, R44_REG): Likewise.
	(R57_REG, R59_REG, PCL_REG): Likewise.
	(ILINK1_REGNUM): Renamed to ILINK1_REG.
	(ILINK2_REGNUM): Renamed to ILINK2_REG.
	(Rgp): Remove.
	(SP_REGS): Likewise.
	(Rcw): Remove unused reg classes.
	* config/arc/predicates.md (dest_reg_operand): Just default on
	register_operand predicate.
	(mpy_dest_reg_operand): Likewise.
	(move_dest_operand): Use macros instead of constants.

From-SVN: r266100

2018-11-14  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/87974
	* tree-vect-loop.c (vectorizable_reduction): When computing
	the vectorized reduction PHI vector type ignore constant
	and external defs.

	* g++.dg/opt/pr87974.C: New testcase.

From-SVN: r266099

re PR tree-optimization/87977 (ICE: verify_ssa failed (error: definition in block 4 follows the use))

	PR tree-optimization/87977
	* tree-ssa-math-opts.c (optimize_recip_sqrt): Don't reuse division
	stmt, build a new one and replace the old one with it.  Formatting fix.
	Call release_ssa_name (x) if !has_other_use and !delete_div.
	(pass_cse_reciprocals::execute): Before calling optimize_recip_sqrt
	verify lhs of stmt is still def.

	* gcc.dg/recip_sqrt_mult_1.c: Add -fcompare-debug to dg-options.
	* gcc.dg/recip_sqrt_mult_2.c: Likewise.
	* gcc.dg/recip_sqrt_mult_3.c: Likewise.
	* gcc.dg/recip_sqrt_mult_4.c: Likewise.
	* gcc.dg/recip_sqrt_mult_5.c: Likewise.

From-SVN: r266098

re PR rtl-optimization/87507 (IRA unnecessarily uses non-volatile registers during register assignment)

gcc/
	PR rtl-optimization/87507
	* lower-subreg.c (operand_for_swap_move_operator): New function.
	(simple_move): Strip simple operators.
	(find_pseudo_copy): Likewise.
	(resolve_operand_for_swap_move_operator): New function.
	(resolve_simple_move): Strip simple operators and swap operands.

gcc/testsuite/
	PR rtl-optimization/87507
	* gcc.target/powerpc/pr87507.c: New test.
	* gcc.target/powerpc/pr68805.c: Update expected results.

From-SVN: r266097

From-SVN: r266096

	PR tree-optimization/87898
	* omp-simd-clone.c (ipa_simd_modify_stmt_ops): Formatting fix.
	(ipa_simd_modify_function_body): Remove debug stmts where the first
	argument was changed into a non-decl.

	* gcc.dg/gomp/pr87898.c: New test.

From-SVN: r266093

	* src/c++17/memory_resource.cc (select_num_pools): Fix off-by-one
	error when block_size is equal to one of the values in the array.

From-SVN: r266092

	* src/c++17/memory_resource.cc (_Pool::deallocate): Restore
	attributes to parameters that are only used in assertions.

From-SVN: r266091

	* src/c++17/memory_resource.cc (bitset::find_first_unset()): Remove
	unused function.
	(bitset::get_first_unset()): Remove loop, if there's are unset bits
	then _M_next_word refers to the first one and there's no need to loop.
	(_Pool::_Pool(size_t, size_t), _Pool::block_size()): Remove dead code.

From-SVN: r266090

Make the munge_options function round the largest_required_pool_block
value to a multiple of the smallest pool size (currently 8 bytes) to
avoid pools with odd sizes.

Ensure there is a pool large enough for blocks of the requested size.
Previously when largest_required_pool_block was exactly equal to one of
the pool_sizes[] values there would be no pool of that size. This patch
increases _M_npools by one, so there is a pool at least as large as the
requested value. It also reduces the size of the largest pool to be no
larger than needed.

	* src/c++17/memory_resource.cc (munge_options): Round up value of
	largest_required_pool_block to multiple of smallest pool size. Round
	excessively large values down to largest pool size.
	(select_num_pools): Increase number of pools by one unless it exactly
	matches requested largest_required_pool_block.
	(__pool_resource::_M_alloc_pools()): Make largest pool size equal
	largest_required_pool_block.
	* testsuite/20_util/unsynchronized_pool_resource/options.cc: Check
	that pool_options::largest_required_pool_block is set appropriately.

From-SVN: r266089

Since a big_block rounds up the size to a multiple of big_block::min it
is wrong to assert that the supplied number of bytes equals the
big_block's size(). Add big_block::alloc_size(size_t) to calculate the
allocated size consistently, and add comments to the code.

	* src/c++17/memory_resource.cc (big_block): Improve comments.
	(big_block::all_ones): Remove.
	(big_block::big_block(size_t, size_t)): Use alloc_size.
	(big_block::size()): Add comment, replace all_ones with equivalent
	expression.
	(big_block::align()): Shift value of correct type.
	(big_block::alloc_size(size_t)): New function to round up size.
	(__pool_resource::allocate(size_t, size_t)): Add comment.
	(__pool_resource::deallocate(void*, size_t, size_t)): Likewise. Fix
	incorrect assertion by using big_block::alloc_size(size_t).
	* testsuite/20_util/unsynchronized_pool_resource/allocate.cc: Add
	more tests for unpooled allocations.

From-SVN: r266088

	* src/c++17/memory_resource.cc (bitset::full()): Handle edge case
	for _M_next_word maximum value.
	(bitset::get_first_unset(), bitset::set(size_type)): Use
	update_next_word() to update _M_next_word.
	(bitset::update_next_word()): New function, avoiding wraparound of
	unsigned _M_next_word member.
	(bitset::max_word_index()): New function.
	(chunk::chunk(void*, uint32_t, void*, size_t)): Add assertion.
	(chunk::max_bytes_per_chunk()): New function.
	(pool::replenish(memory_resource*, const pool_options&)): Prevent
	_M_blocks_per_chunk from exceeding max_blocks_per_chunk or from
	causing chunk::max_bytes_per_chunk() to be exceeded.
	* testsuite/20_util/unsynchronized_pool_resource/allocate-max-chunks.cc:
	New test.

From-SVN: r266087