[Ada] Emit DW_AT_GNU_bias with -fgnat-encodings=gdb

Emit DW_AT_GNU_bias with -fgnat-encodings=gdb.  gdb implements this,
but not the encoded variant.

2019-09-19  Tom Tromey  <tromey@adacore.com>

gcc/ada/

* gcc-interface/misc.c (gnat_get_type_bias): Return the bias
when -fgnat-encodings=gdb.

gcc/testsuite/

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

From-SVN: r275958

[Ada] Accept concatentation arguments to pragma Annotate

In cases where pragma Annotate accepts a string literal as an argument,
we now also accept a concatenation of string literals.

2019-09-19  Steve Baird  <baird@adacore.com>

gcc/ada/

* sem_prag.adb (Preferred_String_Type): A new function. Given an
expression, determines whether the preference rules defined for
the third-and-later arguments of pragma Annotate suffice to
determine the type of the expression. If so, then the preferred
type is returned; if not then Empty is returned. Handles
concatenations.
(Analyze_Pragma): Replace previous code, which dealt only with
string literals, with calls to the new Preferred_String_Type
function, which also handles concatenations.
* doc/gnat_rm/implementation_defined_pragmas.rst: Update
documentation for pragma Annotate.
* gnat_rm.texi: Regenerate.

gcc/testsuite/

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

From-SVN: r275957

[Ada] Get rid of useless temporary for slice in overaligned record type

This fixes a recent code quality regression for targets that do not
require the strict alignment of memory accesses: the compiler would
generate a useless temporary for a slice of an array component in an
overaligned record type.

Running these commands:

  gcc -c p.adb -gnatws -gnatD
  grep loop p.adb.dg

On the following sources:

procedure P (N : Positive) is

  type Rec1 is record
    I : Integer;
  end record;

  type Arr is array (Positive range <>) of Rec1;

  type Rec2 is record
    A : Arr (1 .. 128);
  end record;
  for Rec2'Alignment use 8;

  procedure Proc (A : Arr) is
  begin
    null;
  end;

  R : Rec2;

begin
  Proc (R.A (1 .. N));
end;

Should execute silently.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_util.adb (Is_Possibly_Unaligned_Slice): Do not return true
on pure alignment considerations if the target does not require
the strict alignment of memory accesses.

From-SVN: r275956

[Ada] Sem_Ch12: add a comment to indicate future work

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem_ch12.adb (Check_Private_View): Add a comment to indicate
future work.

From-SVN: r275955

[Ada] Fix copy operation with private discriminated record type

This prevents the object code from reading too many bytes from the
source for a copy operation involving a private discriminated record
type with default discriminants and generated for the assignment of an
aggregate to a variable or the initialization of a constant.

The front-end already knows that it needs to convert the operation
involving the aggregate into individual assignments if the type of the
aggregate has mutable components, but it would not do so if this type is
private, which does not change anything for code generation.

Running these commands:

  gnatmake -q p -g -fsanitize=address
  p

On the following sources:

with Q; use Q;

procedure P is

   type Rec is record
      A : T;
   end record;

   C : constant Rec := Rec'(A => Default_T);

begin
   null;
end;

package Q is

   type T is private;

   Default_T : constant T;

private

   A : constant := 170;
   B : constant := 8192;

   type A_Index is range 1 .. A;
   type B_Index is range 1 .. B;

   type A_Array is array (A_Index) of Boolean;
   type B_Array is array (B_Index) of Boolean;

   type Data_Type is (A_Type, B_Type);

   type T (Discriminant : Data_Type := A_Type) is record
      case Discriminant is
         when A_Type =>
            Field_A : A_Array;
         when B_Type =>
            Field_B : B_Array;
      end case;
   end record;

   Default_T : constant T :=
     T'(Discriminant => A_Type, Field_A => (others => True));

end Q;

Should execute silently.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_aggr.adb (Has_Mutable_Components): Look at the underlying
type of components to find out whether they are mutable.

From-SVN: r275954

[Ada] Fix bogus "too late" error with nested generics and inlining

This prevents the compiler from issuing a bogus error about a constant
whose full declaration appears too late, if it is declared in a nested
generic package and instantiated in another nested instantiation, when
the instantiations are done in a unit withed from the main unit and
containing an inlined subprogram, and cross-unit inlining is enabled.

It turns out that, under these very peculiar conditions, the compiler
ends up instantiating the body of the generic package twice, which leads
to various semantic errors, in particular for declarations of constants.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem_ch12.adb (Instantiate_Package_Body): Check that the body
has not already been instantiated when the body of the parent
was being loaded.

gcc/testsuite/

* gnat.dg/inline21.adb, gnat.dg/inline21_g.ads,
gnat.dg/inline21_h.adb, gnat.dg/inline21_h.ads,
gnat.dg/inline21_q.ads: New testcase.

From-SVN: r275953

[Ada] Fix bogus visibility error with nested generics and inlining

This prevents the compiler from issuing a bogus error about the
visibility of an operator in an instantiation of a nested generic
package which is itself used as an actual of an instantiation of another
generic package, when the instantiations are done in a unit withed from
the main unit and containing an inlined subprogram, and cross-unit
inlining is enabled.

In most cases, the compiler does not check the visibility of operators
in an instantiation context because this has already been done when the
generic package has been analyzed. However, there are exceptions like
the actuals of an instantiation of a generic child unit which is done
as a compilation unit and the In_Instance predicate has a special check
for these cases.

This check would incorrectly trigger here and needs to be tightened.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem_util.adb (In_Instance): Test whether the current unit has
been analyzed instead of being on the scope stack to detect the
case of actuals of an instantiation of a generic child unit done
as a compilation unit.

gcc/testsuite/

* gnat.dg/inline20.adb, gnat.dg/inline20_g.adb,
gnat.dg/inline20_g.ads, gnat.dg/inline20_h.ads,
gnat.dg/inline20_i.ads, gnat.dg/inline20_q-io.ads,
gnat.dg/inline20_q.ads, gnat.dg/inline20_r.ads: New testcase.

From-SVN: r275952

[Ada] New routine GNAT.Sockets.Create_Socket_Pair

New routine to create 2 connected sockets. This routine is analog of the
UNIX system call socketpair. On UNIX platforms it is implemented on the
base of socketpair. On other platforms it is implemented by conecting
network sockets over loopback interface.

2019-09-19  Dmitriy Anisimkov  <anisimko@adacore.com>

gcc/ada/

* libgnat/g-socket.ads, libgnat/g-socket.adb
(Create_Socket_Pair): New routine.
* libgnat/g-socthi.ads (OS_Has_Socketpair): Boolean constant.
(C_Socketpair): New imported routine.
* libgnat/g-socthi__mingw.ads, libgnat/g-socthi__vxworks.ads
(Default_Socket_Pair_Family): New constant.
(C_Socketpair): New routine.
* libgnat/g-socthi__mingw.adb, libgnat/g-socthi__vxworks.adb
(C_Socketpair): Is separated in anouther file.
* libgnat/g-sthcso.adb (C_Socketpair): Non UNIX implementation.
* libgnat/g-stsifd__sockets.adb: Reuse C_Socketpair.

From-SVN: r275951

[Ada] Use declared type for deciding on SPARK pointer rules

A constant of pointer type is considered as mutable in SPARK, according
to SPARK RM 3.10, but this should be based on the declared type of the
constant instead of its underlying type.

There is no impact on compilation hence no test.

2019-09-19  Yannick Moy  <moy@adacore.com>

gcc/ada/

* sem_prag.adb (Analyze_Depends_In_Decl_Part): Simplify previous
test.

From-SVN: r275950

[Ada] Spurious visibility error in generic child unit

2019-09-19  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

* sem_ch7.adb (Install_Parent_Private_Declarations): If a
generic child unit is instantiated within a sibling child unit,
the analysis of its private part requires that the private part
of the ancestor be available, as is done when the context
includes an instance of the ancestor.

gcc/testsuite/

* gnat.dg/generic2-child.ads, gnat.dg/generic2-io_any.adb,
gnat.dg/generic2-io_any.ads, gnat.dg/generic2.ads: New testcase.

From-SVN: r275949

[Ada] Disable inlining of traversal function in GNATprove

Traversal functions as defined in SPARK RM 3.10 should not be inlined
for analysis in GNATprove, as this changes the ownership behavior.
Disable the inlining performed in GNATprove on functions which could be
interpreted as such.

There is no impact on compilation and thus no test.

2019-09-19  Yannick Moy  <moy@adacore.com>

gcc/ada/

* inline.adb (Can_Be_Inlined_In_GNATprove_Mode): Add special
case for traversal functions.

From-SVN: r275948

[Ada] Allow constants of access type in Global contracts

Now that SPARK supports access types, global constants of access type
may appear as outputs of a subprogram, with the meaning that the
underlying memory can be modified (see SPARK RM 3.10).

2019-09-19  Yannick Moy  <moy@adacore.com>

gcc/ada/

* sem_prag.adb (Analyze_Global_In_Decl_Part): Do not issue an
error when a constant of an access type is used as output in a
Global contract.
(Analyze_Depends_In_Decl_Part): Do not issue an error when a
constant of an access type is used as output in a Depends
contract.

gcc/testsuite/

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

From-SVN: r275947

[Ada] Exp_Attr: remove obsolete comment

2019-09-19  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

* exp_attr.adb: Remove obsolete comment.

From-SVN: r275946

[Ada] Fix run-time segfault with derived access-to-subprogram type

