[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

[Ada] Update the character type comment in exp_dbug.ads

The character type comment in exp_dbug.ads documented the QU and QW
encodings, but did not document the plain "Qc" encoding, where 'c' is
the character itself.  This patch updates the comment to follow the
implementation.

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

gcc/ada/

* exp_dbug.ads: Update character type comment.

From-SVN: r275793

[Ada] Minor fixes mostly in comments of runtime arithmetic unit

Multiple comments in functions Double_Divide and Scaled_Divide were
incorrect. Now fixed.

Also change the expression (if Zhi /= 0 then Ylo * Zhi else 0) to the
simpler equivalent (Ylo * Zhi) in Double_Divide.

Also add a comment explaining why the implementation of Algorithm D for
multiple-precision division from the 2nd Edition of The Art of Computer
Programming does not suffer from two bugs discovered on that version.

There is no impact on execution, hence no test.

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

gcc/ada/

* libgnat/s-arit64.adb (Double_Divide): Simplify needlessly
complex computation. Fix comments.
(Scaled_Divide): Fix comments. Explain why implementation does
not suffer from bugs in Algorithm D from 2nd Edition of TAOCP.

From-SVN: r275792

[Ada] Raise Constraint_Error in overflow case involving rounding

Function Scaled_Divide in s-arith runtime unit computes the combined
multiplication and division of its arguments ((X*Y) / Z). In a very
special case where the quotient computed before rounding is 2**64-1,
then rounding may lead to undesirable wrap-around, leading to a computed
quotient of 0 instead of raising Constraint_Error as expected.

This function is only called in the runtime for arithmetic operations
involving fixed-point types. Rounding is performed only when the target
type is of a decimal fixed-point type, and the attribute 'Round of the
type is used to round the result of the arithmetic operation.

This fix correctly raises Constraint_Error in this special case.

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

gcc/ada/

* libgnat/s-arit64.adb (Scaled_Divide): Add protection against
undesirable wrap-around.

gcc/testsuite/

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

From-SVN: r275791

[Ada] Fix possible suppressed overflows in arithmetic run-time

Function Double_Divide computes the division of its parameters
(X / (Y*Z)) in a way that avoids overflows on signed integers, except in
two specific cases, when X = -2**63, abs(Y) = abs(Z) = 1 (leading to an
overflow in -To_Int(Qu)) and when X = -2**63 and Y*Z is large enough
that Qu=0 and so the remainder Ru=2**63 (leading to an overflow in
-To_Int(Ru)), for example with Y = Z = 2**32-1.

This fix avoids the overflow by applying "-" on the unsigned value
before the conversion to signed integer.

The issue cannot manifest as an overflow check failure in our runtime,
as overflow checks are suppressed by using pragma Suppress at the start
of the file. Assuming a machine implements wraparound semantics here,
the result was correct even with the suppressed overflow.

As a result, there can be no test showing the difference.

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

gcc/ada/

* libgnat/s-arit64.adb (Double_Divide): Fix two possible
overflows.

From-SVN: r275790

[Ada] Force even timestamp in Windows ALI files

Old versions forced even file timestamp in Windows in
GNAT.OS_Lib.GM_Split implementation. We removed this time distortion in
GNAT.OS_Lib.GM_Split a few commits. But gprbuild became unnecessary
recompiling the sources in 50% cases, when the source has odd file
timestamp. This commit is restoring the compatibility between new
gprbuild and old GNAT compilers.

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

gcc/ada/

* make_util.ads (On_Windows): Move...
* osint.ads (On_Windows): There.
* osint.adb (OS_Time_To_GNAT_Time): If odd incremented on
Windows before conversion to Time_Stamp_Type.

From-SVN: r275789

[Ada] GNATprove: avoid crash on illegal borrow during package elaboration

In GNATprove, a borrow during package elaboration is illegal, but a
crash could be issued when analyzing the corresponding declaration. Now
avoid analyzing the declaration in that case.

There is no test as this does not impact compilation.

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

gcc/ada/

* sem_spark.adb (Check_Declaration): Do not check the assignment
from an illegal declaration.

From-SVN: r275788

[Ada] Clarify documentation for Stack_Usage

Clarify the documentation for Stack_Usage (both comments in the code,
and user documentation) to note that tools like Valgrind won't work.

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

gcc/ada/

* doc/gnat_ugn/gnat_and_program_execution.rst: Clarify
documentation.
* gnat_ugn.texi: Regenerate.
* libgnat/s-stausa.ads: Clarify comments.

From-SVN: r275787

[Ada] Don't accept illegal (e.g., Integer'(null)) generic actuals