This fixes a segfault at run time for the call to a local subprogram
through an access value if the type of this access value is derived
from an initial access-to-subprogram type and the access value was
originally obtained with the initial type.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem_ch3.adb (Build_Derived_Access_Type): If this is an access-
to-subprogram type, copy Can_Use_Internal_Rep from the parent.

gcc/testsuite/

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

From-SVN: r275945

[Ada] Move SPARK borrow-checker to gnat2why codebase

Unit sem_spark was implementing the borrow-checker for the support of
ownership pointers in SPARK. It has been moved to gnat2why codebase to
facilitate its evolution and allow the more powerful flow analysis to
provide its results for better analysis on pointers.

2019-09-19  Yannick Moy  <moy@adacore.com>

gcc/ada/

* gcc-interface/Make-lang.in: Remove references to sem_spark.
* sem_spark.adb, sem_spark.ads: Remove unit.

From-SVN: r275944

[Ada] Implement Machine_Rounding attribute in line when possible

GNAT implements Machine_Rounding as an alias for Rounding but, whereas
the implementation of the latter is in line when possible, that of the
former is always out of line, which is not aligned with the intent of
the Ada RM.

This changes the compiler to using for Machine_Rounding the same in line
implementation as Rounding when possible.

Running these commands:

  gcc -c f.adb -gnatD
  grep system f.adb.dg

On the following sources:

function F (Val : Float) return Integer is
begin
  return Integer (Float'Machine_Rounding (Val));
end;

Should execute silently.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_attr.adb (Is_Inline_Floating_Point_Attribute): Treat
Machine_Rounding as an alias for Rounding.
* sem_res.adb (Simplify_Type_Conversion): Likewise.

From-SVN: r275943

[Ada] Suppress GNAT FE up-level reference transformation for GNAT-LLVM

In the case of GNAT-LLVM, the GNAT FE no longer does expansion of
up-level references identified by the subprogram unnesting machinery
into activation record references. This is now only done by the FE when
generating C code. This expansion is already taken care of by the
gnat-llvm middle phase, so there's no benefit to also doing it in the
front end.

2019-09-19  Gary Dismukes  <dismukes@adacore.com>

gcc/ada/

* exp_unst.adb (Unnest_Subprogram): Bypass the transformation of
up-level references unless Opt.Generate_C_Code is enabled.

From-SVN: r275942

[Ada] Streamline comparison for equality of 2-element arrays

In the general case, the comparison for equality of array objects is
implemented by a local function that contains, among other things, a
loop running over the elements, comparing them one by one and exiting
as soon as an element is not the same in the two array objects.

For the specific case of constrained 2-element arrays, this is rather
heavy and unnecessarily obfuscates the control flow of the program,
so this change implements a simple conjunction of comparisons for it.

Running these commands:

  gcc -c p.ads -O -gnatD
  grep loop p.ads.dg

On the following sources:

package P is

  type Rec is record
    Re : Float;
    Im : Float;
  end record;

  type Arr is array (1 .. 2) of Rec;

  function Equal (A, B : Arr) return Boolean is (A = B);

end P;

Should execute silently.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_ch4.adb (Expand_Array_Equality): If optimization is
enabled, generate a simple conjunction of comparisons for the
specific case of constrained 1-dimensional 2-element arrays.
Fix formatting.

From-SVN: r275941

[Ada] Remove duplicated routines for getting homonym number

Routines Homonym_Number and Get_Homonym_Number were exactly the same,
except for minor style differences. Keep the one in Exp_Util; remove the
one in Exp_Dbug. No test attached, because semantics is unaffected.

2019-09-19  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

* exp_dbug.ads, exp_dbug.adb (Get_Homonym_Number): Remove.
(Append_Homonym_Number): Use Homonym_Number instead of
Get_Homonym_Number.
* exp_util.ads, exp_util.adb (Homonym_Number): Mirror style of
the removed Get_Homonym_Number routine, i.e. initialize local
objects at declaration and refine the type of result.
* sem_util.adb (Add_Homonym_Suffix): Use Homonym_Number instead
of Get_Homonym_Number.

From-SVN: r275940

[Ada] Crash on predicate in full view in a generic unit

This patch fixes a compiler abort on a dynamic predicate applied to the
full view of a type in a generic package declaration, when the
expression for the predicate is a conditionql expression that contains
references to components of the full view of the type.

2019-09-19  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

* sem_ch13.adb (Check_Aspect_At_End_Of_Declarations): Simplify
handling of expressions in predicates when the context is a
generic unit.

gcc/testsuite/

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

From-SVN: r275939

[Ada] Memory leak with 'Range of a function call in a loop

If a for loop starts with "for X in F (...)'Range loop", where F is a
function returning an unconstrained array, then memory is leaked. This
patch fixes that bug.

Running these commands:

  gnatmake -q -f main.adb
  main

On the following sources:

with Text_IO; use Text_IO;
package P is

   function Get_Objects return String;

end P;

package body P is
   function Get_Objects return String is
   begin
      return "xyzzy";
   end Get_Objects;

end P;

with Text_IO; use Text_IO;
pragma Warnings (Off, "an internal GNAT unit");
with System.Secondary_Stack;
pragma Warnings (On, "an internal GNAT unit");
with P; use P;

procedure Main is
   Max_Iterations : constant Integer := 1_000;

   procedure Leak_Call is
   begin
      for Id in Get_Objects'Range loop
         null;
      end loop;
   end Leak_Call;

   procedure SS_Info is new System.Secondary_Stack.SS_Info
(Text_IO.Put_Line);

begin
   for Iteration in 1 .. Max_Iterations loop
      Leak_Call;
   end loop;

   SS_Info;

end Main;

Should produce the following output:

  Secondary Stack information:
    Total size              :  10240 bytes
    Current allocated space :  0 bytes
    Number of Chunks        :  1
    Default size of Chunks  :  10240

2019-09-19  Bob Duff  <duff@adacore.com>

gcc/ada/

* sem_attr.adb (Resolve_Attribute): Make sure the secondary
stack is properly managed in the case of a 'Range attribute in a
loop.

From-SVN: r275938

[Ada] Propagate documentation to formal bounded sets

2019-09-19  Raphael Amiard  <amiard@adacore.com>

gcc/ada/

* libgnat/a-cfhase.ads (Set): Add comments to public primitives.

From-SVN: r275937

[Ada] Add comments wrt. deallocation of bounded sets/maps

2019-09-19  Raphael Amiard  <amiard@adacore.com>

gcc/ada/

* libgnat/a-cbhama.ads, libgnat/a-cbhase.ads,
libgnat/a-chtgop.ads (Clear): Refine comments

From-SVN: r275936

[Ada] Fix spurious type mismatch failure on nested instantiations

This fixes a spurious type mismatch failure reported between formal and
actual of a call to a subprogram that comes from the instantiation of a
child generic unit that itself contains an instantiation of a slibling
child generic unit, when the parent is itself a generic unit with
private part. The regression was introduced by a recent change made to
clear the Is_Generic_Actual_Type on the implicit full view built when a
generic package is instantiated on a private type.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem_ch12.adb (Restore_Private_Views): Comment out new code
that clear the Is_Generic_Actual_Type also on the full view.

gcc/testsuite/

* gnat.dg/generic_inst13.adb,
gnat.dg/generic_inst13_pkg-nested_g.ads,
gnat.dg/generic_inst13_pkg-ops_g.ads,
gnat.dg/generic_inst13_pkg.ads: New testcase.

From-SVN: r275935

[Ada] Infinite loop with concatenation and aspect

This patch fixes a bug where an array object initialized with a
concatenation, and that has an aspect_specification for Alignment,
causes the compiler goes into an infinite loop.

2019-09-19  Bob Duff  <duff@adacore.com>

gcc/ada/

* exp_ch3.adb (Rewrite_As_Renaming): Return False if there are
any aspect specifications, because otherwise Insert_Actions
blows up.

gcc/testsuite/

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

From-SVN: r275934

[Ada] Fix fallout of previous change for bit-packed arrays

This fixes a regression introduced by the previous change that improved
the handling of explicit by-reference mechanism. For the very specific
case of a component of a bit-packed array, the front-end still needs to
insert a copy around the call because this is where the rewriting into
the sequence of mask-and-shifts is done for the code generator.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_ch6.adb (Add_Simple_Call_By_Copy_Code): Add
Bit_Packed_Array parameter and documet it. Always insert a copy
if it is set True.
(Expand_Actuals): Adjust the calls to
Add_Simple_Call_By_Copy_Code.

gcc/testsuite/

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

From-SVN: r275933

[Ada] gnatxref: infinite loop on symbols not found

This patch fixes a bug in which if a symbol is not found, gnatxref can
sometimes enter an infinite loop. No impact on compilation.

2019-09-19  Bob Duff  <duff@adacore.com>

gcc/ada/

* xref_lib.adb (Get_Symbol_Name): If we reach EOF in the first
loop without finding the symbol, return "???". Otherwise, it's
an infinite loop.
(Parse_EOL): Assert that we're not already at EOF.  Remove
processing of LF/CR -- there are no operating systems that use
that.

From-SVN: r275932

[Ada] Improve handling of explicit by-reference mechanism

This improves the handling of an explicit by-reference passing mechanism
specified by means of the GNAT pragma Export_Function.  This device sort
of circumvents the rules of the language for the by-reference passing
mechanism and it's then up to the programmer to ensure that the actual
parameter is addressable; if it is not, the compiler will generate a
temporary around the call, thus effectively passing the actual by copy.

It turns out that the compiler was too conservative when determining
whether the actual parameter is addressable, in particular if it's a
component of a record type subject to a representation clause.

The change effectively moves this computation from the front-end to the
back-end, which has much more information on the layout and alignment
of types and thus can be less conservative.

2019-09-19  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_ch6.adb (Is_Legal_Copy): Also return false for an aliased
formal and a formal passed by reference in convention Ada.  Add
missing guard to the existing test on Is_Valued_Procedure.

From-SVN: r275931

[Ada] Rtsfind: improve comment on RTE_Available

2019-09-19  Bob Duff  <duff@adacore.com>

gcc/ada/

* rtsfind.ads (RTE_Available): Improve comment.

From-SVN: r275930

tree-parloops.c (parloops_is_slp_reduction): Do not set LOOP_VINFO_OPERANDS_SWAPPED.

2019-09-19  Richard Biener  <rguenther@suse.de>

* tree-parloops.c (parloops_is_slp_reduction): Do not set
LOOP_VINFO_OPERANDS_SWAPPED.
(parloops_is_simple_reduction): Likewise.
* tree-vect-loop.c (_loop_vec_info::_loop_vec_info): Do not
initialize operands_swapped.
(_loop_vec_info::~_loop_vec_info): Do not re-canonicalize stmts.
(vect_is_slp_reduction): Do not swap operands.
* tree-vectorizer.h (_loop_vec_info::operands_swapped): Remove.
(LOOP_VINFO_OPERANDS_SWAPPED): Likewise.

From-SVN: r275928

Extend pass rpad to handle avx512f vcvtusi2ss vcvtusi2ss 538.imagick_r improved...

Extend pass rpad to handle avx512f vcvtusi2ss vcvtusi2ss
538.imagick_r improved by 4% with single copy run on SKYLAKE workstation.

gcc/
* config/i386/i386.md
(*floatuns<SWI48:mode><MODEF:mode>2_avx512):
Add avx_partial_xmm_update.

gcc/testsuie
* gcc.target/i386/pr87007-3.c: New test.

From-SVN: r275926

RISC-V: Fix more splitters accidentally calling gen_reg_rtx.

PR target/91683
* config/riscv/riscv-protos.h (riscv_split_symbol): New bool parameter.
(riscv_move_integer): Likewise.
* config/riscv/riscv.c (riscv_split_integer): Pass FALSE for new
riscv_move_integer arg.
(riscv_legitimize_move): Likewise.
(riscv_force_temporary): New parameter in_splitter.  Don't call
force_reg if true.
(riscv_unspec_offset_high): Pass FALSE for new riscv_force_temporary
arg.
(riscv_add_offset): Likewise.
(riscv_split_symbol): New parameter in_splitter.  Pass to
riscv_force_temporary.
(riscv_legitimize_address): Pass FALSE for new riscv_split_symbol
arg.
(riscv_move_integer): New parameter in_splitter.  New local
can_create_psuedo.  Don't call riscv_split_integer or force_reg when
in_splitter TRUE.
(riscv_legitimize_const_move): Pass FALSE for new riscv_move_integer,
riscv_split_symbol, and riscv_force_temporary args.
* config/riscv/riscv.md (low<mode>+1): Pass TRUE for new
riscv_move_integer arg.
(low<mode>+2): Pass TRUE for new riscv_split_symbol arg.

From-SVN: r275925

Daily bump.

From-SVN: r275924

libgo: support gollvm build on arm64 linux

    This CL serves as part of an initial change for enabling gollvm
    building on arm64 linux, the rest of the change will be covered by
    another one to the gollvm repo.

    Incorporate type definition of 'uint128' to 'runtime' and 'syscall'
    packges, the change is not specific to arm64 linux but made available
    for all platforms.

    Verified by building and unit-testing gollvm on linux x86-64 and arm64.

    Verified by building and checking gccgo on linux x86-64 and arm64.

    Fixes golang/go#33711

    Change-Id: I4720c7d810cfd4ef720962fb4104c5641b2459c0

From-SVN: r275919

[ARM] Add logical DImode expanders

We currently use default mid-end expanders for logical DImode operations.
These split operations without first splitting off complex immediates or
memory operands.  The resulting expansions are non-optimal and allow for
fewer LDRD/STRD opportunities.  So add back explicit expanders which ensure
memory operands and immediates are handled more efficiently.

    gcc/
PR target/91738
* config/arm/arm.md (<logical_op>di3): Expand explicitly.
(one_cmpldi2): Likewise.
* config/arm/arm.c (const_ok_for_dimode_op): Return true if one
of the constant parts is simple.
* config/arm/iterators.md (LOGICAL): Add new code iterator.
(logical_op): Add new code attribute.
(logical_OP): Likewise.
* config/arm/predicates.md (arm_anddi_operand): Add predicate.
(arm_iordi_operand): Add predicate.
(arm_xordi_operand): Add predicate.

From-SVN: r275907

i386: Restore Skylake SImode hard register store cost

On Skylake, we should move integer register to SSE register without
going through memory.  This patch restores Skylake SImode hard register
store cost to 6.

gcc/

PR target/90878
* config/i386/x86-tune-costs.h (skylake_cost): Restore SImode
hard register store cost to 6.

gcc/testsuite/

PR target/90878
* gcc.target/i386/pr90878.c: New test.

From-SVN: r275906

i386: Increase Skylake SImode pseudo register store cost

On Skylake, SImode store cost isn't less than half cost of 128-bit vector
store.  This patch increases Skylake SImode pseudo register store cost to
make it the same as QImode and HImode.

gcc/

PR target/91446
* config/i386/x86-tune-costs.h (skylake_cost): Increase SImode
pseudo register store cost from 3 to 6 to make it the same as
QImode and HImode.

gcc/testsuite/

PR target/91446
* gcc.target/i386/pr91446.c: New test.

From-SVN: r275905

[ARM] Cleanup 64-bit multiplies

Cleanup 64-bit multiplies.  Combine the expanders using iterators.
Merge the signed/unsigned multiplies as well as the pre-Armv6 and Armv6
variants.  Split DImode operands early into parallel sets inside the
MULL/MLAL instructions - this improves register allocation and avoids
subreg issues due to other DImode operations splitting early.

    gcc/
* config/arm/arm.md (maddsidi4): Remove expander.
(mulsidi3adddi): Remove pattern.
(mulsidi3adddi_v6): Likewise.
(mulsidi3_nov6): Likewise.
(mulsidi3_v6): Likewise.
(umulsidi3): Remove expander.
(umulsidi3_nov6): Remove pattern.
(umulsidi3_v6): Likewise.
(umulsidi3adddi): Likewise.
(umulsidi3adddi_v6): Likewise.
(<Us>mulsidi3): Add combined expander.
(<Us>maddsidi4): Likewise.
(<US>mull): Add combined umull and smull pattern.
(<US>mlal): Likewise.
* config/arm/iterators.md (Us): Add new iterator.

From-SVN: r275901

[ARM] Cleanup highpart multiply patterns

Cleanup the various highpart multiply patterns using iterators.
As a result the signed and unsigned variants and the pre-Armv6
multiply operand constraints are all handled in a single pattern
and simple expander.

    gcc/
* config/arm/arm.md (smulsi3_highpart): Use <US> and <SE> iterators.
(smulsi3_highpart_nov6): Remove pattern.
(smulsi3_highpart_v6): Likewise.
(umulsi3_highpart): Likewise.
(umulsi3_highpart_nov6): Likewise.
(umulsi3_highpart_v6): Likewise.
(<US>mull_high): Add new combined multiply pattern.

From-SVN: r275899

tree-vect-loop.c (vect_is_simple_reduction): Remove operand swapping.

2019-09-18  Richard Biener  <rguenther@suse.de>

* tree-vect-loop.c (vect_is_simple_reduction): Remove operand
swapping.
(vectorize_fold_left_reduction): Remove assert.
(vectorizable_reduction): Also expect COND_EXPR non-reduction
operand in position 2.  Remove assert.

From-SVN: r275898

[ARM] Cleanup multiply patterns

Cleanup the 32-bit multiply patterns.  Merge the pre-Armv6 with the Armv6
patterns, remove useless alternatives and order the accumulator operands
to prefer MLA Ra, Rb, Rc, Ra whenever feasible.

    gcc/
* config/arm/arm.md (arm_mulsi3): Remove pattern.
(arm_mulsi3_v6): Likewise.
(mulsi3addsi_v6): Likewise.
(mulsi3subsi): Likewise.
(mul): Add new multiply pattern.
(mla): Likewise.
(mls): Likewise.

From-SVN: r275897

tree-parloops.c (report_ploop_op): Copy from report_vect_op.

2019-09-18  Richard Biener  <rguenther@suse.de>

* tree-parloops.c (report_ploop_op): Copy from report_vect_op.
(parloops_valid_reduction_input_p): Copy from
valid_reduction_input_p.
(parloops_is_slp_reduction): Copy from vect_is_slp_reduction.
(parloops_needs_fold_left_reduction_p): Copy from
needs_fold_left_reduction_p.
(parloops_is_simple_reduction): Copy from
vect_is_simple_reduction.
(parloops_force_simple_reduction): Copy from
vect_force_simple_reduction.
(gather_scalar_reductions): Adjust.
* tree-vect-loop.c (vect_force_simple_reduction): Make static.
* tree-vectorizer.h (vect_force_simple_reduction): Remove.

From-SVN: r275896

Tweak clang-format configuration.

2019-09-18  Martin Liska  <mliska@suse.cz>

* clang-format: Tweak configuration based on new
options offered.

From-SVN: r275875

tree-vectorizer.h (get_initial_def_for_reduction): Remove.

2019-09-18  Richard Biener  <rguenther@suse.de>

* tree-vectorizer.h (get_initial_def_for_reduction): Remove.
* tree-vect-loop.c (get_initial_def_for_reduction): Make
static.
(vect_create_epilog_for_reduction): Remove dead code.

From-SVN: r275874

Make assemble_real generate canonical CONST_INTs

assemble_real used GEN_INT to create integers directly from the
longs returned by real_to_target.  assemble_integer then went on
to interpret the const_ints as though they had the mode corresponding
to the accompanying size parameter:

      imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0).require ();

      for (i = 0; i < size; i += subsize)
{
  rtx partial = simplify_subreg (omode, x, imode, i);

But in the assemble_real case, X might not be canonical for IMODE.

If the interface to assemble_integer is supposed to allow outputting
(say) the low 4 bytes of a DImode integer, then the simplify_subreg
above is wrong.  But if the number of bytes passed to assemble_integer
is supposed to be the number of bytes that the integer actually contains,
assemble_real is wrong.

This patch takes the latter interpretation and makes assemble_real
generate const_ints that are canonical for the number of bytes passed.

The flip_storage_order handling assumes that each long is a full
SImode, which e.g. excludes BITS_PER_UNIT != 8 and float formats
whose memory size is not a multiple of 32 bits (which includes
HFmode at least).  The patch therefore leaves that code alone.
If interpreting each integer as SImode is correct, the const_ints
that it generates are also correct.

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* varasm.c (assemble_real): Generate canonical const_ints.

From-SVN: r275873

re PR lto/91763 (go.go-torture/execute/printnil.go FAILs)

2019-09-18  Richard Biener  <rguenther@suse.de>

PR lto/91763
* lto-streamer-in.c (input_eh_regions): Move EH init to
lto_materialize_function.
* tree-streamer-in.c (lto_input_ts_function_decl_tree_pointers):
Likewise.

lto/
* lto.c (lto_materialize_function): Initialize EH by looking
at the function personality and flag_exceptions setting.

From-SVN: r275872

Make get_value_for_expr check for INTEGER_CSTs

CONSTANT lattice values are symbolic constants rather than
compile-time constants, so among other things can be POLY_INT_CSTs.
This patch fixes a case in which we assumed all CONSTANTs were either
ADDR_EXPRs or INTEGER_CSTs.

This is tested by later SVE patches.

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* tree-ssa-ccp.c (get_value_for_expr): Check whether CONSTANTs
are INTEGER_CSTs.

From-SVN: r275871

Don't treat variable-length vectors as VLAs during gimplification

Source-level SVE vectors should be gimplified in the same way
as normal fixed-length vectors rather than as VLAs.

This is tested by later SVE patches.

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* gimplify.c (gimplify_decl_expr): Use poly_int_tree_p instead
of checking specifically for INTEGER_CST.

From-SVN: r275870

Handle variable-length vectors in compute_record_mode

This patch makes compute_record_mode handle SVE vectors in the
same way as it would handle fixed-length vectors.  There should
be no change in behaviour for other targets.

This is needed for the SVE equivalent of arm_neon.h types like
int8x8x2_t (i.e. a pair of int8x8_ts).

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* stor-layout.c (compute_record_mode): Operate on poly_uint64
sizes instead of uhwi sizes.

From-SVN: r275869

Two more POLY_INT cases for dwarf2out.c

loc_list_for_tree_1 and add_const_value_attribute currently ICE
on POLY_INTs.  loc_list_for_tree_1 can do something sensible but
add_const_value_attribute has to punt, since the constant there
needs to be a link-time rather than load-time or run-time constant.

This is tested by later SVE patches.

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* dwarf2out.c (loc_list_from_tree_1): Handle POLY_INT_CST.
(add_const_value_attribute): Handle CONST_POLY_INT.

From-SVN: r275868

Come up with debug counter for store-merging.

2019-09-18  Martin Liska  <mliska@suse.cz>

* dbgcnt.def (store_merging): New counter.
* gimple-ssa-store-merging.c (imm_store_chain_info::output_merged_stores):
Use it in store merging.

From-SVN: r275867

[Ada] Avoid gnatbind regression caused by Copy_Bitfield

The recent Copy_Bitfield change caused gnatbind to change elaboration
order, causing different error messages.

2019-09-18  Bob Duff  <duff@adacore.com>

gcc/ada/

* exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Move call
to RTE_Available later, so it doesn't disturb the elab order.
The RE_Copy_Bitfield entity is defined in package
System.Bitfields which has a dependency on package
System.Bitfield_Utils, which has it its spec:

   pragma Elaborate_Body;

The query on RTE_Available forces loading and analyzing
System.Bitfields and all its withed units.

From-SVN: r275866

[Ada] Fix spurious alignment warning on simple address clause

This eliminates a spurious alignment warning given by the compiler on an
address clause when the No_Exception_Propagation restriction is in
effect and the -gnatw.x switch is used. In this configuration the
address clauses whose expression is itself of the form X'Address would
not be sufficiently analyzed and, therefore, the compiler might give
false positive warnings.

2019-09-18  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* checks.ads (Alignment_Warnings_Record): Add P component.
* checks.adb (Apply_Address_Clause_Check): Be prepared to kill
the warning also if the clause is of the form X'Address.
(Validate_Alignment_Check_Warning): Kill the warning if the
clause is of the form X'Address and the alignment of X is
compatible.

gcc/testsuite/

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

From-SVN: r275865

[Ada] Crash on universal case expression in fixed-point division

This patch fixes a compiler abort on a case expression whose
alternatives are universal_real constants, when the case expression is
an operand in a multiplication or division whose other operand is of a
fixed-point type.

2019-09-18  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

* sem_res.adb (Set_Mixed_Node_Expression): If a conditional
expression has universal_real alternaitves and the context is
Universal_Fixed, as when it is an operand in a fixed-point
multiplication or division, resolve the expression with a
visible fixed-point type, which must be unique.

gcc/testsuite/

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

From-SVN: r275864

[Ada] Use static discriminant value for discriminated task record

This patch allows the construction of a static subtype for the generated
constrained Secondary_Stack component of a task for which a stack size
is specified, when compiling for a restricted run-time that forbids
dynamic allocation. Needed for LLVM.

2019-09-18  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

* sem_ch3.adb (Constrain_Component_Type): For a discriminated
type, handle the case of a constraint given by a conversion of a
discriminant of the enclosing type. Necessary when compiling a
discriminated task for a restricted run-time, when the generated
Secondary_Stack component may be set by means of an aspect on
the task type.

From-SVN: r275863

[Ada] Crash on aggregate with dscriminant in if-expression as default

This patch fixes a crash on a an aggregate for a discriminated type,
when a component of the aggregate is also a discriminated type
constrained by a discriminant of the enclosing object, and the default
value for the component is a conditional expression that includes
references to that outer discriminant.

2019-09-18  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

* exp_aggr.adb (Expand_Record_Aggregate, Rewrite_Discriminant):
After rewriting a reference to an outer discriminant as a
selected component of the enclosing object, analyze the selected
component to ensure that the entity of the selector name is
properly set. This is necessary when the aggregate appears
within an expression that may have been analyzed already.

gcc/testsuite/

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

From-SVN: r275862

[Ada] Spurious ineffective use_clause warning

This patch fixes an issue whereby expansion of post conditions may lead
to spurious ineffective use_clause warnings when a use type clause is
present in a package specification and a use package clause exists in
the package body on the package containing said type.

2019-09-18  Justin Squirek  <squirek@adacore.com>

gcc/ada/

* sem_ch8.adb (Use_One_Type): Add guard to prevent warning on a
reundant use package clause where there is no previous
use_clause in the chain.

gcc/testsuite/

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

From-SVN: r275861

[Ada] Missing accessibility check on discrim assignment

This patch fixes an issue whereby assignments from anonymous access
descriminants which are part of stand alone objects of anonymous access
did not have runtime checks generated based on the accessibility level
of the object according to ARM 3.10.2 (12.5/3).

2019-09-18  Justin Squirek  <squirek@adacore.com>

gcc/ada/

* exp_ch4.adb (Expand_N_Type_Conversion): Add calculation of an
alternative operand for the purposes of generating accessibility
checks.

gcc/testsuite/

* gnat.dg/access8.adb, gnat.dg/access8_pkg.adb,
gnat.dg/access8_pkg.ads: New testcase.

From-SVN: r275860

[Ada] Fix sharing of expression in array aggregate with others choice

This change fixes a long-standing issue in the compiler that is
generally silent but may lead to wrong code generation in specific
circumstances.  When an others choice in an array aggregate spans
multiple ranges, the compiler may generate multiple (groups of)
assignments for the ranges.

The problem is that it internally reuses the original expression for all
the ranges, which is problematic if this expression gets rewritten
during the processing of one of the ranges and typically causes a new
temporary to be shared between different ranges.

The solution is to duplicate the original expression for each range.

2019-09-18  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* exp_aggr.adb (Build_Array_Aggr_Code): In STEP 1 (c), duplicate
the expression and reset the Loop_Actions for each loop
generated for an others choice.

gcc/testsuite/

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

From-SVN: r275859

[Ada] Spurious run time error on anonymous access formals

This patch fixes an issue whereby subprograms with anonymous access
formals may trigger spurious runtime accessibility errors when such
formals are used as actuals in calls to nested subprograms.

Running these commands:

  gnatmake -q pass.adb
  gnatmake -q fail.adb
  gnatmake -q test_main.adb
  gnatmake -q indirect_call_test.adb
  pass
  fail
  test_main
  indirect_call_test

On the following sources:

--  pass.adb

procedure Pass is

  function A (Param : access Integer) return Boolean is
    type Typ is access all Integer;
    function A_Inner (Param : access Integer) return Typ is
      begin
        return Typ (Param); --  OK
      end;
    begin
      return A_Inner (Param) = Typ (Param);
    end;

  function B (Param : access Integer) return Boolean;
  function B (Param : access Integer) return Boolean is
    type Typ is access all Integer;
    function B_Inner (Param : access Integer) return Typ is
      begin
        return Typ (Param); --  OK
      end;
    begin
      return B_Inner (Param) = Typ (Param);
    end;

  procedure C (Param : access Integer) is
    type Typ is access all Integer;
    Var : Typ;
    procedure C_Inner (Param : access Integer) is
      begin
        Var := Typ (Param); --  OK
      end;
    begin
      C_Inner (Param);
    end;

  procedure D (Param : access Integer);
  procedure D (Param : access Integer) is
    type Typ is access all Integer;
    Var : Typ;
    procedure D_Inner (Param : access Integer) is
      begin
        Var := Typ (Param); --  OK
      end;
    begin
      D_Inner (Param);
    end;

  protected type E is
    function G (Param : access Integer) return Boolean;
    procedure I (Param : access Integer);
  end;

  protected body E is
    function F (Param : access Integer) return Boolean is
      type Typ is access all Integer;
      function F_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  OK
        end;
      begin
        return F_Inner (Param) = Typ (Param);
      end;

    function G (Param : access Integer) return Boolean is
      type Typ is access all Integer;
      function G_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  OK
        end;
      B : Boolean := F (Param); --  OK
      begin
        return G_Inner (Param) = Typ (Param);
      end;

    procedure H (Param : access Integer) is
      type Typ is access all Integer;
      Var : Typ;
      procedure H_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  OK
        end;
      begin
        H_Inner (Param);
      end;

    procedure I (Param : access Integer) is
      type Typ is access all Integer;
      Var : Typ;
      procedure I_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  OK
        end;
      begin
        H (Param); --  OK
        I_Inner (Param);
      end;
  end;

  task type J is end;

  task body J is
    function K (Param : access Integer) return Boolean is
      type Typ is access all Integer;
      function K_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  OK
        end;
      begin
        return K_Inner (Param) = Typ (Param);
      end;

    function L (Param : access Integer) return Boolean;
    function L (Param : access Integer) return Boolean is
      type Typ is access all Integer;
      function L_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  OK
        end;
      begin
        return L_Inner (Param) = Typ (Param);
      end;

    procedure M (Param : access Integer) is
      type Typ is access all Integer;
      Var : Typ;
      procedure M_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  OK
        end;
      begin
        M_Inner (Param);
      end;

    procedure N (Param : access Integer);
    procedure N (Param : access Integer) is
      type Typ is access all Integer;
      Var : Typ;
      procedure N_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  OK
        end;
      begin
        N_Inner (Param);
      end;
    Var : aliased Integer := 666;
    begin
      if K (Var'Access) then null; end if; --  OK
      if L (Var'Access) then null; end if; --  OK
      M (Var'Access);                      --  OK
      N (Var'Access);                      --  OK
    end;

begin
  begin
    begin
      declare
      Var  : aliased Integer := 666;
      T    : J;
      Prot : E;
      begin
        if A (Var'Access) then null; end if;      --  OK
        if B (Var'Access) then null; end if;      --  OK
        C (Var'Access);                           --  OK
        D (Var'Access);                           --  OK
        if Prot.G (Var'Access) then null; end if; --  OK
        Prot.I (Var'Access);                      --  OK
      end;
    end;
  end;
end;

--  fail.adb

procedure Fail is
  Failures : Integer := 0;

  type Base_Typ is access all Integer;

  function A (Param : access Integer) return Boolean is
    subtype Typ is Base_Typ;
    function A_Inner (Param : access Integer) return Typ is
      begin
        return Typ (Param); --  ERROR
      end;
    begin
      return A_Inner (Param) = Typ (Param);
    exception
      when others => Failures := Failures + 1;
      return False;
    end;

  function B (Param : access Integer) return Boolean;
  function B (Param : access Integer) return Boolean is
    subtype Typ is Base_Typ;
    function B_Inner (Param : access Integer) return Typ is
      begin
        return Typ (Param); --  ERROR
      end;
    begin
      return B_Inner (Param) = Typ (Param);
    exception
      when others => Failures := Failures + 1;
      return False;
    end;

  procedure C (Param : access Integer) is
    subtype Typ is Base_Typ;
    Var : Typ;
    procedure C_Inner (Param : access Integer) is
      begin
        Var := Typ (Param); --  ERROR
      end;
    begin
      C_Inner (Param);
    exception
      when others => Failures := Failures + 1;
    end;

  procedure D (Param : access Integer);
  procedure D (Param : access Integer) is
    subtype Typ is Base_Typ;
    Var : Typ;
    procedure D_Inner (Param : access Integer) is
      begin
        Var := Typ (Param); --  ERROR
      end;
    begin
      D_Inner (Param);
    exception
      when others => Failures := Failures + 1;
    end;

  protected type E is
    function G (Param : access Integer) return Boolean;
    procedure I (Param : access Integer);
  end;

  protected body E is
    function F (Param : access Integer) return Boolean is
      subtype Typ is Base_Typ;
      function F_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  ERROR
        end;
      begin
        return F_Inner (Param) = Typ (Param);
      exception
        when others => Failures := Failures + 1;
        return False;
      end;

    function G (Param : access Integer) return Boolean is
      subtype Typ is Base_Typ;
      function G_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  ERROR
        end;
      B : Boolean := F (Param); --  ERROR
      begin
        return G_Inner (Param) = Typ (Param);
      exception
        when others => Failures := Failures + 1;
        return False;
      end;

    procedure H (Param : access Integer) is
      subtype Typ is Base_Typ;
      Var : Typ;
      procedure H_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  ERROR
        end;
      begin
        H_Inner (Param);
      exception
        when others => Failures := Failures + 1;
      end;

    procedure I (Param : access Integer) is
      subtype Typ is Base_Typ;
      Var : Typ;
      procedure I_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  ERROR
        end;
      begin
        H (Param); --  ERROR
        I_Inner (Param);
      exception
        when others => Failures := Failures + 1;
      end;
  end;

  task type J is end;

  task body J is
    function K (Param : access Integer) return Boolean is
      subtype Typ is Base_Typ;
      function K_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  ERROR
        end;
      begin
        return K_Inner (Param) = Typ (Param);
      exception
        when others => Failures := Failures + 1;
        return False;
      end;

    function L (Param : access Integer) return Boolean;
    function L (Param : access Integer) return Boolean is
      subtype Typ is Base_Typ;
      function L_Inner (Param : access Integer) return Typ is
        begin
          return Typ (Param); --  ERROR
        end;
      begin
        return L_Inner (Param) = Typ (Param);
      exception
        when others => Failures := Failures + 1;
        return False;
      end;

    procedure M (Param : access Integer) is
      subtype Typ is Base_Typ;
      Var : Typ;
      procedure M_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  ERROR
        end;
      begin
        M_Inner (Param);
      exception
        when others => Failures := Failures + 1;
      end;

    procedure N (Param : access Integer);
    procedure N (Param : access Integer) is
      subtype Typ is Base_Typ;
      Var : Typ;
      procedure N_Inner (Param : access Integer) is
        begin
          Var := Typ (Param); --  ERROR
        end;
      begin
        N_Inner (Param);
      exception
        when others => Failures := Failures + 1;
      end;
    Var : aliased Integer := 666;
    begin
      if K (Var'Access) then null; end if; --  ERROR
      if L (Var'Access) then null; end if; --  ERROR
      M (Var'Access);                      --  ERROR
      N (Var'Access);                      --  ERROR
    end;

begin
  begin
    begin
      declare
      Var  : aliased Integer := 666;
      T    : J;
      Prot : E;
      begin
        if A (Var'Access) then null; end if;      --  ERROR
        if B (Var'Access) then null; end if;      --  ERROR
        C (Var'Access);                           --  ERROR
        D (Var'Access);                           --  ERROR
        if Prot.G (Var'Access) then null; end if; --  ERROR
        Prot.I (Var'Access);                      --  ERROR
        if Failures /= 12 then
          raise Program_Error;
        end if;
      end;
    end;
  end;
end;

--  indirect_call_test.adb

with Text_IO;

procedure Indirect_Call_Test is

   Tracing_Enabled : constant Boolean := False;
   procedure Trace (S : String) is
   begin
      if Tracing_Enabled then
        Text_IO.Put_Line (S);
      end if;
   end;

   package Pkg is
      type Root is abstract tagged null record;
      function F (X : Root; Param : access Integer)
        return Boolean is abstract;
   end Pkg;

   function F_Wrapper
     (X : Pkg.Root; Param : access Integer)
     return Boolean
     is (Pkg.F (Pkg.Root'Class (X), Param));
     -- dispatching call

   function A (Param : access Integer) return Boolean is
      type Typ is access all Integer;

      package Nested is
         type Ext is new Pkg.Root with null record;
         overriding function F
           (X : Ext; Param : access Integer)
           return Boolean;
      end Nested;

      function A_Inner
        (Param : access Integer) return Typ is
      begin
         return Typ (Param);  -- OK
      end A_Inner;

      package body Nested is
         function F (X : Ext; Param : access Integer)
          return Boolean is
         begin
            return A_Inner (Param) = null;
         end;
      end;

       Ext_Obj : Nested.Ext;
   begin
       Trace ("In subtest A");
       return F_Wrapper (Pkg.Root (Ext_Obj), Param);
   exception
      when Program_Error =>
          Trace ("Failed");
          return True;
   end A;

   function B (Param : access Integer) return Boolean is
      type Typ is access all Integer;

      function B_Inner
        (Param : access Integer) return Typ is
      begin
         return Typ (Param); -- OK
      end B_Inner;

      type Ref is access function
         (Param : access Integer) return Typ;
      Ptr : Ref := B_Inner'Access;

      function Ptr_Caller return Typ is
        (Ptr.all (Param)); -- access-to-subp value
   begin
      Trace ("In subtest B");
      return Ptr_Caller = null;
   exception
      when Program_Error =>
          Trace ("*** failed");
          return True;
   end B;

begin
   begin
      begin
         declare
            Var : aliased Integer := 666;
         begin
            if A (Var'Access) then
               null;
            end if;
            Trace ("Subtest A done");
            if B (Var'Access) then
               null;
            end if;
            Trace ("Subtest B done");
         end;
      end;
   end;
end Indirect_Call_Test;

Should produce the following output:

  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure
  Failure

2019-09-18  Justin Squirek  <squirek@adacore.com>

gcc/ada/

* einfo.adb, einfo.ads (Minimum_Accessibility): Added new field.
(Set_Minimum_Accessibility): Added to set new field.
(Minimum_Accessibility): Added to fetch new field.
* exp_ch6.adb (Expand_Subprogram_Call): Modify calls to fetch
accessibility levels to the new subprogram Get_Accessibility
which handles cases where minimum accessibility might be needed.
* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Add section to
generate a Minimum_Accessibility object within relevant
subprograms.
* sem_util.adb, sem_util.ads (Dynamic_Accessibility_Level):
Additional documentation added and modify section to use new
function Get_Accessibility.
(Get_Accessibility): Added to centralize processing of
accessibility levels.

From-SVN: r275858

[Ada] Implement AI12-0086's rules for discriminants in aggregates

In Ada2012, a discriminant value that governs an active variant part in
an aggregate had to be static. AI12-0086 relaxes this restriction - if
the subtype of the discriminant value is a static subtype all of whose
values select the same variant, then that is good enough.

2019-09-18  Steve Baird  <baird@adacore.com>

gcc/ada/

* sem_util.ads (Interval_Lists): A new visible package. This
package is visible because it is also intended for eventual use
in Sem_Eval.Subtypes_Statically_Compatible when that function is
someday upgraded to handle static predicates correctly.  This
new package doesn't really need to be visible for now, but it
still seems like a good idea.
* sem_util.adb (Gather_Components): Implement AI12-0086 via the
following strategy. The existing code knows how to take a static
discriminant value and identify the corresponding variant; in
the newly-permitted case of a non-static value of a static
subtype, we arbitrarily select a value of the subtype and find
the corresponding variant using the existing code. Subsequently,
we check that every other value of the discriminant's subtype
corresponds to the same variant; this is done using the newly
introduced Interval_Lists package.
(Interval_Lists): Provide a body for the new package.

gcc/testsuite/

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

From-SVN: r275857

[Ada] Fix portability issues in access to subprograms

This patch improves the portability of the code generated by the
compiler for access to subprograms. Written by Richard Kenner.

2019-09-18  Javier Miranda  <miranda@adacore.com>

gcc/ada/

* exp_ch4.adb (Expand_N_Op_Eq): The frontend assumes that we can
do a bit-for-bit comparison of two access to protected
subprogram pointers. However, there are two reasons why we may
not be able to do that: (1) there may be padding bits for
alignment before the access to subprogram, and (2) the access to
subprogram itself may not be compared bit-for- bit because the
activation record part is undefined: two pointers are equal iff
the subprogram addresses are equal. This patch fixes it by
forcing a field-by-field comparison.
* bindgen.adb (Gen_Adainit): The type No_Param_Proc is defined
in the library as having Favor_Top_Level, but when we create an
object of that type in the binder file we don't have that
pragma, so the types are different. This patch fixes this issue.
* libgnarl/s-interr.adb, libgnarl/s-interr__hwint.adb,
libgnarl/s-interr__sigaction.adb, libgnarl/s-interr__vxworks.adb
(Is_Registered): This routine erroneously assumes that the
access to protected subprogram is two addresses. We need to
create the same record that the compiler makes to ensure that
any padding is the same. Then we have to look at just the first
word of the access to subprogram. This patch fixes this issue.

From-SVN: r275856

[Ada] Improve efficiency of copying bit-packed slices

This patch substantially improves the efficiency of copying large slices
of bit-packed arrays, by copying 32 bits at a time instead of 1 at a
time.

2019-09-18  Bob Duff  <duff@adacore.com>

gcc/ada/

* exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): The call
to Copy_Bitfield is now enabled.
(Expand_Assign_Array_Bitfield): Multiply 'Length times
'Component_Size "by hand" instead of using 'Size.

From-SVN: r275855

[Ada] Fix minor formatting issue

2019-09-18  Vasiliy Fofanov  <fofanov@adacore.com>

gcc/ada/

* doc/gnat_rm/implementation_defined_pragmas.rst: Fix minor
formatting issue.

From-SVN: r275854

[Ada] Code cleanup of alignment representation clauses in dispatch tables

This patch does not modify the functionality of the compiler; it avoids
generating non-required alignment representation clauses for dispatch
tables.

2019-09-18  Javier Miranda  <miranda@adacore.com>

gcc/ada/

* exp_disp.adb (Make_DT, Make_Secondary_DT): Remove generation
of alignment representation clause for the following tables:
Predef_Prims, Iface_DT, TSD, ITable, DT.

From-SVN: r275853

[Ada] Don't fail a front-end assertion if errors have already been detected

In sem_eval.adb, we have an assertion that the type of a "null" literal
is an access type. It turns out that this assertion can fail when
processing an illegal program, e.g. one that contains something like
"Integer'(null)".  This leads to differences in the compiler's generated
output for such tests depending on whether assertions are/aren't
enabled; in particular, the "compilation abandoned due to previous
error" message generated in Comperr.Compiler_Abort. In order to avoid
these differences, we change the assertion so that it does not fail if
errors have already been posted on the given node.

2019-09-18  Steve Baird  <baird@adacore.com>

gcc/ada/

* sem_eval.adb (Expr_Value): Do not fail "the type of a null
literal must be an access type" assertion if errors have already
been posted on the given node.

From-SVN: r275852

[Ada] Refine type of Get_Homonym_Number result

Routine Get_Homonym_Number always returns a positive number. This is
explained in its comment and is evident from its body. No test attached,
because semantics is unaffected.

2019-09-18  Piotr Trojanek  <trojanek@adacore.com>

gcc/ada/

* exp_dbug.ads, exp_dbug.adb (Get_Homonym_Number): Refine type
from Nat to Pos.
* sem_util.adb (Add_Homonym_Suffix): Refine type of a local
variable.

From-SVN: r275851

[Ada] Skip entity name qualification in GNATprove mode

GNATprove was using the qualification of names for entities with local
homonyms in the same scope, requiring the use of a suffix to
differentiate them. This caused problems for correctly identifying
primitive equality operators. This case is now handled like the rest of
entities in GNATprove, by instead updating Unique_Name to append the
suffix on-the-fly where needed.

There is no impact on compilation and hence no test.

2019-09-18  Yannick Moy  <moy@adacore.com>

gcc/ada/

* exp_dbug.adb (Append_Homonym_Number): Use new function
Get_Homonym_Number.
(Get_Homonym_Number): New function to return the homonym number.
(Qualify_Entity_Name): Remove special case for GNATprove.
* exp_dbug.ads (Get_Homonym_Number): Make the new function
public for use in GNATprove.
* frontend.adb (Frontend): Do not qualify names in GNATprove
mode.
* sem_util.adb (Unique_Name): Append homonym suffix where needed
for entities which have local homonyms in the same scope.

From-SVN: r275850

[Ada] Ensure that Scan_Real result does not depend on trailing zeros

Previous change in that procedure to handle overflow issues during
scanning removed the special handling for trailing zeros in the decimal
part. Beside the absence of overflow during scanning the special
handling of these zeros is still necessary.

2019-09-18  Nicolas Roche  <roche@adacore.com>

gcc/ada/

* libgnat/s-valrea.adb (Scan_Integral_Digits): New procedure.
(Scan_Decimal_Digits): New procedure.
(As_Digit): New function.
(Scan_Real): Use Scan_Integral_Digits and Scan_Decimal_Digits.

gcc/testsuite/

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

From-SVN: r275849

[Ada] Factor out code for deciding statically known Constrained attributes

Create a separate routine in Exp_Util for deciding the value of the
Constrained attribute when it is statically known. This routine is used
in Exp_Attr and will be reused in the backend of GNATprove.

There is no impact on compilation and hence no test.

2019-09-18  Claire Dross  <dross@adacore.com>

gcc/ada/

* exp_attr.adb (Expand_N_Attribute_Reference): Call routine from
Exp_Util to know the value of the Constrained attribute in the
static case.
* exp_spark.adb (Expand_SPARK_N_Attribute_Reference): Make
implicit dereferences inside the Constrained attribute explicit.
* exp_util.ads, exp_util.adb
(Attribute_Constrained_Static_Value): New routine to compute the
value of a statically known reference to the Constrained
attribute.

From-SVN: r275848

[Ada] Raise exception on call to Expect for a dead process

Call to Expect for a dead process results in SIGBUS signal on Linux
systems. Process_Died exception is raised in this case now.

2019-09-18  Vadim Godunko  <godunko@adacore.com>

gcc/ada/

* libgnat/g-expect.adb (Expect_Internal): Don't include invalid
file descriptors into the set of file descriptors for Poll.
Raise Process_Died exception when computed set of file
descriptors to monitor is empty.

gcc/testsuite/

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

From-SVN: r275847

[Ada] Fix errno for rename for the VxWorks 6 target

This fixes the wrong errno for rename when the file is not existing on a
dosFs. In the end it makes Ada.Directories.Rename raising the right
exception in the case we are trying to move a file in a non existing
directory.

2019-09-18  Frederic Konrad  <konrad@adacore.com>

gcc/ada/

* adaint.c: Include dosFsLib.h and vwModNum.h for VxWorks 6.
(__gnat_rename): Map S_dosFsLib_FILE_NOT_FOUND to ENOENT.

From-SVN: r275846

[Ada] No Storage_Error for an oversized disabled ghost array object

In some cases where the size computation for an object declaration will
unconditionally overflow, the FE generates code to raise Storage_Error
at the point of the object declaration (and may generate an associated
warning). Don't do this if the object declaration is an ignored (i.e.,
disabled) ghost declaration.

2019-09-18  Steve Baird  <baird@adacore.com>

gcc/ada/

* freeze.adb (Freeze_Object_Declaration): Do not call
Check_Large_Modular_Array when the object declaration being
frozen is an ignored ghost entity.

gcc/testsuite/

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

From-SVN: r275845

[Ada] Fix typo in error message

An error message mentions "gnamake", where it meant to mention
"gnatmake".

2019-09-18  Tom Tromey  <tromey@adacore.com>

gcc/ada/

* make.adb (Initialize): Fix typo.

From-SVN: r275844

[Ada] Fix 32/64bit mistake on SYSTEM_INFO component in s-win32

The dwActiveProcessorMask field in a SYSTEM_INFO structure on Windows
should be DWORD_PTR, an integer the size of a pointer.

In s-win32, it is currently declared as DWORD. This happens to work on
32bit hosts and is wrong on 64bit hosts, causing mishaps in accesses to
this component and all the following ones.

The proposed correction adds a definition for DWORD_PTR and uses it for
dwActiveProcessorMask in System.Win32.SYSTEM_INFO.

2019-09-18  Olivier Hainque  <hainque@adacore.com>

gcc/ada/

* libgnat/s-win32.ads (DWORD_PTR): New type, pointer size
unsigned int.
(SYSTEM_INFO): Use it for dwActiveProcessorMask.

gcc/testsuite/

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

From-SVN: r275843

[Ada] Improve doc on Warning_As_Error

2019-09-18  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

* doc/gnat_rm/implementation_defined_pragmas.rst: Improve doc on
Warning_As_Error.
* gnat_rm.texi: Regenerate.

From-SVN: r275842

[Ada] Remove remaining references to VMS support

2019-09-18  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

* doc/gnat_rm/implementation_defined_characteristics.rst,
doc/gnat_rm/implementation_defined_pragmas.rst,
doc/gnat_rm/implementation_of_specific_ada_features.rst: Remove
remaining references to VMS support
* gnat_rm.texi: Regenerate.

From-SVN: r275841

[Ada] System.Stack_Usage: fix a typo

2019-09-18  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

* libgnat/s-stausa.adb: Fix a typo

From-SVN: r275840

[Ada] Avoid uninitialized variable in bounded containers

In function Copy in Ada.Containers.Bounded_Ordered_Sets and other
bounded containers packages, remove a possible use of an uninitialized
variable. This was not a bug, because the uninitialized variable could
be used only if checks are suppressed, and the checks would have failed,
leading to erroneous execution.

However, it seems more robust this way, and is probably equally
efficient, and avoids a warning that is given if checks are suppressed,
and the -Wall switch is given, and optimization is turned on.

2019-09-18  Bob Duff  <duff@adacore.com>

gcc/ada/

* libgnat/a-cbhama.adb, libgnat/a-cbhase.adb,
libgnat/a-cbmutr.adb, libgnat/a-cborma.adb,
libgnat/a-cborse.adb, libgnat/a-cobove.adb (Copy): Avoid reading
the uninitialized variable C in the Checks = False case. Change
variable to be a constant.

gcc/testsuite/

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

From-SVN: r275839

[Ada] Fix style issues in functional maps

Rename global constants from I to J. No functional changes.

2019-09-18  Claire Dross  <dross@adacore.com>

gcc/ada/

* libgnat/a-cofuma.adb (Remove, Elements_Equal_Except,
Keys_Included, Keys_Included_Except): Rename loop indexes and
global constants from I to J.

From-SVN: r275838

[Ada] Refine previous change for -gnatn and LLVM

2019-09-18  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

* exp_unst.adb (Unnest_Subprograms): Refine previous change.

From-SVN: r275837

[x86] Tweak testcases for PR82361

gcc/testsuite/gcc.target/i386/pr82361-[12].c check whether we
can optimise away a 32-to-64-bit zero extension of a 32-bit
division or modulus result.  Currently this fails for the modulus
part of f1 and f2 in pr82361-1.c:

/* FIXME: We are still not able to optimize the modulo in f1/f2, only manage
   one.  */
/* { dg-final { scan-assembler-times "movl\t%edx" 2 } } */

pr82361-2.c instead expects no failures:

/* Ditto %edx to %rdx zero extensions.  */
/* { dg-final { scan-assembler-not "movl\t%edx, %edx" } } */

But we actually get the same zero-extensions for f1 and f2 in pr82361-2.c.
The reason they don't trigger a failure is that the RA allocates the
asm input for "d" to %rdi rather than %rdx, so we have:

movl %rdx, %rdi

instead of:

movl %rdx, %rdx

For the tests to work as expected, I think they have to force "c" and
"d" to be %rax and %rdx respectively.  We then see the same failure in
pr82361-2.c as for pr82361-1.c (but doubled, due to the 8-bit division
path).

2019-09-18  Richard Sandiford  <richard.sandiford@arm.com>

gcc/testsuite/
* gcc.target/i386/pr82361-1.c (f1, f2, f3, f4, f5, f6): Force
"c" to be in %rax and "d" to be in %rdx.
* gcc.target/i386/pr82361-2.c: Expect 4 instances of "movl\t%edx".

From-SVN: r275836

Daily bump.

From-SVN: r275833

runtime: for FFI, treat directIface types as pointers

    This only matters on systems that pass a struct with a single pointer
    field differently than passing a single pointer.  I noticed it on
    32-bit PPC, where the reflect package TestDirectIfaceMethod failed.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/195878

From-SVN: r275814

re PR go/91781 (r275691 breaks go test "reflect")

PR go/91781
    reflect: promote integer closure return to full word

    The libffi library expects an integer return type to be promoted to a
    full word.  Implement that when returning from a closure written in Go.
    This only matters on big-endian systems when returning an integer smaller
    than the pointer size, which is why we didn't notice it until now.

    Fixes https://gcc.gnu.org/PR91781.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/195858

From-SVN: r275813

reflect: unexport FFICallbackGo; use go:linkname instead

    The function was always intended to be internal-only, but was exported
    so that C code could call it. Now that have go:linkname for that, use it.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/195857

From-SVN: r275809

[arm][aarch64] Handle no_insn in TARGET_SCHED_VARIABLE_ISSUE

Since no_insn patterns expand to no instructions, they shouldn't
count against the issue rate, just like USEs and CLOBBERs don't.

2019-09-17  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* config/aarch64/aarch64.c (aarch64_sched_variable_issue): New
function.
(TARGET_SCHED_VARIABLE_ISSUE): New macro.
* config/arm/arm.c (arm_sched_variable_issue): New function.
(TARGET_SCHED_VARIABLE_ISSUE): New macro.

From-SVN: r275808

[arm][aarch64] Make no_insn issue to nothing

no_insn is documented as:

  an insn which does not represent an instruction in the final output,
  thus having no impact on scheduling.

and is used in that way by the arm port (e.g. for define_insns that
expand to comments).  However, most scheduling descriptions instead
assigned units to no_insn patterns, in some cases treating them as more
expensive than a plain move.

This patch removes the no_insn handling from individual scheduling
descriptions and uses a common define_insn_reservation for all CPUs.

2019-09-17  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* config/arm/types.md (no_reservation): New reservation.
* config/aarch64/falkor.md (falkor_other_0_nothing): Don't handle
no_insn here.
* config/aarch64/saphira.md (saphira_other_0_nothing): Likewise.
* config/aarch64/thunderx2t99.md (thunderx2t99_nothing): Likewise.
* config/aarch64/tsv110.md (tsv110_alu): Likewise.
* config/arm/arm1020e.md (1020alu_op): Likewise.
* config/arm/arm1026ejs.md (alu_op): Likewise.
* config/arm/arm1136jfs.md (11_alu_op): Likewise.
* config/arm/arm926ejs.md (9_alu_op): Likewise.
* config/arm/cortex-a15.md (cortex_a15_alu): Likewise.
* config/arm/cortex-a17.md (cortex_a17_alu): Likewise.
* config/arm/cortex-a5.md (cortex_a5_alu): Likewise.
* config/arm/cortex-a53.md (cortex_a53_alu): Likewise.
* config/arm/cortex-a57.md (cortex_a57_alu): Likewise.
* config/arm/cortex-a7.md (cortex_a7_alu_shift): Likewise.
* config/arm/cortex-a8.md (cortex_a8_alu): Likewise.
* config/arm/cortex-a9.md (cortex_a9_dp): Likewise.
* config/arm/cortex-m4.md (cortex_m4_alu): Likewise.
* config/arm/cortex-m7.md (cortex_m7_alu_simple): Likewise.
* config/arm/cortex-r4.md (cortex_r4_alu_shift_reg): Likewise.
* config/arm/fa526.md (526_alu_op): Likewise.
* config/arm/fa606te.md (606te_alu_op): Likewise.
* config/arm/fa626te.md (626te_alu_op): Likewise.
* config/arm/fa726te.md (726te_alu_op): Likewise.
* config/arm/xgene1.md (xgene1_nop): Likewise.

From-SVN: r275807

[arm] Fix insn type of *thumb1_tablejump

*thumb1_tablejump had type "no_insn", which doesn't seems to correspond
to its documented use:

  an insn which does not represent an instruction in the final output,
  thus having no impact on scheduling.

Indirect jumps use the same instruction and have type "branch",
so the patch uses "branch" here too.

2019-09-17  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* config/arm/thumb1.md (*thumb1_tablejump): Change type from
"no_insn" to "branch".

From-SVN: r275806

Remove name of unused parameter in array-traits.h

2019-09-17  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* array-traits.h (array_traits<T[N]>::size): Remove parameter name.

From-SVN: r275805

re PR debug/91772 (ICE in add_dwarf_attr, at dwarf2out.c:4412 since r259749)

2019-09-17  Richard Biener  <rguenther@suse.de>

PR debug/91772
* dwarf2out.c (dwarf2out_late_global_decl): If early dwarf
was missing generate locations only once.

From-SVN: r275804

[ARM/FDPIC v6 20/24] [ARM][testsuite] FDPIC: Skip tests using architectures unsupported by FDPIC

Since FDPIC currently supports arm and thumb-2 modes only, these tests
fail because they enforce an architecture version that doesn't match
these restrictions.

This patch introduces new values for the arm_arch effective-target
(v4t_thumb, v5t_thumb, v5te_thumb, v6_thumb, v6k_thumb, v6z_thumb) as
needed, and adds them to the relevant tests.  In addition, it adds
v4t_arm, v5t_arm, v5te_arm, v6_arm, v6k_arm and v6z_arm to avoid
skipping some tests when GCC is configured to generate Thumb code by
default.

It also adds the corresponding non-thumb effective-target to the tests
that were missing it.

The existing v4t, v5t, v5te, v6 v6k and v6z effective-targets now force
-mfloat-abi=softfp since these thumb-1 targets do not support
hard-float anyway.

Finally, the patch removes the special case to detect the presence of
-marm in the flags, since it makes atomic_loaddi tests unsupported:
since the flags in question also include -march, the combination is
supported, while -marm alone is not if GCC is configured to target an
M-profile CPU.

2019-19-17  Christophe Lyon  <christophe.lyon@st.com>

* lib/target-supports.exp
(check_effective_target_arm_arch_FUNC_ok): Add v4t_arm, v4t_thumb,
v5t_arm, v5t_thumb, v5te_arm, v5te_thumb, v6_arm, v6_thumb,
v6k_arm, v6k_thumb, v6z_arm, v6z_thumb.
Add -mfloat-abi=softfp to v4t, v5t, v5te, v6, v6k, v6z.
Remove early exit for -marm.
* gcc.target/arm/armv6-unaligned-load-ice.c: Add arm_arch
effective-target.
* gcc.target/arm/attr-unaligned-load-ice.c: Likewise.
* gcc.target/arm/ftest-armv4-arm.c: Likewise.
* gcc.target/arm/ftest-armv4t-arm.c: Likewise.
* gcc.target/arm/ftest-armv4t-thumb.c: Likewise.
* gcc.target/arm/ftest-armv5t-arm.c: Likewise.
* gcc.target/arm/ftest-armv5t-thumb.c: Likewise.
* gcc.target/arm/ftest-armv5te-arm.c: Likewise.
* gcc.target/arm/ftest-armv5te-thumb.c: Likewise.
* gcc.target/arm/ftest-armv6-arm.c: Likewise.
* gcc.target/arm/ftest-armv6-thumb.c: Likewise.
* gcc.target/arm/ftest-armv6k-arm.c: Likewise.
* gcc.target/arm/ftest-armv6k-thumb.c: Likewise.
* gcc.target/arm/ftest-armv6m-thumb.c: Likewise.
* gcc.target/arm/ftest-armv6t2-arm.c: Likewise.
* gcc.target/arm/ftest-armv6t2-thumb.c: Likewise.
* gcc.target/arm/ftest-armv6z-arm.c: Likewise.
* gcc.target/arm/ftest-armv6z-thumb.c: Likewise.
* gcc.target/arm/g2.c: Likewise.
* gcc.target/arm/macro_defs1.c: Likewise.
* gcc.target/arm/pr59858.c: Likewise.
* gcc.target/arm/pr65647-2.c: Likewise.
* gcc.target/arm/pr79058.c: Likewise.
* gcc.target/arm/pr83712.c: Likewise.
* gcc.target/arm/pragma_arch_switch_2.c: Likewise.
* gcc.target/arm/scd42-1.c: Likewise.
* gcc.target/arm/scd42-2.c: Likewise.
* gcc.target/arm/scd42-3.c: Likewise.
* gcc.c-torture/compile/pr82096.c: Fix arm_arch effective-target.
* gcc.target/arm/attr_arm-err.c: Likewise.
* gcc.target/arm/di-longlong64-sync-withldrexd.c: Likewise.

From-SVN: r275803

PR ipa/91089 - Setup predicate for switch default case in IPA

2019-09-17  Feng Xue  <fxue@os.amperecomputing.com>

        PR ipa/91089
        * doc/invoke.texi (ipa-max-switch-predicate-bounds): Document new
        option.
        * params.def (PARAM_IPA_MAX_SWITCH_PREDICATE_BOUNDS): New.
        * ipa-fnsummary.c (set_switch_stmt_execution_predicate): Add predicate
        for switch default case using range analysis information.

2019-09-17  Feng Xue  <fxue@os.amperecomputing.com>

        PR ipa/91089
        * gcc.dg/ipa/pr91089.c: New test.

From-SVN: r275802

re PR fortran/91588 (ICE in check_inquiry, at fortran/expr.c:2673)

2019-09-17  Paul Thomas  <pault@gcc.gnu.org>

PR fortran/91588
* expr.c (check_inquiry): Remove extended component refs by
using symbol pointers. If a function argument is an associate
variable with a constant target, copy the target expression in
place of the argument expression. Check that the charlen is not
NULL before using the string length.
(gfc_check_assign): Remove extraneous space.

2019-09-17  Paul Thomas  <pault@gcc.gnu.org>

PR fortran/91588
* gfortran.dg/associate_49.f90 : New test.

From-SVN: r275800

[PR91749][arm] FDPIC: Handle -mflip-thumb

2019-09-16  Christophe Lyon  <christophe.lyon@linaro.org>

PR target/91749
* config/arm/arm.c (arm_valid_target_attribute_rec): Make sure the
mode attributed is supported by FDPIC.

From-SVN: r275799

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

2019-09-17  Richard Biener  <rguenther@suse.de>

PR tree-optimization/91790
* tree-vect-stmts.c (vectorizable_load): For BB vectorization
use the correct DR for setting up realignment.

From-SVN: r275798

[Ada] Add Remove primitive on functional maps

A primitive for removing a mapping from a functional map has been added.

2019-09-17  Claire Dross  <dross@adacore.com>

gcc/ada/

* libgnat/a-cofuma.ads, libgnat/a-cofuma.adb (Remove): New
function which returns a copy of the input container without a
given mapping.

From-SVN: r275797

[Ada] Fix rounding of fixed-point arithmetic operation

Fixed-point multiplication, division and conversion may lead to calling
the function Double_Divide in s-arit64 runtime unit. In the special case
where arguments have the special values X = -2**63 and the absolute
value of the product of its other arguments Y*Z = 2**64, the rounded
value should be either -1 or 1, but currently Double_Divide returns a
quotient of 0.

Rounding only applies when Round attribute is called on the arithmetic
operation for a decimal fixed-point result, or the result type is
integer.

This fixes correctly applies rounding away from 0 in that special case.

2019-09-17  Yannick Moy  <moy@adacore.com>

gcc/ada/

* libgnat/s-arit64.adb (Double_Divide): Correctly handle the
special case when rounding.

gcc/testsuite/

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

From-SVN: r275796

[Ada] Missing propagation of Has_Predicates in cloned subtypes

The frontend silently skips propagating attributes Has_Predicates and
Predicate function to the internally built cloned subtype. This change
does not affect the functionality of the compiler; it leaves more clean
the decoration of internal entities.

2019-09-17  Javier Miranda  <miranda@adacore.com>

gcc/ada/

* sem_ch3.adb (Complete_Private_Subtype): Propagate attributes
Has_Attributes and Predicate_Function to the cloned subtype.

From-SVN: r275795

[Ada] Fix ineffective -gnatyN for separate compilation units

This fixes a recent regression introduced in the machinery giving style
warnings: the -gnatyN switch no longer cancels an earlier -gnaty switch
for separate compilation units.

Running this command:

  gcc -c slib.adb -gnatyaAbcefhiIklmM25OnprStux -gnatyN

On the following sources:

package Slib is
   procedure I_Am_Short;
end Slib;

with Ada.Text_IO; use Ada.Text_IO;

package body Slib is
   --  have a long line here as well.
   procedure                I_Am_Short is               separate;
end Slib;

separate (Slib)

procedure I_Am_Short is
begin
    Put_Line (".......................................................");
end I_Am_Short;

Should execute silently.

2019-09-17  Eric Botcazou  <ebotcazou@adacore.com>

gcc/ada/

* sem.adb (Do_Analyze): Save Style_Check_Max_Line_Length on
entry and restore it on exit instead of recomputing it.

From-SVN: r275794