Sem_Util.Wrong_Type usually emits an error message, but in some cases it
does not. The code which prevents emitting an error message was going
too far in some cases, causing illegal constructs to be accepted. For
example, a qualified expression such as Integer'(null) might be passed
in as an actual parameter in an instantiation of a generic and generate
no error message.

Running this command:

  gcc -c inst.ads

On the following sources:

package Inst is
   type Ptr is new Integer;

   generic
      type TElement is private;
      NonDefini : TElement;
   package ArbMgr is
   end ArbMgr;

   package Pack is new ArbMgr (Ptr, Ptr'(null));

   procedure Dummy;
end Inst;

Should produce the following output:

  inst.ads:10:42: expected type "Ptr" defined at line 2
  inst.ads:10:42: found an access type
  compilation abandoned due to previous error

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

gcc/ada/

* sem_util.adb (Wrong_Type): In deciding to suppress a message,
it is not enough for In_Instance to be True; in addition,
In_Generic_Actual (Expr) must be False.
* sem_type.adb (In_Generic_Actual): Fix bug where traversal of
parents skips every other node.

From-SVN: r275786

[Ada] Support chained calls to traversal functions in SPARK

This change only affects the SPARK toolset. In the part of semantic
analysis enforcing ownership rules for SPARK, it corrects a crash in
analysis of a declaration of a local borrower whose definition is a
chain of several calls to traversal functions.

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

gcc/ada/

* sem_spark.adb (Get_Observed_Or_Borrowed_Expr): If the
definition of a local borrower contains calls to traversal
functions, the borrowed expression is the first parameter of the
first traversal function call in the definition.

From-SVN: r275785

[Ada] Remove section on pragma No_Run_Time

This pragma has been long obsolescent and confuses users.

2019-09-17  Ed Falis  <falis@adacore.com>

gcc/ada/

* doc/gnat_rm/implementation_defined_pragmas.rst: Remove
section.
* gnat_rm.texi, gnat_ugn.texi: Regenerate.

From-SVN: r275784

[Ada] Close file descriptors allocated for tty only once

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

gcc/ada/

* libgnat/g-exptty.ads (Close_Input): New subprogram.
* libgnat/g-exptty.adb (Close_Input): New subprogram.
(Close): Move close of TTY to Close_Input.
* terminals.c (__gnat_close_tty): Set file descriptors to
invalid value after close.

From-SVN: r275783

[Ada] GNAT.Expect (Expect_Internal): Try to call 'poll' few times

'poll' returns -1 in case of any error (including interruption by a
signal), so call need to be repeated few times to avoid false failures.

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

gcc/ada/

* libgnat/g-expect.adb (Expect_Internal): Try to call 'poll' few
times.

From-SVN: r275782

[Ada] Avoid to close irrelevant file descriptors

'Close' subprogram of GNAT.Expect can close irrelevant file descriptors
when 'Expect' was terminated by Process_Died exception and any file open
operations was done before call to 'Close'.

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

gcc/ada/

* libgnat/g-expect.ads, libgnat/g-expect.adb (Close_Input): New
subprogram.
(Get_Command_Output): Call Close_Input to close input stream.
(Expect_Internal): Likewise.
(Close): Likewise.
* libgnat/g-exptty.adb (Close): Likewise.

gcc/testsuite/

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

From-SVN: r275781

[Ada] A new utility routine for detecting attribute 'Old

Add a utility routine for detecting attribute 'Old. It will be
immediately reused in the GNATprove backend.

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

gcc/ada/

* sem_util.ads, sem_util.adb (Is_Attribute_Old): New utility
routine.

From-SVN: r275780

[Ada] Do not inline dispatching operations in GNATprove mode

In GNATprove, local subprograms without contracts are candidates for
inlining, so that they are only analyzed in the context of their calls.
This does not apply to dispatching operations, which may be called
through dispatching, in an unknown calling context. Hence such
operations should not be considered as candidates for inlining.

There is no test as this has no effect on compilation.

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

gcc/ada/

* inline.adb (Can_Be_Inlined_In_GNATprove_Mode): Add handling
for dispatching operations.

From-SVN: r275779

[Ada] In a generic use Presanalyze_Spec_Expression on Predicates

When verifying that the meaning of an aspect has not changed between the
freeze point of the entity and the end of the declarations, we analkyze
a copy of the expression to verify its conformance to previous analysis.
If the expression contains overloaded references, these have to be
resolved, which is not done if the expression is only preanalyzed.  This
applies in particular to expressions in predicates.

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

gcc/ada/

* sem_ch13.adb (Check_Aspect_At_End_Of_Declarations): In a
generic context, for a Predicate aspect, use
Preanalyze_Spec_Expression to verify conformance.

gcc/testsuite/

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

From-SVN: r275778

[Ada] Missing tagged type decoration in corresponding record subtypes

The frontend silently skips propagating attribute Is_Tagged_Type to the
constrained corresponding record subtype associated with a protected
type or task type with discriminants. 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 (Constrain_Corresponding_Record): Propagate
attribute Is_Tagged_Type.

From-SVN: r275777

[Ada] Ada 2020: Raise expressions in limited contexts (AI12-0172)

This patch adds support for the use of raise expressions in more
limited contexts (as described in the Ada Isssue AI12-0172).

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

gcc/ada/

* exp_ch3.adb (Build_Record_Init_Proc): Do not generate code to
adjust the tag component when the record is initialized with a
raise expression.
* sem_aggr.adb (Valid_Limited_Ancestor): Return True for
N_Raise_Expression nodes.
(Valid_Ancestor_Type): Return True for raise expressions.
* sem_ch3.adb (Analyze_Component_Declaration): Do not report an
error when a component is initialized with a raise expression.
* sem_ch4.adb (Analyze_Qualified_Expression): Do not report an
error when the aggregate has a raise expression.

gcc/testsuite/

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

From-SVN: r275776

[Ada] Ignore missing ALI files in GNATprove mode

This change only affects GNATprove backend, where it avoids spurious
errors on missing ALI files for units indirectly withed from the current
unit and processed as part of a different .gpr project.

No test provided, because only GNATprove is affected.

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

gcc/ada/

* ali.ads: Fix casing in comment.
* ali-util.ads, ali-util.adb (Read_Withed_ALIs): Remove
Ignore_Errors parameter; it was only set to non-default value of
True when running in GNATprove_Mode and wrongly reset to False
when calling this routine recursively. Now in GNATprove mode we
want it to be always True, so in fact it is equivalent to
GNATProve_Mode flag itself (which was already used in this
routine).

From-SVN: r275775

[Ada] PR ada/91268 Do not redefine macros

This should fix PR ada/91268 by only defining macros if not already
done.

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

gcc/ada/

* adaint.c (_REENTRANT, _THREAD_SAFE): Only define if needed.

From-SVN: r275774

[Ada] Refine change for bit-packed slices

We use Long_Long_Integer'Size / 2 instead of 4 * 8 to support
specifying a target configuration file where the largest integer is
32 bits instead of 64.

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

gcc/ada/

* libgnat/s-bitfie.ads (Val_Bits, Val_Bytes): Define from
Long_Long_Integer'Size.

From-SVN: r275773

[Ada] Adding assertions on extra formals for BIP function calls

This patch adds assertions to ensure that the frontend passes to the
backend the right number of extra parameters required for build in place
function calls. No functional change.

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

gcc/ada/

* exp_ch6.ads (Needs_BIP_Task_Actuals): New subprogram.
* exp_ch6.adb (Add_Task_Actuals_To_Build_In_Place_Call): Code
cleanup.
(Check_Number_Of_Actuals): New subprogram.
(Make_Build_In_Place_Call_In_Allocator): Adding assertion.
(Make_Build_In_Place_Call_In_Anonymous_Context): Adding
assertion.
(Make_Build_In_Place_Call_In_Assignment): Adding assertion.
(Make_Build_In_Place_Call_In_Object_Declaration): Code cleanup
plus assertion addition.
(Needs_BIP_Task_Actuals): New subprogram.
* sem_ch6.adb (Create_Extra_Formals): Rely on
Needs_BIP_Task_Actuals() to check if the master of the tasks to
be created, and the caller's activation chain formals are
needed.

From-SVN: r275772

[Ada] Avoid touching potentially nonexistent memory

...in cases where the Val_2 might cross a page boundary, and the second
page is now known to exist.

Copy_Bitfield is still disabled in the compiler: no test possible.

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

gcc/ada/

* libgnat/s-bituti.adb (Get_Val_2, Set_Val_2): Use new routines
for getting and setting a Val_2, avoiding touching the second
half when that half might not exist.
* exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Correct
tests for potential volatile or independent components. In
particular, do not call Prefix unless we know it's a slice.

From-SVN: r275771

[Ada] Support for local unix sockets in GNAT.Sockets API

Sock_Addr_Type has Family_Unix variant now. This variant can be created
with function Unix_Local_Addr call. And this variant is working in
GNAT.Socket routines where it is appropriate.

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

gcc/ada/

* gsocket.h: Include sys/un.h.
* s-oscons-tmplt.c (AF_UNIX): New constant generation.
(SIZEOF_sockaddr_un): Idem.
* libgnat/g-socket.ads (Family_Type): New value Family_Unix
added.
(Family_Inet_4_6): New subtype only for network families.
(Sock_Addr_Type): Add Unbounded_String field for Family_Unix
variant.
(Unix_Socket_Address): Create Sock_Addr_Type from socket
pathname.
(Network_Socket_Address): Create Sock_Addr_Type from
Inet_Addr_Type and Port_Type parameters.
* libgnat/g-socket.adb: Support local unix address in socket
routines.
(Get_Address_Info): Disable warning about Result may be
referenced before it has a value. Remove duplicated code to exit
from Look_For_Supported.
* libgnat/g-sothco.ads (Unix_Name_Length): New constant defining
maximum number of characters in local socket address path.
(Sockaddr): Add variant for Family_Unix address family. Move
Sin_Port and Sin_Family to Family_Inet section. Add Sin6_Port
and Sin6_Family to Family_Inet6 section.
(Set_Address): Add out parameter Length to return valuable
Sockaddr data length.
(Get_Address): Add input parameter Length to set valuable
Sockaddr data length.
* libgnat/g-sothco.adb: Support local unix address in socket
routines.

From-SVN: r275770

[Ada] Fix wrong value of 'Size for slices of bit-packed arrays

This fixes a long-standing issue in the compiler which would return
a wrong value for the Size attribute applied to slices of bit-packed
arrays whose size is not a multiple of the storage unit.

The problem is that the computation was done in the code generator
after the bit-packed array had been internally rewritten into an
array of bytes, so the Size was always rounded up to the next byte.

The computation is now rewritten into the product of the Length and
Compnent_Size attribute of the slices before being sent to the code
generator.

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

gcc/ada/

* exp_attr.adb (Expand_Size_Attribute): Chain the special cases
on the back-end path and rewrite the attribute appled to slices
of bit-packed arrays into the product of the Length and the
Compoent_Size attributes of the slices.
* exp_ch5.adb (Expand_Assign_Array_Bitfield): Use Size attribute
directly to compute the bitfield's size.

gcc/testsuite/

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

From-SVN: r275769

[Ada] Refine conditions for calling Copy_Bitfield

Avoid calling Copy_Bitfield if there are volatile or independent
components that might be read or written. The test is conservative.

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

gcc/ada/

* exp_ch5.adb (Expand_Assign_Array_Loop_Or_Bitfield): Add tests
for potential volatile or independent components.
* libgnat/s-bituti.adb (Copy_Small_Bitfield,
Copy_Large_Bitfield): Move declarations to more appropriate
place.

From-SVN: r275768

Daily bump.

From-SVN: r275763

decl.c (grokdeclarator): Use declspecs->locations and declarator->id_loc in a few error messages.

/cp
2019-09-16  Paolo Carlini  <paolo.carlini@oracle.com>

* decl.c (grokdeclarator): Use declspecs->locations and
declarator->id_loc in a few error messages.
* pt.c (finish_member_template_decl): Use DECL_SOURCE_LOCATION.
(push_template_decl_real): Likewise.

/testsuite
2019-09-16  Paolo Carlini  <paolo.carlini@oracle.com>

* g++.dg/ext/int128-6.C: New.
* c-c++-common/pr68107.c: Test location(s).
* g++.dg/other/large-size-array.C: Likewise.
* g++.dg/template/dtor2.C: Likewise.
* g++.dg/template/error9.C: Likewise.
* g++.dg/tls/diag-2.C: Likewise.
* g++.dg/tls/diag-4.C: Likewise.
* g++.dg/tls/diag-5.C: Likewise.
* g++.old-deja/g++.pt/memtemp71.C: Likewise.

From-SVN: r275759

compiler: fix quoting of //go:linkname in error message

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

From-SVN: r275758

pr89386.c (foo): Fix return type.

* gcc.target/i386/pr89386.c (foo): Fix return type.
* gcc.target/i386/pr89386-1.c (foo): Ditto.

From-SVN: r275757

* config/i386/sync.md (atomic_store<mode>): Improve comment.

From-SVN: r275755

re PR target/91719 (gcc compiles seq_cst store on x86-64 differently from clang/icc)

PR target/91719
* config/i386/i386.h (TARGET_USE_XCHG_FOR_ATOMIC_STORE): New macro.
* config/i386/x86-tune.def (X86_TUNE_USE_XCHG_FOR_ATOMIC_STORE): New.
* config/i386/sync.md (atomic_store<mode>): emit XCHG for
TARGET_USE_XCHG_FOR_ATOMIC_STORE.

From-SVN: r275754

* Makefile.in (build/genmatch.o): Depend on $(CPPLIB_H).

From-SVN: r275753

Rewrite second part of or_comparisons_1 into match.pd.

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

* gimple-fold.c (or_comparisons_1): Remove rules moved
to ...
* match.pd: ... here.

From-SVN: r275752

Rewrite first part of or_comparisons_1 into match.pd.

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

* gimple-fold.c (or_comparisons_1): Remove rules
moved to ...
* match.pd: ... here.

From-SVN: r275751

Rewrite part of and_comparisons_1 into match.pd.

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

* genmatch.c (dt_node::append_simplify): Do not print
warning when we have duplicate patterns belonging
to a same simplify rule.
* gimple-fold.c (and_comparisons_1): Remove matching moved to match.pd.
(maybe_fold_comparisons_from_match_pd): Handle
tcc_comparison as a results.
* match.pd: Handle (X == CST1) && (X OP2 CST2) conditions.

From-SVN: r275750

Fix PR88784, middle end is missing some optimizations about unsigned

2019-09-16  Li Jia He  <helijia@linux.ibm.com>
    Qi Feng  <ffengqi@linux.ibm.com>

PR middle-end/88784
* match.pd (x >  y  &&  x != XXX_MIN): Optimize into 'x > y'.
(x >  y  &&  x == XXX_MIN): Optimize into 'false'.
(x <= y  &&  x == XXX_MIN): Optimize into 'x == XXX_MIN'.
(x <  y  &&  x != XXX_MAX): Optimize into 'x < y'.
(x <  y  &&  x == XXX_MAX): Optimize into 'false'.
(x >= y  &&  x == XXX_MAX): Optimize into 'x == XXX_MAX'.
(x >  y  ||  x != XXX_MIN): Optimize into 'x != XXX_MIN'.
(x <= y  ||  x != XXX_MIN): Optimize into 'true'.
(x <= y  ||  x == XXX_MIN): Optimize into 'x <= y'.
(x <  y  ||  x != XXX_MAX): Optimize into 'x != XXX_MAX'.
(x >= y  ||  x != XXX_MAX): Optimize into 'true'.
(x >= y  ||  x == XXX_MAX): Optimize into 'x >= y'.
2019-09-16  Li Jia He  <helijia@linux.ibm.com>
    Qi Feng  <ffengqi@linux.ibm.com>

PR middle-end/88784
* gcc.dg/pr88784-1.c: New testcase.
* gcc.dg/pr88784-2.c: New testcase.
* gcc.dg/pr88784-3.c: New testcase.
* gcc.dg/pr88784-4.c: New testcase.
* gcc.dg/pr88784-5.c: New testcase.
* gcc.dg/pr88784-6.c: New testcase.
* gcc.dg/pr88784-7.c: New testcase.
* gcc.dg/pr88784-8.c: New testcase.
* gcc.dg/pr88784-9.c: New testcase.
* gcc.dg/pr88784-10.c: New testcase.
* gcc.dg/pr88784-11.c: New testcase.
* gcc.dg/pr88784-12.c: New testcase.

Co-Authored-By: Qi Feng <ffengqi@linux.ibm.com>
From-SVN: r275749

Auto-generate maybe_fold_and/or_comparisons from match.pd

2019-09-16  Li Jia He  <helijia@linux.ibm.com>
    Martin Liska  <mliska@suse.cz>

* gimple-fold.c (and_comparisons_1): Add type as first
argument.
(and_var_with_comparison): Likewise.
(and_var_with_comparison_1): Likewise.
(or_comparisons_1): Likewise.
(or_var_with_comparison): Likewise.
(or_var_with_comparison_1): Likewise.
(maybe_fold_and_comparisons): Call maybe_fold_comparisons_from_match_pd.
(maybe_fold_or_comparisons): Likewise.
(maybe_fold_comparisons_from_match_pd): New.
* gimple-fold.h (maybe_fold_and_comparisons): Add type argument.
(maybe_fold_or_comparisons): Likewise.
* gimple.c (gimple_size): Make it public and add num_ops argument.
(gimple_init): New function.
(gimple_alloc): Call gimple_init.
* gimple.h (gimple_size): New.
(gimple_init): Likewise.
* tree-if-conv.c (fold_or_predicates): Pass type.
* tree-ssa-ifcombine.c (ifcombine_ifandif): Likewise.
* tree-ssa-reassoc.c (eliminate_redundant_comparison): Likewise.
(optimize_vec_cond_expr): Likewise.
(ovce_extract_ops): Return type of conditional expression.
* tree-ssanames.c (init_ssa_name_imm_use): New.
(make_ssa_name_fn): Use init_ssa_name_imm_use.
* tree-ssanames.h (init_ssa_name_imm_use): New.

Co-Authored-By: Martin Liska <mliska@suse.cz>
From-SVN: r275748

re PR tree-optimization/91756 (g++.dg/lto/alias-3 FAILs)

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

PR tree-optimization/91756
PR tree-optimization/87132
* tree-ssa-alias.h (enum translate_flags): New.
(get_continuation_for_phi): Use it instead of simple bool flag.
(walk_non_aliased_vuses): Likewise.
* tree-ssa-alias.c (maybe_skip_until): Adjust.
(get_continuation_for_phi): When looking across backedges only
disallow valueization.
(walk_non_aliased_vuses): Adjust.
* tree-ssa-sccvn.c (vn_reference_lookup_3): Avoid valueization
if requested.

* gcc.dg/tree-ssa/ssa-fre-81.c: New testcase.

From-SVN: r275747

PR c++/30277 - int-width bit-field promotion.

Here, if cp_perform_integral_promotions saw that the TREE_TYPE of a
bit-field reference was the same as the type it promotes to, it didn't do
anything.  But then decay_conversion saw that the bit-field reference was
unchanged, and converted it to its declared type.  So I needed to add
something to make it clear that promotion has been done.  But then the 33819
change caused trouble by looking through the NOP_EXPR I just added.  This
was the wrong fix for that bug; I've now fixed that better by recognizing in
cp_perform_integral_promotions that we won't promote a bit-field larger than
32 bits, so we should use the declared type.

PR c++/33819 - long bit-field promotion.
* typeck.c (cp_perform_integral_promotions): Handle large bit-fields
properly.  Handle 32-bit non-int bit-fields properly.
(is_bitfield_expr_with_lowered_type): Don't look through NOP_EXPR.

From-SVN: r275746

PR c++/82165 - enum bitfields and operator overloading.

In this testcase, !f.b0 was failing to call the overloaded operator because
TREE_TYPE is the magic bitfield integer type, and we weren't using
unlowered_expr_type the way we do in other places.  It would be nice if we
could give bit-field COMPONENT_REFs their declared type until genericization
time...

* call.c (build_new_op_1): Use unlowered_expr_type.

From-SVN: r275745

Fix conversions for built-in operator overloading candidates.

While working on C++20 operator<=>, I noticed that build_new_op_1 was doing
too much conversion when a built-in candidate was selected; the standard
says it should only perform user-defined conversions, and then leave the
normal operator semantics to handle any standard conversions.  This is
important for operator<=> because a comparison of two different unscoped
enums is ill-formed; if we promote the enums to int here, cp_build_binary_op
never gets to see the original operand types, so we can't give the error.

* call.c (build_new_op_1): Don't apply any standard conversions to
the operands of a built-in operator.  Don't suppress conversions in
cp_build_unary_op.
* typeck.c (cp_build_unary_op): Do integral promotions for enums.

From-SVN: r275744

Handle location wrappers better in warn_logical_operator.

When we introduced location wrappers, we added fold_for_warn to warnings
that are interested in a constant value, or wrapper-stripping to warnings
that are interested in literal constants.  This particular warning is
looking for a literal constant, but was wrongly changed to use
fold_for_warn; this patch makes it strip instead.

* c-warn.c (warn_logical_operator): Strip location wrappers.  Don't
fold_for_warn in "|| mask" warning.

From-SVN: r275743

Daily bump.

From-SVN: r275741

PR c++/91740 - ICE with constexpr call and ?: in ARRAY_REF.

* pt.c (build_non_dependent_expr): Call build_non_dependent_expr for
the first operand.

* g++.dg/cpp1y/var-templ63.C: New test.

From-SVN: r275736

2019-09-15  Sandra Loosemore  <sandra@codesourcery.com>

gcc/testsuite/
* lib/target-supports.exp
(check_effective_target_arm_neon_fp16_hw)
(check_effective_target_arm_fp16_hw): Use check_runtime
instead of check_runtime_nocache.

From-SVN: r275735

re PR fortran/91727 (ICE in conformable_arrays, at fortran/resolve.c:7490)

2019-09-15  Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/91727
* resolve.c (conformable_arrays):  If array-spec is NULL, then
allocate-object is a scalar.  a conformability check only occurs
for an array source-expr.

2019-09-15  Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/91727
* gfortran.dg/pr91727.f90: New test.

From-SVN: r275731

Change C++ to C comments.

From-SVN: r275730

re PR fortran/91550 (ICE in do_subscript, at fortran/frontend-passes.c:2652)

2019-09-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/91550
* frontend-passes.c (do_subscript): If step equals
zero, a previuos error has been reported; do nothing
in this case.
* resolve.c (gfc_resolve_iterator): Move error checking
after type conversion.

2019-09-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/91550
* gfortran.dg/do_subscript_6.f90: New test.

From-SVN: r275729

[C++ PATCH] simplify clone predicate

https://gcc.gnu.org/ml/gcc-patches/2019-09/msg00904.html
* cp-tree.h (DECL_CLONED_FUNCTION_P): Reimplement using
IDENTIFIER_CDTOR_P, correct documentation.
(DECL_CLONED_FUNCTION): Directly access field.
(decl_cloned_function_p): Delete.
* class.c (decl_cloned_function_p): Delete.
* pt.c (instantiate_template_1): Check DECL_CHAIN is a decl.

From-SVN: r275727

re PR fortran/91556 (Problems with better interface checking)

2019-09-15  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/91556
* gfortran.dg/warn_argument_mismatch_1.f90: Remove.

From-SVN: r275726

Daily bump.

From-SVN: r275723