[Ada] Minor reformatting

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

gcc/ada/

* binderr.ads, namet.ads: Minor reformatting.

From-SVN: r256510

[Ada] Improve documentation of xml2gnat

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

gcc/ada/

* doc/gnat_ugn/gnat_utility_programs.rst: Improve documentation of
xml2gnat.

From-SVN: r256509

[Ada] gnatbind -f switch gives an error for duplicates

If the -felab-order.txt switch is given to gnatbind, and there are duplicate
unit names in elab-order.txt, an error will be given.

The following test should get errors:

this (spec) <-- that (body)
error: elab-order.txt:5: duplicate unit name "this (spec)" from line 1
error: elab-order.txt:7: duplicate unit name "that (body)" from line 3
gnatmake: *** bind failed.

Content of elab-order.txt (7 lines):

this%s

that%b

this (spec)

that%b

gnatmake -q -f -g -O0 -gnata that-main.adb -bargs -felab-order.txt

package body That is
end That;
package That is
   pragma Elaborate_Body;
end That;
with This, That;
procedure That.Main is
begin
   null;
end That.Main;
package body This is
end This;
package This is
   pragma Elaborate_Body;
end This;

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

gcc/ada/

* binde.adb (Force_Elab_Order): Give an error if there are duplicate
unit names.

From-SVN: r256508

[Ada] Crash on expression function as completion, with implicit dereference

An implicit dereference freezes the corresponding designated type. Most
implicit dereferences are made explicit during expansion, but this is not the
case for a dispatching call where the the controlling parameter and the
corresponding controlling argument are access to a tagged type. In that case,
to enforce the rule that an expression function that is a completion freezes
type references within, we must locate controlling arguments of an access type
and freeze explicitly the corresponding designated type.

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

gcc/ada/

* sem_ch6.adb (Freeze_Expr_Types): If an access value is the
controlling argument of a dispatching call. freeze the corresponding
designated type.

gcc/testsuite/

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

From-SVN: r256507

[Ada] Add Sphinx option -W to treat warnings as errors

2018-01-11  Ben Brosgol  <brosgol@adacore.com>

gcc/ada/

* doc/Makefile: Add Sphinx option -W to treat warnings as errors.

From-SVN: r256506

[Ada] Minor type/wording corrections

2018-01-11  Ben Brosgol  <brosgol@adacore.com>

gcc/ada/

* doc/gnat_rm/implementation_defined_aspects.rst: Minor type/wording
corrections.
* gnat_rm.texi: Regenerate.

From-SVN: r256505

[Ada] Warning on use of predefined operations on an actual fixed-point type

The compiler warns when a generic actual is a fixed-point type, because
arithmetic operations in the instance will use the predefined operations on
it, even if the type has user-defined primitive operations (unless formsl
surprograms for these operations appear in the generic). This patch refines
this warning to exclude the case where the formsal type is private, because
in this case there can be no suspicious arithmetic operastions in the generic
unit.

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

gcc/ada/

* sem_ch12.adb (Check_Fixed_Point_Type): Do not apply check if the
formsl type corresponding to the actual fixed point type is private,
because in this case there can be no suspicious arithmetic operations
in the generic unless they reference a formal subprogram.  Clarify
warning.

gcc/testsuite/

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

From-SVN: r256504

exp_util.adb (Remove_Side_Effects): No action done for functions returning class-wide types since it requires...

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

gcc/ada/

* exp_util.adb (Remove_Side_Effects): No action done for functions
returning class-wide types since it requires generating code using
'reference and the CCG target has no secondary stack.
* gnat1drv.adb: Disable building static dispatch tables when generating
C code.

From-SVN: r256503

[Ada] Annotate standard File_Type with Default_Initial_Condition (for SPARK)

GNATprove was emitting spurious checks about objects of the File_Type being
uninitialized and there was no easy to fix that (those checks could only be
silenced by pragma Annotate or by hiding File_Type behind as SPARK wrapper).

Now the full view of File_Type is annotated with Default_Initial_Condition
and GNATprove knows that objects of that type are default-initialized. The
default initialization is implicitly defined in the Ada RM (as indeed
there is no procedure that would take an IN OUT parameter of that type).

Semantics of Ada programs shall not be affected by these annotations,
so no frontend test is provided. It only affects GNATprove.

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

gcc/ada/

* libgnat/a-direio.ads, libgnat/a-sequio.ads, libgnat/a-ststio.ads,
libgnat/a-textio.ads, libgnat/a-witeio.ads, libgnat/a-ztexio.ads
(File_Type): Add Default_Initial_Condition aspect.

From-SVN: r256502

[Ada] New implementation for Normalize_Pathname

This implementation fixes an issue on Windows where a single drive letter
was not followed by a directory separator. On Windows the following
program:

   with Ada.Text_IO; use Ada.Text_IO;
   with GNAT.OS_Lib; use GNAT.OS_Lib;
   procedure Main is
   begin
      Put_Line (Normalize_Pathname ("c:\"));
      Put_Line (Normalize_Pathname ("c:\toto\.."));
   end Main;

Must output:

C:\
C:\

2018-01-11  Pascal Obry  <obry@adacore.com>

gcc/ada/

* libgnat/s-os_lib.adb (Normalize_Pathname): New implementation.

From-SVN: r256501

[Ada] Update gnatpp documentation after engine change

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

gcc/ada/

* doc/gnat_ugn/gnat_utility_programs.rst: Rewrite gnatpp documentation
to match what the Libadalang-based version does.
* doc/gnat_ugn/about_this_guide.rst: Update reference.

From-SVN: r256500

[Ada] Secondary stack leak due to controlled component

This pach modifies the expansion related to initialization calls and secondary
stack usage to inspec the components of a type derived from Limited_Controlled
or Controlled. Previously controlled types were treated as never utilizing the
secondary stack, however this is not true because a controlled type may contain
a component initialized by a function which returns on the secondary stack.

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

--  pack1.ads

with Ada.Finalization; use Ada.Finalization;

package Pack1 is
   type Ctrl is new Controlled with record
      Comp : Integer;
   end record;

   function Make_Ctrl return Ctrl;
end Pack1;

--  pack1.adb

package body Pack1 is
   Empty : constant Ctrl := (Controlled with Comp => 123);

   function Make_Ctrl return Ctrl is
   begin
      return Empty;
   end Make_Ctrl;
end Pack1;

--  pack2.ads

with Ada.Finalization; use Ada.Finalization;
with Pack1;            use Pack1;

package Pack2 is
   type Ctrl_Wrap is new Controlled with record
      Comp : Ctrl := Make_Ctrl;
   end record;
end Pack2;

--  main.adb

with Pack2; use Pack2;

procedure Main is
   procedure Make_Ctrl_Wrap is
      Obj : Ctrl_Wrap;
      pragma Warnings (Off, Obj);
   begin null; end Make_Ctrl_Wrap;

begin
   for Iter in 1 .. 10_000 loop
      Make_Ctrl_Wrap;
   end loop;
end Main;

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

$ gnatmake -q main.adb
$ valgrind ./main >& valgrind.log
$ grep -c "still reachable" valgrind.log
0

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

gcc/ada/

* sem_res.adb (Uses_SS): A controlled type requires the secondary stack
if it contains at least one component declaration employing a function
call returning on the secondary stack.

From-SVN: r256499

[Ada] Update description of restriction SPARK_05 with SPARK 2014

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

gcc/ada/

* doc/gnat_rm/standard_and_implementation_defined_restrictions.rst:
Update description of restriction SPARK_05 with SPARK 2014.
* gnat_rm.texi: Regenerate.

From-SVN: r256498

[Ada] Minor layout fix in documentation sources

2018-01-11  Vasiliy Fofanov  <fofanov@adacore.com>

gcc/ada/

* doc/gnat_ugn/gnat_utility_programs.rst: Fix layout.

From-SVN: r256497

[Ada] Minor reformatting

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

gcc/ada/

* exp_aggr.adb, exp_ch9.adb, exp_util.adb, sem_aggr.adb, sem_ch3.adb,
sem_res.adb, sem_util.adb: Minor reformatting.

From-SVN: r256496

[Ada] Handling of pragma Predicate

This patch fixes an omission in the processing of pragma Predicate, which
should have the same semantics as the corresponding aspect, which is more
commonly used.

Executing
   gnatmake -q -gnata predicate
   predicate

must yield:

   Even1 violated
   Even2 violated

----
with Text_IO; use Text_IO;
procedure Predicate is
begin
   begin
      declare
         subtype Even1 is Integer;
         pragma Predicate (Even1, Even1 mod 2 = 0);
         X1 : constant Even1 := 1; --  This should fail first
      begin
         null;
      end;
   exception
      when Others => Put_Line ("Even1 violated");
   end;

   begin
      declare
         subtype Even2 is Integer with Predicate => Even2 mod 2 = 0;
         X2 : constant Even2 := 1; --  This should fail later, if reached
      begin
         null;
      end;
   exception
      when Others => Put_Line ("Even2 violated");
   end;
end;

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

gcc/ada/

* sem_prag.adb (Analyze_Pragma, case Predicate): Indicate that the type
has a delayed aspect which must be processed at the point the type is
frozen. This mimics what is done when the predicate is provided by a
source aspect.

From-SVN: r256495

[Ada] Enable sigtramp for aarch64-vx7

2018-01-11  Doug Rupp  <rupp@adacore.com>

gcc/ada/

* init.c (vxworks): Add macro checks for __aarch64__.

From-SVN: r256494

[Ada] Different runtime behavior of Predicate_Failure

This patch corrects the generation of predicate checks to handle the case where
Predicate_Failure appears as a pragma.

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

--  main.adb

with Ada.Assertions; use Ada.Assertions;
with Ada.Exceptions; use Ada.Exceptions;
with Ada.Text_IO;    use Ada.Text_IO;

procedure Main is
   subtype Even_Asp is Integer
     with Predicate => Even_Asp mod 2 = 0,
          Predicate_Failure => "Even_Asp failed";

   subtype Even_Prag is Integer
     with Predicate => Even_Prag mod 2 = 0;
   pragma Predicate_Failure (Even_Prag, "Even_Prag failed");

begin
   begin
      declare
         Val : constant Even_Asp := 1;
      begin
         Put_Line ("ERROR: Even_Asp: did not fail");
      end;
   exception
      when AE : Assertion_Error => Put_Line (Exception_Message (AE));
      when others => Put_Line ("ERROR: Even_Asp: raised unexpected error");
   end;

   begin
      declare
         Val : constant Even_Prag := 3;
      begin
         Put_Line ("ERROR: Even_Prag: did not fail");
      end;
   exception
      when AE : Assertion_Error => Put_Line (Exception_Message (AE));
      when others => Put_Line ("ERROR: Even_Prag: raised unexpected error");
   end;
end Main;

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

$ gnatmake -q main.adb
$ ./main
Even_Asp failed
Even_Prag failed

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

gcc/ada/

* exp_util.adb (Add_Failure_Expression): New routine.
(Make_Predicate_Check): Reimplement the handling of Predicate_Failure.
* sem_util.adb (Is_Current_Instance): Code cleanup.

From-SVN: r256493

[Ada] Integer overflow in SS_Allocate

This patch imposes a new check and rewrites existing ones to ensure operations
involving SS_Ptr do not cause an Integer overflow. The Default_Sec_Stack_Size
function was removed in the process to simplify System.Parameter.

SS_Ptr was derived from the integer System.Parameters.Size_Type to ease the
creation of objects of type SS_Stack by the binder and imposes a maximum
secondary stack size of 2GB. In most cases, the user will not hit this limit as
they cannot specify task stack sizes of more than 2GB via the Storage_Size and
Secondary_Stack_Size pragmas. Additionally, most operating systems limit the
primary stack size to less than 2GB, with defaults under 10MB. Linux is the
rare exception where the user can unbound the primary stack.

Executing the following:
gnatmake -q overflow
./overflow

must yield:

raised STORAGE_ERROR : s-secsta.adb:140 explicit raise

--  overflow.adb:

with String_Pack;

procedure Overflow is
begin
   null;
end Overflow;

-- string_pack.ads:

package String_Pack is
   function Return_Big_String return String;
end String_Pack;

-- string_pack.adb:

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

package body String_Pack is
   function Return_Big_String return String is
   begin
      return Integer'Last * "P";
   end Return_Big_String;

   S : String := Return_Big_String;

end String_Pack;

2018-01-11  Patrick Bernardi  <bernardi@adacore.com>

gcc/ada/

* libgnat/s-parame*.adb, libgnat/s-parame*.ads: Remove unneeded
Default_Sec_Stack_Size.
* libgnat/s-secsta.adb (SS_Allocate): Handle the fixed secondary stack
limit check so that the integer index does not overflow. Check the
dynamic stack allocation does not cause the secondary stack pointer to
overflow.
(SS_Info): Align colons.
(SS_Init): Cover the case when bootstraping with an old compiler that
does not set Default_SS_Size.

From-SVN: r256492

[Ada] Illegal protected calls in inherited pre/postconditions

AI12-0166 specifies that it is illegal for a pre/postcondition of a
protected operation to contain an internal call to a protected function.
This patch completes the implementation of this rule in the case the
condition is inherited from a classwide condition of an abstract operation
of an interface type.

Compiling inheritpo.adb must yield:

   inheritpo.ads:9:04: instantiation error at line 6
   inheritpo.ads:9:04: internal call to "F" cannot appear
      in inherited precondition of protected operation "P"
   inheritpo.ads:9:04: instantiation error at line 7
   inheritpo.ads:9:04: internal call to "F" cannot appear
      in inherited precondition of protected operation "P"

--
package InheritPO is

   type T is limited interface;
   function F (X : T) return Boolean is abstract;
   procedure P (X : in out T) is abstract with
     Pre'Class  => X.F,
     Post'Class => X.F;

   protected type PT is new T with
     overriding function F return Boolean;
     overriding procedure P;
   end PT;

end InheritPO;
----
package body InheritPO is
   protected body PT is
     function F return Boolean is begin return True; end;
     procedure P is begin null; end;
   end PT;
end InheritPO;

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

gcc/ada/

* sem_ch3.adb (Add_Internal_Interface_Entities): When checking the
legality of an inherited operation that may require overriding, ignore
primitive_wrappers that correspond to explicit operations that override
an interface primitive.

* exp_util.adb (Build_Class_Wide_Expression, Replace_Entity): If the
operation to which the class-wide expression applies is a protected op.
with a primitive_wrapper, verify that the updated inherited expression
does not contain an internal call to a protected function.  This
completes the implementation of AI12-0166.

From-SVN: r256491

[Ada] Encoding of with clauses in ALI files

This patch modifies the encodings of with clauses in ALI files to adhere to the
existing API. The encodigs are as follows:

   * Explicit with clauses are encoded on a 'W' line (same as before).

   * Implicit with clauses for ancestor units are encoded on a 'W' line (same
     as before).

   * Limited_with clauses are encoded on a 'Y' line (same as before).

   * ABE and RTSfind-related with clauses are encoded on a 'Z' line.

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

--  case_10_func.adb

function Case_10_Func return Boolean is
begin
   return True;
end Case_10_Func;

--  case_10_gen_func.ads

generic
function Case_10_Gen_Func return Boolean;

--  case_10_gen_func.adb

function Case_10_Gen_Func return Boolean is
begin
   return True;
end Case_10_Gen_Func;

--  case_10_tasks.ads

package Case_10_Tasks is
   task type Task_Typ is
   end Task_Typ;
end Case_10_Tasks;

--  case_10_tasks.adb

package body Case_10_Tasks is
   task body Task_Typ is begin null; end Task_Typ;
end Case_10_Tasks;

--  case_10_gen.ads

with Case_10_Func;
with Case_10_Gen_Func;
with Case_10_Tasks;

generic
package Case_10_Gen is
   Val : constant Boolean := Case_10_Func;

   function Inst is new Case_10_Gen_Func;

   Tsk : Case_10_Tasks.Task_Typ;
end Case_10_Gen;

--  case_10.ads

with Case_10_Gen;

package Case_10 is
   package Inst is new Case_10_Gen;
end Case_10;

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

$ gcc -c case_10.ads
$ grep "W " case_10.ali | sort
$ grep "Z " case_10.ali | sort
W case_10_gen%s case_10_gen.ads case_10_gen.ali
Z case_10_func%b case_10_func.adb case_10_func.ali
Z case_10_gen_func%s case_10_gen_func.adb case_10_gen_func.ali  ED
Z case_10_tasks%s case_10_tasks.adb case_10_tasks.ali  AD
Z system.soft_links%s s-soflin.adb s-soflin.ali
Z system.tasking%s s-taskin.adb s-taskin.ali
Z system.tasking.stages%s  s-tassta.adb s-tassta.ali

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

gcc/ada/

* ali.adb: Document the remaining letters available for ALI lines.
(Scan_ALI): A with clause is internal when it is encoded on a 'Z' line.
* ali.ads: Update type With_Record. Field
Implicit_With_From_Instantiation is no longer in use. Add field
Implicit_With.
* csinfo.adb (CSinfo): Remove the setup for attribute
Implicit_With_From_Instantiation.
* lib-writ.adb (Collect_Withs): Correct the logic which marks a unit as
either implicitly or explicitly withed.
(Is_Implicit_With_Clause): New routine.
(Write_ALI): Rename array Implicit_With to Has_Implicit_With to avoid
confusion with the with clause attribute by the same name.
(Write_With_Lines): Update the emission of 'W', 'Y', and 'Z' headers.
* rtsfind.adb (Maybe_Add_With): Code cleanup.
* sem_ch8.adb (Present_System_Aux): Code cleanup.
* sem_ch10.adb (Expand_With_Clause): Mark the with clause as generated
for a parent unit.
(Implicit_With_On_Parent): Mark the with clause as generated for a
parent unit.
* sem_ch12.adb (Inherit_Context): With clauses inherited by an
instantiation are no longer marked as Implicit_With_From_Instantiation
because they are already marked as implicit.
* sem_elab.adb (Ensure_Prior_Elaboration_Static): Remove the kludge
which marks implicit with clauses as related to an instantiation.
* sinfo.adb (Implicit_With_From_Instantiation): Removed.
(Parent_With): New routine.
(Set_Implicit_With_From_Instantiation): Removed.
(Set_Parent_With): New routine.
* sinfo.ads: Update the documentation of attribute Implicit_With.
Remove attribute Implicit_With_From_Instantiation along with
occurrences in nodes.  Add attribute Parent_With along with occurrences
in nodes.
(Implicit_With_From_Instantiation): Removed along with pragma Inline.
(Parent_With): New routine along with pragma Inline.
(Set_Implicit_With_From_Instantiation): Removed along with pragma Inline.
(Set_Parent_With): New routine along with pragma Inline.

From-SVN: r256490

[Ada] Finding proper scope when inside entry body

This patch modifies routine Find_Enclosing_Scope which obtains the scope of an
arbitrary node to return the unique defining entity of an enclosing body. This
automatically takes care of the following corner cases:

   * The body is a subprogram body which does not complete a previous
     declaration. In this case the proper scope is the entity of the
     body.

   * The body is an entry body. Due to a limitation in the AST, the
     entry body does not store its correcponsing spec, but utilizes a
     roundabout way of obtaining it. Regardless of the limitation, the
     proper scope is the entity of the entry declaration.

The issue was discovered during the development of the GNATprove tool and
is not visible to end users. No simple test is available because this would
require a debug session.

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

gcc/ada/

* sem_util.adb (Find_Enclosing_Scope): Return the unique defining
entity when the enclosing construct is a body.

From-SVN: r256489

[Ada] Aspect/pragma Secondary_Stack_Size can evaluate non-literals as zero

This patch fixes the problem of aspect/pragma Secondary_Stack_Size expressions
with non-literals evaluating as zero in static secondary stacks allocations.
The aspect Secondary_Stack_Size is now converted to a pragma instead of an
attribute as the attribute does not have visibility on the discriminant.
Additionally, the discriminant of the corresponding record type is now
referenced if the pragma expression contains a discriminant.

No simple test available as the problem only impacts programs when
System.Parameters.Sec_Stack_Dynamic = False

2018-01-11  Patrick Bernardi  <bernardi@adacore.com>

gcc/ada/

* exp_ch9.adb (Expand_N_Task_Type_Declaration): Simplified
Secondary_Stack_Size handling as a pragma is now generated for the
corresponding aspect instead of an attribute.  Pragma expression is
relocated instead of evaluated. Discriminant of the corresponding
record type is referenced rather than the type discriminant.
(Create_Secondary_Stack_For_Task, Make_Task_Create_Call): Update
Secondary_Stack_Size rep item checks to only look for the pragma rep.
* sem_ch13.adb (Analyze_One_Aspect): Transform
Aspect_Secondary_Stack_Size into a pragma instead of an attribute
because the attribute does not have visibility on a task type's
discriminants when the type's definition is expanded.
(Analyze_Attribute_Definition_Clause): Remove handling of
Attribute_Secondary_Stack_Size.
* snames.adb-tmpl, snames.ads-tmpl: Remove
Attribute_Secondary_Stack_Size, no longer used.

From-SVN: r256488

[Ada] Minor reformatting

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

gcc/ada/

* sem_ch8.adb: Minor comment fix.

From-SVN: r256487

[Ada] Missing finalization in case expression

This patch modifies the processing of controlled transient objects within case
expressions represented by an Expression_With_Actions node. The inspection of
an individual action must continue in case it denotes a complex expression,
such as a case statement, which in turn may contain additional transients.

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

--  pack.ads

with Ada.Finalization; use Ada.Finalization;

package Pack is
   function Next_Id return Natural;

   type Ctrl is new Controlled with record
      Id : Natural := 0;
   end record;

   procedure Adjust (Obj : in out Ctrl);
   procedure Finalize (Obj : in out Ctrl);
   procedure Initialize (Obj : in out Ctrl);

   function New_Ctrl return Ctrl;

   Empty : constant Ctrl := (Controlled with Id => 1);

   type Enum is (One, Two, Three);

   type Ctrl_Rec is record
      Comp : Ctrl;
      Kind : Enum;
   end record;

   procedure Proc (Obj : Ctrl_Rec);
end Pack;

--  pack.adb

with Ada.Text_IO; use Ada.Text_IO;

package body Pack is
   Id_Gen : Natural := 1;

   procedure Adjust (Obj : in out Ctrl) is
      Old_Id : constant Natural := Obj.Id;
      New_Id : Natural;

   begin
      if Old_Id = 0 then
         Put_Line ("  adj: ERROR already finalized");
      else
         New_Id := Old_Id * 100;
         Put_Line ("  adj: " & Old_Id'Img & " ->" & New_Id'Img);
         Obj.Id := New_Id;
      end if;
   end Adjust;

   procedure Finalize (Obj : in out Ctrl) is
      Old_Id : constant Natural := Obj.Id;

   begin
      if Old_Id = 0 then
         Put_Line ("  fin: ERROR already finalized");
      else
         Put_Line ("  fin: " & Old_Id'Img);
         Obj.Id := 0;
      end if;
   end Finalize;

   procedure Initialize (Obj : in out Ctrl) is
      New_Id : constant Natural := Next_Id;
   begin
      Put_Line ("  ini: " & New_Id'Img);
      Obj.Id := New_Id;
   end Initialize;

   procedure Proc (Obj : Ctrl_Rec) is
   begin
      Put_Line ("proc : " & Obj.Comp.Id'Img);
   end Proc;

   function Next_Id return Natural is
   begin
      Id_Gen := Id_Gen + 1;
      return Id_Gen;
   end Next_Id;

   function New_Ctrl return Ctrl is
      Obj : Ctrl;
   begin
      return Obj;
   end New_Ctrl;
end Pack;

--  main.adb

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

procedure Main is
   procedure Proc_Case_Expr (Mode : Enum) is
   begin
      Put_Line ("proc_case_expr: " & Mode'Img);
      Proc (case Mode is
               when One   => (Kind => Two,   Comp => Empty),
               when Two   => (Kind => Three, Comp => Empty),
               when Three => (Kind => One,   Comp => New_Ctrl));
   end Proc_Case_Expr;

   procedure Proc_If_Expr (Mode : Enum) is
   begin
      Put_Line ("proc_if_expr: " & Mode'Img);
      Proc ((if    Mode = One then (Kind => Two,   Comp => Empty)
             elsif Mode = Two then (Kind => Three, Comp => Empty)
             else                  (Kind => One,   Comp => New_Ctrl)));
   end Proc_If_Expr;

begin
   Proc_Case_Expr (One);
   Proc_Case_Expr (Two);
   Proc_Case_Expr (Three);

   Proc_If_Expr (One);
   Proc_If_Expr (Two);
   Proc_If_Expr (Three);
end Main;

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

$ gnatmake -q main.adb
$ ./main
proc_case_expr: ONE
  adj:  1 -> 100
proc :  100
  fin:  100
proc_case_expr: TWO
  adj:  1 -> 100
proc :  100
  fin:  100
proc_case_expr: THREE
  ini:  2
  adj:  2 -> 200
  fin:  2
  adj:  200 -> 20000
proc :  20000
  fin:  20000
  fin:  200
proc_if_expr: ONE
  adj:  1 -> 100
proc :  100
  fin:  100
proc_if_expr: TWO
  adj:  1 -> 100
proc :  100
  fin:  100
proc_if_expr: THREE
  ini:  3
  adj:  3 -> 300
  fin:  3
  adj:  300 -> 30000
proc :  30000
  fin:  30000
  fin:  300
  fin:  1

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

gcc/ada/

* exp_ch4.adb (Process_Action): Do not abandon the inspection of an
individual action because the action may denote a complex expression,
such as a case statement, which in turn may contain additional
transient objects.

From-SVN: r256486

[Ada] Crash on iterated_component_association in expression function

This patch improves on the handling of the Ada2020 construct Iterated_
Component_Association in various contexts, when the expression involved
is a record or array aggregate.

Executing:
   gnatmake -gnatX -q main
   ./main

must yield:

   123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ

----
with Text_IO; use Text_IO;
with Exfor; use Exfor;
procedure Main is
   Map : String := Table_ASCII;
begin
   Put_Line (Map (50..91));
end;
----
package Exfor is
   function Table_ASCII return String is
      (for I in 1 .. Character'Pos (Character'Last) + 1 => Character'Val(I-1));
end Exfor;

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

gcc/ada/

* sem_aggr.adb (Resolve_Iterated_Component_Association): Perform
analysis on a copy of the expression with a copy of the index variable,
because full expansion will rewrite construct into a loop with the
original loop variable.
* exp_aggr.adb (Gen_Assign): Defer analysis and resolution if the
expression is an iterated component association. Full analysis takes
place when construct is rewritten as a loop.
(In_Place_Assign_OK, Safe_Component): An iterated_component_association
is not safe for in-place assignment.
* sem_util.adb (Remove_Entity): Handle properly the case of an isolated
entity with no homonym and no other entity in the scope.

From-SVN: r256485

[Ada] Wrong column in sloc of "expect name" error for loop variant

This patch corrects error messages printed when using the pragma Loop_Variant
without a named argument from having an incorrect column number in some cases.

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

gcc/ada/

* sem_prag.adb (Analyze_Pragma:Pragma_Loop_Variant): Modify error
message to be printed on the pragma argument identifier.

gcc/testsuite/

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

From-SVN: r256484

[Ada] Inconsistent scope chain due to quantified expression

This patch corrects the minor decoration performed on invariant procedures in
case the procedure is not inserted into the tree and analyzed. The decoration
now constructs a proper first/next/last entity chain containing the single
formal parameter which represents the object of the related type. The chain
then ensures that any other entities generated by the [pre]analysis of the
invariant expression will be properly added to the chain.

The issue was discovered during the development of the GNATprove tool and
is not visible to end users. No simple test is available because this would
require a debug session.

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

gcc/ada/

* exp_util.adb (Build_Invariant_Procedure_Declaration): Set the last
entity of the generated invariant procedure in order to construct a
proper entity chain.

From-SVN: r256483

[Ada] Fix minor comment issues

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

gcc/ada/

* sem_ch13.adb (Build_Predicate_Functions): Fix minor issues in
comment.

From-SVN: r256482

einfo.ads, einfo.adb (Activation_Record_Component, [...]): Allow E_Discriminant.

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

gcc/ada/

* einfo.ads, einfo.adb (Activation_Record_Component,
Set_Activation_Record_Component, Set_Is_Uplevel_Referenced_Entity):
Allow E_Discriminant.

From-SVN: r256481

re PR tree-optimization/83189 (internal compiler error: in probability_in, at profile-count.h:1050)

PR middle-end/83189
* gfortran.fortran-torture/compile/pr83189.f90: New testcase.
* tree-ssa-loop-manip.c (tree_transform_and_unroll_loop): Handle zero
profile.

From-SVN: r256480

re PR rtl-optimization/83575 (ICE: verify_flow_info failed (error: multiple hot/cold transitions found))

PR middle-end/83575
* cfgrtl.c (rtl_verify_edges): Only verify fixability of partition
when in layout mode.
(cfg_layout_finalize): Do not verify cfg before we are out of layout.
* cfgcleanup.c (try_optimize_cfg): Only verify flow info when doing
partition fixup.

* gcc.c-torture/compile/pr83575.c: New testcase.

From-SVN: r256479

aarch64-modes.def (V2HF): New VECTOR_MODE.

2018-01-10  Michael Collison  <michael.collison@arm.com>

* config/aarch64/aarch64-modes.def (V2HF): New VECTOR_MODE.
* config/aarch64/aarch64-option-extension.def: Add
AARCH64_OPT_EXTENSION of 'fp16fml'.
* config/aarch64/aarch64-c.c (aarch64_update_cpp_builtins):
(__ARM_FEATURE_FP16_FML): Define if TARGET_F16FML is true.
* config/aarch64/predicates.md (aarch64_lane_imm3): New predicate.
* config/aarch64/constraints.md (Ui7): New constraint.
* config/aarch64/iterators.md (VFMLA_W): New mode iterator.
(VFMLA_SEL_W): Ditto.
(f16quad): Ditto.
(f16mac1): Ditto.
(VFMLA16_LOW): New int iterator.
(VFMLA16_HIGH): Ditto.
(UNSPEC_FMLAL): New unspec.
(UNSPEC_FMLSL): Ditto.
(UNSPEC_FMLAL2): Ditto.
(UNSPEC_FMLSL2): Ditto.
(f16mac): New code attribute.
* config/aarch64/aarch64-simd-builtins.def
(aarch64_fmlal_lowv2sf): Ditto.
(aarch64_fmlsl_lowv2sf): Ditto.
(aarch64_fmlalq_lowv4sf): Ditto.
(aarch64_fmlslq_lowv4sf): Ditto.
(aarch64_fmlal_highv2sf): Ditto.
(aarch64_fmlsl_highv2sf): Ditto.
(aarch64_fmlalq_highv4sf): Ditto.
(aarch64_fmlslq_highv4sf): Ditto.
(aarch64_fmlal_lane_lowv2sf): Ditto.
(aarch64_fmlsl_lane_lowv2sf): Ditto.
(aarch64_fmlal_laneq_lowv2sf): Ditto.
(aarch64_fmlsl_laneq_lowv2sf): Ditto.
(aarch64_fmlalq_lane_lowv4sf): Ditto.
(aarch64_fmlsl_lane_lowv4sf): Ditto.
(aarch64_fmlalq_laneq_lowv4sf): Ditto.
(aarch64_fmlsl_laneq_lowv4sf): Ditto.
(aarch64_fmlal_lane_highv2sf): Ditto.
(aarch64_fmlsl_lane_highv2sf): Ditto.
(aarch64_fmlal_laneq_highv2sf): Ditto.
(aarch64_fmlsl_laneq_highv2sf): Ditto.
(aarch64_fmlalq_lane_highv4sf): Ditto.
(aarch64_fmlsl_lane_highv4sf): Ditto.
(aarch64_fmlalq_laneq_highv4sf): Ditto.
(aarch64_fmlsl_laneq_highv4sf): Ditto.
* config/aarch64/aarch64-simd.md:
(aarch64_fml<f16mac1>l<f16quad>_low<mode>): New pattern.
(aarch64_fml<f16mac1>l<f16quad>_high<mode>): Ditto.
(aarch64_simd_fml<f16mac1>l<f16quad>_low<mode>): Ditto.
(aarch64_simd_fml<f16mac1>l<f16quad>_high<mode>): Ditto.
(aarch64_fml<f16mac1>l_lane_lowv2sf): Ditto.
(aarch64_fml<f16mac1>l_lane_highv2sf): Ditto.
(aarch64_simd_fml<f16mac>l_lane_lowv2sf): Ditto.
(aarch64_simd_fml<f16mac>l_lane_highv2sf): Ditto.
(aarch64_fml<f16mac1>lq_laneq_lowv4sf): Ditto.
(aarch64_fml<f16mac1>lq_laneq_highv4sf): Ditto.
(aarch64_simd_fml<f16mac>lq_laneq_lowv4sf): Ditto.
(aarch64_simd_fml<f16mac>lq_laneq_highv4sf): Ditto.
(aarch64_fml<f16mac1>l_laneq_lowv2sf): Ditto.
(aarch64_fml<f16mac1>l_laneq_highv2sf): Ditto.
(aarch64_simd_fml<f16mac>l_laneq_lowv2sf): Ditto.
(aarch64_simd_fml<f16mac>l_laneq_highv2sf): Ditto.
(aarch64_fml<f16mac1>lq_lane_lowv4sf): Ditto.
(aarch64_fml<f16mac1>lq_lane_highv4sf): Ditto.
(aarch64_simd_fml<f16mac>lq_lane_lowv4sf): Ditto.
(aarch64_simd_fml<f16mac>lq_lane_highv4sf): Ditto.
* config/aarch64/arm_neon.h (vfmlal_low_u32): New intrinsic.
(vfmlsl_low_u32): Ditto.
(vfmlalq_low_u32): Ditto.
(vfmlslq_low_u32): Ditto.
(vfmlal_high_u32): Ditto.
(vfmlsl_high_u32): Ditto.
(vfmlalq_high_u32): Ditto.
(vfmlslq_high_u32): Ditto.
(vfmlal_lane_low_u32): Ditto.
(vfmlsl_lane_low_u32): Ditto.
(vfmlal_laneq_low_u32): Ditto.
(vfmlsl_laneq_low_u32): Ditto.
(vfmlalq_lane_low_u32): Ditto.
(vfmlslq_lane_low_u32): Ditto.
(vfmlalq_laneq_low_u32): Ditto.
(vfmlslq_laneq_low_u32): Ditto.
(vfmlal_lane_high_u32): Ditto.
(vfmlsl_lane_high_u32): Ditto.
(vfmlal_laneq_high_u32): Ditto.
(vfmlsl_laneq_high_u32): Ditto.
(vfmlalq_lane_high_u32): Ditto.
(vfmlslq_lane_high_u32): Ditto.
(vfmlalq_laneq_high_u32): Ditto.
(vfmlslq_laneq_high_u32): Ditto.
* config/aarch64/aarch64.h (AARCH64_FL_F16SML): New flag.
(AARCH64_FL_FOR_ARCH8_4): New.
(AARCH64_ISA_F16FML): New ISA flag.
(TARGET_F16FML): New feature flag for fp16fml.
(doc/invoke.texi): Document new fp16fml option.

2018-01-10  Michael Collison  <michael.collison@arm.com>

* config/aarch64/aarch64-builtins.c:
(aarch64_types_ternopu_imm_qualifiers, TYPES_TERNOPUI): New.
* config/aarch64/aarch64-c.c (aarch64_update_cpp_builtins):
(__ARM_FEATURE_SHA3): Define if TARGET_SHA3 is true.
* config/aarch64/aarch64.h (AARCH64_FL_SHA3): New flags.
(AARCH64_ISA_SHA3): New ISA flag.
(TARGET_SHA3): New feature flag for sha3.
* config/aarch64/iterators.md (sha512_op): New int attribute.
(CRYPTO_SHA512): New int iterator.
(UNSPEC_SHA512H): New unspec.
(UNSPEC_SHA512H2): Ditto.
(UNSPEC_SHA512SU0): Ditto.
(UNSPEC_SHA512SU1): Ditto.
* config/aarch64/aarch64-simd-builtins.def
(aarch64_crypto_sha512hqv2di): New builtin.
(aarch64_crypto_sha512h2qv2di): Ditto.
(aarch64_crypto_sha512su0qv2di): Ditto.
(aarch64_crypto_sha512su1qv2di): Ditto.
(aarch64_eor3qv8hi): Ditto.
(aarch64_rax1qv2di): Ditto.
(aarch64_xarqv2di): Ditto.
(aarch64_bcaxqv8hi): Ditto.
* config/aarch64/aarch64-simd.md:
(aarch64_crypto_sha512h<sha512_op>qv2di): New pattern.
(aarch64_crypto_sha512su0qv2di): Ditto.
(aarch64_crypto_sha512su1qv2di): Ditto.
(aarch64_eor3qv8hi): Ditto.
(aarch64_rax1qv2di): Ditto.
(aarch64_xarqv2di): Ditto.
(aarch64_bcaxqv8hi): Ditto.
* config/aarch64/arm_neon.h (vsha512hq_u64): New intrinsic.
(vsha512h2q_u64): Ditto.
(vsha512su0q_u64): Ditto.
(vsha512su1q_u64): Ditto.
(veor3q_u16): Ditto.
(vrax1q_u64): Ditto.
(vxarq_u64): Ditto.
(vbcaxq_u16): Ditto.
* config/arm/types.md (crypto_sha512): New type attribute.
(crypto_sha3): Ditto.
(doc/invoke.texi): Document new sha3 option.

2018-01-10  Michael Collison  <michael.collison@arm.com>

* config/aarch64/aarch64-builtins.c:
(aarch64_types_quadopu_imm_qualifiers, TYPES_QUADOPUI): New.
* config/aarch64/aarch64-c.c (aarch64_update_cpp_builtins):
(__ARM_FEATURE_SM3): Define if TARGET_SM4 is true.
(__ARM_FEATURE_SM4): Define if TARGET_SM4 is true.
* config/aarch64/aarch64.h (AARCH64_FL_SM4): New flags.
(AARCH64_ISA_SM4): New ISA flag.
(TARGET_SM4): New feature flag for sm4.
* config/aarch64/aarch64-simd-builtins.def
(aarch64_sm3ss1qv4si): Ditto.
(aarch64_sm3tt1aq4si): Ditto.
(aarch64_sm3tt1bq4si): Ditto.
(aarch64_sm3tt2aq4si): Ditto.
(aarch64_sm3tt2bq4si): Ditto.
(aarch64_sm3partw1qv4si): Ditto.
(aarch64_sm3partw2qv4si): Ditto.
(aarch64_sm4eqv4si): Ditto.
(aarch64_sm4ekeyqv4si): Ditto.
* config/aarch64/aarch64-simd.md:
(aarch64_sm3ss1qv4si): Ditto.
(aarch64_sm3tt<sm3tt_op>qv4si): Ditto.
(aarch64_sm3partw<sm3part_op>qv4si): Ditto.
(aarch64_sm4eqv4si): Ditto.
(aarch64_sm4ekeyqv4si): Ditto.
* config/aarch64/iterators.md (sm3tt_op): New int iterator.
(sm3part_op): Ditto.
(CRYPTO_SM3TT): Ditto.
(CRYPTO_SM3PART): Ditto.
(UNSPEC_SM3SS1): New unspec.
(UNSPEC_SM3TT1A): Ditto.
(UNSPEC_SM3TT1B): Ditto.
(UNSPEC_SM3TT2A): Ditto.
(UNSPEC_SM3TT2B): Ditto.
(UNSPEC_SM3PARTW1): Ditto.
(UNSPEC_SM3PARTW2): Ditto.
(UNSPEC_SM4E): Ditto.
(UNSPEC_SM4EKEY): Ditto.
* config/aarch64/constraints.md (Ui2): New constraint.
* config/aarch64/predicates.md (aarch64_imm2): New predicate.
* config/arm/types.md (crypto_sm3): New type attribute.
(crypto_sm4): Ditto.
* config/aarch64/arm_neon.h (vsm3ss1q_u32): New intrinsic.
(vsm3tt1aq_u32): Ditto.
(vsm3tt1bq_u32): Ditto.
(vsm3tt2aq_u32): Ditto.
(vsm3tt2bq_u32): Ditto.
(vsm3partw1q_u32): Ditto.
(vsm3partw2q_u32): Ditto.
(vsm4eq_u32): Ditto.
(vsm4ekeyq_u32): Ditto.
(doc/invoke.texi): Document new sm4 option.

2018-01-10  Michael Collison  <michael.collison@arm.com>

* config/aarch64/aarch64-arches.def (armv8.4-a): New architecture.
* config/aarch64/aarch64.h (AARCH64_ISA_V8_4): New ISA flag.
(AARCH64_FL_FOR_ARCH8_4): New.
(AARCH64_FL_V8_4): New flag.
(doc/invoke.texi): Document new armv8.4-a option.

2018-01-10  Michael Collison  <michael.collison@arm.com>

* config/aarch64/aarch64-c.c (aarch64_update_cpp_builtins):
(__ARM_FEATURE_AES): Define if TARGET_AES is true.
(__ARM_FEATURE_SHA2): Define if TARGET_SHA2 is true.
* config/aarch64/aarch64-option-extension.def: Add
AARCH64_OPT_EXTENSION of 'sha2'.
(aes): Add AARCH64_OPT_EXTENSION of 'aes'.
(crypto): Disable sha2 and aes if crypto disabled.
(crypto): Enable aes and sha2 if enabled.
(simd): Disable sha2 and aes if simd disabled.
* config/aarch64/aarch64.h (AARCH64_FL_AES, AARCH64_FL_SHA2):
New flags.
(AARCH64_ISA_AES, AARCH64_ISA_SHA2): New ISA flags.
(TARGET_SHA2): New feature flag for sha2.
(TARGET_AES): New feature flag for aes.
* config/aarch64/aarch64-simd.md:
(aarch64_crypto_aes<aes_op>v16qi): Make pattern
conditional on TARGET_AES.
(aarch64_crypto_aes<aesmc_op>v16qi): Ditto.
(aarch64_crypto_sha1hsi): Make pattern conditional
on TARGET_SHA2.
(aarch64_crypto_sha1hv4si): Ditto.
(aarch64_be_crypto_sha1hv4si): Ditto.
(aarch64_crypto_sha1su1v4si): Ditto.
(aarch64_crypto_sha1<sha1_op>v4si): Ditto.
(aarch64_crypto_sha1su0v4si): Ditto.
(aarch64_crypto_sha256h<sha256_op>v4si): Ditto.
(aarch64_crypto_sha256su0v4si): Ditto.
(aarch64_crypto_sha256su1v4si): Ditto.
(doc/invoke.texi): Document new aes and sha2 options.

From-SVN: r256478

PR tree-optimization/83781 - Bootstrap failed on x86 with --with-arch=corei7

PR tree-optimization/83781 - Bootstrap failed on x86 with --with-arch=corei7
  --with-cpu=corei7

gcc/ChangeLog:
* gimple-fold.c (get_range_strlen): Avoid treating arrays of pointers
as string arrays.

gcc/testsuite/ChangeLog:
* gcc.dg/strlenopt-42.c: New test.

From-SVN: r256477

re PR tree-optimization/83501 (strlen(a) not folded after strcpy(a, "..."))

2018-01-11  Martin Sebor  <msebor@gmail.com>
    Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

PR tree-optimization/83501
PR tree-optimization/81703

* tree-ssa-strlen.c (get_string_cst): Rename...
(get_string_len): ...to this.  Handle global constants.
(handle_char_store): Adjust.

testsuite/
* gcc.dg/strlenopt-39.c: New test-case.
* gcc.dg/pr81703.c: Likewise.

Co-Authored-By: Prathamesh Kulkarni <prathamesh.kulkarni@linaro.org>
From-SVN: r256475

debug/dwarf: formStrp uses a 64-bit value for 64-bit DWARF

    No test as the only system I know that uses 64-bit DWARF is AIX.

    Backport of https://golang.org/cl/84379, which will be in Go 1.11.
    Backporting now for AIX support in gccgo.

    Reviewed-on: https://go-review.googlesource.com/87296

From-SVN: r256474

Daily bump.

From-SVN: r256472

decl.c (gnat_to_gnu_component_type): Apply the check for atomic access once the component size is taken into account...

* gcc-interface/decl.c (gnat_to_gnu_component_type): Apply the check
for atomic access once the component size is taken into account and
also do it if the component type is Atomic or Volatile_Full_Access.

From-SVN: r256465

re PR fortran/82367 (ICE with deferred length string allocate on non-deferred length argument)

2018-01-10  Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/82367
* resolve.c (resolve_allocate_expr): Check for NULL pointer.

2018-01-10  Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/82367
* gfortran.dg/deferred_character_18.f90: New test.

From-SVN: r256464

c-ada-spec.c (dump_number): Add FLOAT_P parameter.

* c-ada-spec.c (dump_number): Add FLOAT_P parameter.
Skip 'f' and 'F' characters if it is true.
(store_ada_macro): Minor tweak.
(dump_ada_macros) <CPP_COMMENT>: Likewise.
<CPP_WSTRING>: Likewise.
<CPP_STRING>: Output '&' in the buffer if not the first string.
<CPP_NUMBER>: Adjust calls to dump_number.

From-SVN: r256463

RISC-V: Add naked function support.

2018-01-10  Kito Cheng  <kito.cheng@gmail.com>

gcc/
* config/riscv/riscv-protos.h (riscv_output_return): New.
* config/riscv/riscv.c (struct machine_function): New naked_p field.
(riscv_attribute_table, riscv_output_return),
(riscv_handle_fndecl_attribute, riscv_naked_function_p),
(riscv_allocate_stack_slots_for_args, riscv_warn_func_return): New.
(riscv_compute_frame_info): Only compute frame->mask if not a naked
function.
(riscv_expand_prologue): Add early return for naked function.
(riscv_expand_epilogue): Likewise.
(riscv_function_ok_for_sibcall): Return false for naked function.
(riscv_set_current_function): New.
(TARGET_SET_CURRENT_FUNCTION, TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS),
(TARGET_ATTRIBUTE_TABLE, TARGET_WARN_FUNC_RETURN): New.
* config/riscv/riscv.md (simple_return): Call riscv_output_return.
* doc/extend.texi (RISC-V Function Attributes): New.

Co-Authored-By: Jim Wilson <jimw@sifive.com>
From-SVN: r256462

argv.c (expandargv): Correct check for dynamically allocated argv.

2018-01-10  Daniel van Gerpen  <daniel@vangerpen.de>

* argv.c (expandargv): Correct check for dynamically
allocated argv.

From-SVN: r256460

rs6000.c (is_complex_IBM_long_double): Explicitly check for 128-bit long double before checking TCmode.

2018-01-10  Michael Meissner  <meissner@linux.vnet.ibm.com>

* config/rs6000/rs6000.c (is_complex_IBM_long_double): Explicitly
check for 128-bit long double before checking TCmode.
* config/rs6000/rs6000.h (FLOAT128_IEEE_P): Explicitly check for
128-bit long doubles before checking TFmode or TCmode.
(FLOAT128_IBM_P): Likewise.

From-SVN: r256458

PR tree-optimization/83671 - Fix for false positive reported by -Wstringop-overflow does not work with inlining

gcc/testsuite/ChangeLog:

PR tree-optimization/83671
* gcc.dg/strlenopt-40.c: New test.
* gcc.dg/strlenopt-41.c: New test.

gcc/ChangeLog:

PR tree-optimization/83671
* builtins.c (c_strlen): Unconditionally return zero for the empty
string.
Use -Warray-bounds for warnings.
* gimple-fold.c (get_range_strlen): Handle non-constant lengths
for non-constant array indices with COMPONENT_REF, arrays of
arrays, and pointers to arrays.
(gimple_fold_builtin_strlen): Determine and set length range for
non-constant character arrays.

From-SVN: r256457

re PR middle-end/81897 (spurious -Wmaybe-uninitialized warning)

PR middle-end/81897
* tree-ssa-uninit.c (convert_control_dep_chain_into_preds): Skip
empty blocks.

From-SVN: r256456

[multiple changes]

2018-01-10 Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/83093
* resolve.c (resolve_charlen): Check the type of cl->length
after resolution.

2018-01-10  Steven G. Kargl  <kargl@gcc.gnu.org>

PR fortran/83093
* gfortran.dg/allocate_with_typespec_7.f90: New test.

From-SVN: r256455

* dwarf2out.c (dwarf2out_var_location): Do not pass NULL to fprintf.

From-SVN: r256454

re PR target/83399 (Power8 ICE During LRA with 2-op rtl pattern for lvx instruction)

gcc/
PR target/83399
* config/rs6000/rs6000.c (print_operand) <'y'>: Use
VECTOR_MEM_ALTIVEC_OR_VSX_P.
* config/rs6000/vsx.md (*vsx_le_perm_load_<mode> for VSX_D): Use
indexed_or_indirect_operand predicate.
(*vsx_le_perm_load_<mode> for VSX_W): Likewise.
(*vsx_le_perm_load_v8hi): Likewise.
(*vsx_le_perm_load_v16qi): Likewise.
(*vsx_le_perm_store_<mode> for VSX_D): Likewise.
(*vsx_le_perm_store_<mode> for VSX_W): Likewise.
(*vsx_le_perm_store_v8hi): Likewise.
(*vsx_le_perm_store_v16qi): Likewise.
(eight unnamed splitters): Likewise.

gcc/testsuite/
PR target/83399
* gcc.target/powerpc/pr83399.c: New test.

From-SVN: r256453

x86intrin.h: Change #warning to #error.

* config/rs6000/x86intrin.h: Change #warning to #error. Update message.
* config/rs6000/emmintrin.h: Likewise.
* config/rs6000/mmintrin.h: Likewise.
* config/rs6000/xmmintrin.h: Likewise.

From-SVN: r256452

parser.c (cp_parser_std_attribute_spec): When token_pair::require_open / require_close return false simply return...

2018-01-10  Paolo Carlini  <paolo.carlini@oracle.com>

* parser.c (cp_parser_std_attribute_spec): When
        token_pair::require_open / require_close return false simply
return error_mark_node, avoid duplicate cp_parser_error about
expected '(' / ')', respectively.

From-SVN: r256451

os, syscall: handle _st_timespec for AIX stat

    Reviewed-on: https://go-review.googlesource.com/87197

From-SVN: r256450

Preserving locations for variable-uses and constants (PR c++/43486)

This patch implements location wrapper nodes, preserving source locations
of the uses of variables and constants in various places in the
C++ frontend: at the arguments at callsites, and for typeid, alignof,
sizeof, and offsetof.

For example, it allows the C++ FE to underline the pertinent argument
for mismatching calls, for such expressions, improving:

extern int callee (int one, const char *two, float three);

int caller (int first, int second, float third)
{
  return callee (first, second, third);
}

from

test.cc: In function 'int caller(int, int, float)':
test.cc:5:38: error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   return callee (first, second, third);
                                      ^
test.cc:1:41: note:   initializing argument 2 of 'int callee(int, const char*, float)'
 extern int callee (int one, const char *two, float three);
                             ~~~~~~~~~~~~^~~

to:

test.cc: In function 'int caller(int, int, float)':
test.cc:5:25: error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   return callee (first, second, third);
                         ^~~~~~
test.cc:1:41: note:   initializing argument 2 of 'int callee(int, const char*, float)'
 extern int callee (int one, const char *two, float three);
                             ~~~~~~~~~~~~^~~

This is the combination of the following patches:

  "[PATCH 01/14] C++: preserve locations within build_address"
     https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00883.html

  "[PATCH v2.4 of 02/14] Support for adding and stripping location_t wrapper nodes"
    https://gcc.gnu.org/ml/gcc-patches/2018-01/msg00591.html

  "[PATCH] Eliminate location wrappers in tree_nop_conversion/STRIP_NOPS"
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01330.html

  "[PATCH v4 of 03/14] C++: add location_t wrapper nodes during parsing (minimal impl)"
    https://gcc.gnu.org/ml/gcc-patches/2018-01/msg00660.html

  "[PATCH 04/14] Update testsuite to show improvements"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00891.html

  "[v3 of 05/14] C++: handle locations wrappers when calling warn_for_memset"
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01378.html

  "[PATCH 07/14] reject_gcc_builtin: strip any location wrappers"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00886.html

  "[v3 of PATCH 08/14] cp/tree.c: strip location wrappers in lvalue_kind"
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01433.html

  "[PATCH 09/14] Strip location wrappers in null_ptr_cst_p"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00888.html

  "[PATCH 11/14] Handle location wrappers in string_conv_p"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00890.html

  "[PATCH 12/14] C++: introduce null_node_p"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00894.html

  "[v3 of PATCH 13/14] c-format.c: handle location wrappers"
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01494.html

  "[PATCH 14/14] pp_c_cast_expression: don't print casts for location wrappers"
    https://gcc.gnu.org/ml/gcc-patches/2017-11/msg00893.html

  "[v3 of PATCH 15/14] Use fold_for_warn in get_atomic_generic_size"
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01380.html

  "[PATCH] Add selftest for "fold_for_warn (error_mark_node)""
    https://gcc.gnu.org/ml/gcc-patches/2017-12/msg01385.html

gcc/c-family/ChangeLog:
PR c++/43486
* c-common.c: Include "selftest.h".
(get_atomic_generic_size): Perform the test for integral type
before the range test for any integer constant, fixing indentation
of braces.  Call fold_for_warn before testing for an INTEGER_CST.
(reject_gcc_builtin): Strip any location wrapper from EXPR.
(selftest::test_fold_for_warn): New function.
(selftest::c_common_c_tests): New function.
(selftest::c_family_tests): Call it, and
selftest::c_pretty_print_c_tests.
* c-common.h (selftest::c_pretty_print_c_tests): New decl.
* c-format.c (check_format_arg): Convert VAR_P check to a
fold_for_warn.
* c-pretty-print.c: Include "selftest.h".
(pp_c_cast_expression): Don't print casts for location wrappers.
(selftest::assert_c_pretty_printer_output): New function.
(ASSERT_C_PRETTY_PRINTER_OUTPUT): New macro.
(selftest::test_location_wrappers): New function.
(selftest::c_pretty_print_c_tests): New function.
* c-warn.c (warn_for_memset): Call fold_for_warn on the arguments.

gcc/cp/ChangeLog:
PR c++/43486
* call.c (null_ptr_cst_p): Strip location wrappers when
converting from '0' to a pointer type in C++11 onwards.
(conversion_null_warnings): Replace comparison with null_node with
call to null_node_p.
(build_over_call): Likewise.
* cp-gimplify.c (cp_fold): Remove the early bailout when
processing_template_decl.
* cp-lang.c (selftest::run_cp_tests): Call
selftest::cp_pt_c_tests and selftest::cp_tree_c_tests.
* cp-tree.h (cp_expr::maybe_add_location_wrapper): New method.
(selftest::run_cp_tests): Move decl to bottom of file.
(null_node_p): New inline function.
(selftest::cp_pt_c_tests): New decl.
(selftest::cp_tree_c_tests): New decl.
* cvt.c (build_expr_type_conversion): Replace comparison with
null_node with call to null_node_p.
* error.c (args_to_string): Likewise.
* except.c (build_throw): Likewise.
* mangle.c (write_expression): Skip location wrapper nodes.
* parser.c (literal_integer_zerop): New function.
(cp_parser_postfix_expression): Call maybe_add_location_wrapper on
the result for RID_TYPEID. Pass true for new "wrap_locations_p"
param of cp_parser_parenthesized_expression_list.  When calling
warn_for_memset, replace integer_zerop calls with
literal_integer_zerop, eliminating the double logical negation
cast to bool.  Eliminate the special-casing for CONST_DECL in
favor of the fold_for_warn within warn_for_memset.
(cp_parser_parenthesized_expression_list): Add "wrap_locations_p"
param, defaulting to false.  Convert "expr" to a cp_expr, and call
maybe_add_location_wrapper on it when wrap_locations_p is true.
(cp_parser_unary_expression): Call maybe_add_location_wrapper on
the result for RID_ALIGNOF and RID_SIZEOF.
(cp_parser_builtin_offsetof): Likewise.
* pt.c: Include "selftest.h".
(tsubst_copy): Handle location wrappers.
(tsubst_copy_and_build): Likewise.
(build_non_dependent_expr): Likewise.
(selftest::test_build_non_dependent_expr): New function.
(selftest::cp_pt_c_tests): New function.
* tree.c: Include "selftest.h".
(lvalue_kind): Handle VIEW_CONVERT_EXPR location wrapper nodes.
(selftest::test_lvalue_kind): New function.
(selftest::cp_tree_c_tests): New function.
* typeck.c (string_conv_p): Strip any location wrapper from "exp".
(cp_build_binary_op): Replace comparison with null_node with call
to null_node_p.
(build_address): Use location of operand when building address
expression.

gcc/testsuite/ChangeLog:
PR c++/43486
* g++.dg/diagnostic/param-type-mismatch.C: Update expected results
to reflect that the arguments are correctly underlined.
* g++.dg/plugin/diagnostic-test-expressions-1.C: Add test coverage
for globals, params, locals and literals.
(test_sizeof): Directly test the location of "sizeof", rather than
when used in compound expressions.
(test_alignof): Likewise for "alignof".
(test_string_literals): Likewise for string literals.
(test_numeric_literals): Likewise for numeric literals.
(test_builtin_offsetof): Likewise for "__builtin_offsetof".
(test_typeid): Likewise for typeid.
(test_unary_plus): New.
* g++.dg/warn/Wformat-1.C: Add tests of pointer arithmetic on
format strings.

gcc/ChangeLog:
PR c++/43486
* tree-core.h: Document EXPR_LOCATION_WRAPPER_P's usage of
"public_flag".
* tree.c (tree_nop_conversion): Return true for location wrapper
nodes.
(maybe_wrap_with_location): New function.
(selftest::check_strip_nops): New function.
(selftest::test_location_wrappers): New function.
(selftest::tree_c_tests): Call it.
* tree.h (STRIP_ANY_LOCATION_WRAPPER): New macro.
(maybe_wrap_with_location): New decl.
(EXPR_LOCATION_WRAPPER_P): New macro.
(location_wrapper_p): New inline function.
(tree_strip_any_location_wrapper): New inline function.

From-SVN: r256448

pr82618.c (dg-options): Add -mno-stv.

* gcc.target/i386/pr82618.c (dg-options): Add -mno-stv.

From-SVN: r256447

libgo: add platform support for SuperH

    Reviewed-on: https://go-review.googlesource.com/84555

From-SVN: r256446

memcmp-1.c: Reduce runtime to something reasonable.

2018-01-10  Aaron Sawdey  <acsawdey@linux.vnet.ibm.com>

* gcc.dg/memcmp-1.c: Reduce runtime to something reasonable.

From-SVN: r256443

Add missing .a files.

Add missing .a files.  These should have been committed with the
update to go1.10beta1, but were skipped because by default Subversion
ignores all files matching *.a.

From-SVN: r256442

re PR c++/82541 (Wduplicated-branches triggers in template context)

PR c++/82541
* call.c (build_conditional_expr_1): Check complain before warning.
* pt.c (tsubst_copy_and_build) <case COND_EXPR>: Suppress
-Wduplicated-branches.

* g++.dg/warn/Wduplicated-branches4.C: New test.

From-SVN: r256441

re PR c++/81327 (cast to void* does not suppress -Wclass-memaccess)

PR c++/81327
* call.c (maybe_warn_class_memaccess): Add forward declaration.
Change last argument from tree * to const vec<tree, va_gc> *, adjust
args uses and check number of operands too.  Don't strip away any
nops.  Use maybe_constant_value when looking for INTEGER_CST args.
Deal with src argument not having pointer type.  Check
tree_fits_uhwi_p before calling tree_to_uhwi.  Remove useless
test.
(build_over_call): Call maybe_warn_class_memaccess here on the
original arguments.
(build_cxx_call): Rather than here on converted arguments.

* g++.dg/Wclass-memaccess-2.C: Don't expect a warning when explicitly
cast to void *.

From-SVN: r256440

2018-01-10  François Dumont  <fdumont@gcc.gnu.org>

* include/bits/forward_list.h
(_Fwd_list_node_base(_Fwd_list_node_base&&)): New.
(_Fwd_list_node_base& operator=(_Fwd_list_node_base&&)): New.
(_Fwd_list_node_base(const _Fwd_list_node_base&)): Explicit delete.
(_Fwd_list_node_base& operator=(const _Fwd_list_node_base&)): Likewise.
(_Fwd_list_impl()): Add noexcept qualification.
(_Fwd_list_impl(const _Node_alloc_type&)): Delete.
(_Fwd_list_impl(_Fwd_list_impl&&)): New, default.
(_Fwd_list_impl(_Fwd_list_impl&&, _Node_alloc_type&&)): New.
(_Fwd_list_base()): Default.
(_Fwd_list_base(_Fwd_list_base&&, _Node_alloc_type&&, true_type)): New.
(_Fwd_list_base(_Fwd_list_base&&)): Default.
(forward_list<>()): Default.
(forward_list<>(forward_list&&)): Default.
(forward_list(forward_list&&, _Node_alloc_type&&, false_type)): New.
(forward_list(forward_list&&, _Node_alloc_type&&, true_type)): New.
(forward_list(forward_list&&, const _Alloc&)): Adapt to use latters.
* include/bits/forward_list.tcc
(_Fwd_list_base(_Fwd_list_base&&, _Node_alloc_type&&)): Adapt to use
_M_impl._M_head move assignment.
(forward_list<>::merge(forward_list<>&&, _Comp)): Likewise.
* testsuite/23_containers/forward_list/allocator/default_init.cc: New.

From-SVN: r256439

re PR c++/81055 (ICE with invalid initializer for array new)

/cp
2018-01-10  Paolo Carlini  <paolo.carlini@oracle.com>

PR c++/81055
* init.c (build_vec_init): Avoid building an INIT_EXPR with
error_mark_node as second argument.

/testsuite
2018-01-10  Paolo Carlini  <paolo.carlini@oracle.com>

PR c++/81055
* g++.dg/cpp0x/new2.C: New.

From-SVN: r256438

re PR c/82922 (Request: add -Wstrict-prototypes to -Wextra as K&R style is obsolescent)

PR c/82922

    runtime, syscall: use full prototypes in C code

    Based on patch by Martin Sebor.

    Reviewed-on: https://go-review.googlesource.com/86815

From-SVN: r256437

i386: Also adjust stack frame for stack slot alignment

We should also adjust stack_realign_offset for the largest alignment of
stack slot actually used when stack realignment isn't needed.  This is
required to keep stack frame properly aligned to satisfy the largest
alignment of stack slots.

Tested on Linux/i686 and Linux/x86-64.

gcc/

PR target/83735
* config/i386/i386.c (ix86_compute_frame_layout): Always adjust
stack_realign_offset for the largest alignment of stack slot
actually used.
(ix86_find_max_used_stack_alignment): New function.
(ix86_finalize_stack_frame_flags): Use it.  Set
max_used_stack_alignment if we don't realign stack.
* config/i386/i386.h (machine_function): Add
max_used_stack_alignment.

gcc/testsuite/

PR target/83735
* gcc.target/i386/pr83735.c: New test.

From-SVN: r256436

exp: remove exp/proxy and exp/terminal packages

    The exp/proxy package was removed from the master library in
    https://golang.org/cl/6461056 (August, 2012).

    The exp/terminal package was removed from the master library in
    https://golang.org/cl/5970044 (March, 2012).

    I'm not sure why they lingered in the gofrontend copy, but let's
    finally remove them now.

    Reviewed-on: https://go-review.googlesource.com/87138

From-SVN: r256435

[ARM] Add -mbranch-cost option, and update a few tests

2018-01-10  Christophe Lyon  <christophe.lyon@linaro.org>

gcc/
* config/arm/arm.opt (-mbranch-cost): New option.
* config/arm/arm.h (BRANCH_COST): Take arm_branch_cost into
account.

gcc/testsuite/
* lib/target-supports.exp (check_effective_target_branch_cost):
New function.
* gcc.dg/builtin-bswap-7.c: Use branch_cost effective target.
* gcc.dg/pr21643.c: Likewise.
* gcc.dg/pr46309.c: Likewise.
* gcc.dg/tree-ssa/phi-opt-11.c: Likewise.
* gcc.dg/tree-ssa/phi-opt-2.c: Likewise.
* gcc.dg/tree-ssa/reassoc-32.c: Likewise.
* gcc.dg/tree-ssa/reassoc-33.c: Likewise.
* gcc.dg/tree-ssa/reassoc-34.c: Likewise.
* gcc.dg/tree-ssa/reassoc-35.c: Likewise.
* gcc.dg/tree-ssa/reassoc-36.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-13.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-1.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-2.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-3.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-4.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-5.c: Likewise.
* gcc.dg/tree-ssa/ssa-ifcombine-ccmp-6.c: Likewise.

From-SVN: r256434

cmd/go: check for another GCC error message

    GCC always recognizes the -fsplit-stack option, but then tests whether
    it is supported by the selected target. If not, it reports
        cc1: error: ‘-fsplit-stack’ is not supported by this compiler configuration
    Check for that error message when deciding whether a compiler option works.

    Reviewed-on: https://go-review.googlesource.com/87137

From-SVN: r256433

rs6000: Wrap diff of immediates in const (PR83629)

In various of our 32-bit load_toc patterns we take the difference of
two immediates (labels) as a term to something bigger; but this isn't
canonical RTL, it needs to be wrapped in CONST.

PR target/83629
* config/rs6000/rs6000.md (load_toc_v4_PIC_2, load_toc_v4_PIC_3b,
load_toc_v4_PIC_3c): Wrap const term in CONST RTL.

testsuite/
PR target/83629
* gcc.target/powerpc/pr83629.c: New testcase.

From-SVN: r256432

runtime: fix makemap calls in __go_construct_map

    The signature of makemap changed with the update to 1.10beta1,
    but I forgot to update the call from C code.

    Reviewed-on: https://go-review.googlesource.com/87135

From-SVN: r256431

re PR c/78768 (-Walloca-larger-than and -Wformat-length warnings disabled by -flto)

2018-01-10  Richard Biener  <rguenther@suse.de>

PR testsuite/78768
* gcc.dg/pr78768.c: Un-XFAIL.

From-SVN: r256430

re PR debug/82425 (gcc.dg/guality/inline-params-2.c fail)

2018-01-10  Richard Biener  <rguenther@suse.de>

PR debug/82425
* gcc.dg/guality/inline-params-2.c: Un-XFAIL for slim LTO.

From-SVN: r256429

re PR debug/83765 (LTO bootstrap with Ada fails)

2018-01-10  Richard Biener  <rguenther@suse.de>

PR debug/83765
* dwarf2out.c (gen_subprogram_die): Hoist old_die && declaration
early out so it also covers the case where we have a non-NULL
origin.

From-SVN: r256428

Don't use permutes for single-element accesses (PR83753)

After cunrolling the inner loop, the remaining loop in the testcase
has a single 32-bit access and a group of 64-bit accesses.  We first
try to vectorise at 128 bits (VF 4), but decide not to for cost reasons.
We then try with 64 bits (VF 2) instead.  This means that the group
of 64-bit accesses uses a single-element vector, which is deliberately
supported as of r251538.  We then try to create "permutes" for these
single-element vectors and fall foul of:

      for (i = 0; i < 6; i++)
sel[i] += exact_div (nelt, 2);

in vect_grouped_store_supported, since nelt==1.

Maybe we shouldn't even be trying to vectorise statements in the
single-element case, and instead just copy the scalar statement
for each member of the group.  But until then, this patch treats
non-strided grouped accesses as VMAT_CONTIGUOUS if no permutation
is necessary.

2018-01-10  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
PR tree-optimization/83753
* tree-vect-stmts.c (get_group_load_store_type): Use VMAT_CONTIGUOUS
for non-strided grouped accesses if the number of elements is 1.

gcc/testsuite/
PR tree-optimization/83753
* gcc.dg/torture/pr83753.c: New test.

From-SVN: r256427

PR 83740 Wrong string length type in bounds check

This patch fixes up the formatting and corrects the PR number in the
ChangeLog for r256425.

gcc/fortran/ChangeLog:

2018-01-10  Janne Blomqvist  <jb@gcc.gnu.org>

PR fortran/83740
* trans-array.c (gfc_trans_array_ctor_element): Fix formatting.

From-SVN: r256426

PR 84740 Wrong string length type in bounds check

Need to convert the RHS to the type of the LHS when assigning.

Regtested on x86_64-pc-linux-gnu, committed as obvious.

gcc/fortran/ChangeLog:

2018-01-10  Janne Blomqvist  <jb@gcc.gnu.org>

PR fortran/84740
* trans-array.c (gfc_trans_array_ctor_element): Convert RHS to the
LHS type when assigning.

From-SVN: r256425

re PR target/81616 (Update -mtune=generic for the current Intel and AMD processors)

PR target/81616
* i386.c (ix86_vectorize_builtin_gather): Check TARGET_USE_GATHER.
* i386.h (TARGET_USE_GATHER): Define.
* x86-tune.def (X86_TUNE_USE_GATHER): New.

From-SVN: r256424

avx2-gather-1.c: Add -march.

* gcc.target/i386/avx2-gather-1.c: Add -march.
* gcc.target/i386/avx2-gather-2.c: Add -march.
* gcc.target/i386/avx2-gather-3.c: Add -march.
* gcc.target/i386/avx2-gather-4.c: Add -march.
* gcc.target/i386/avx2-gather-5.c: Add -march.
* gcc.target/i386/avx2-gather-6.c: Add -march.
* gcc.target/i386/avx512f-gather-1.c: Add -march.
* gcc.target/i386/avx512f-gather-2.c: Add -march.
* gcc.target/i386/avx512f-gather-3.c: Add -march.
* gcc.target/i386/avx512f-gather-4.c: Add -march.
* gcc.target/i386/avx512f-gather-5.c: Add -march.
* gcc.target/i386/avx512f-i32gatherd512-1.c: Add -march.
* gcc.target/i386/avx512f-i32gatherd512-2.c: Add -march.
* gcc.target/i386/avx512f-i32gatherpd512-1.c: Add -march.
* gcc.target/i386/avx512f-i32gatherpd512-2.c: Add -march.
* gcc.target/i386/avx512f-i32gatherps512-1.c: Add -march.

From-SVN: r256423

Clean up partitioning in try_optimize_cfg (PR bootstrap/82831).

2018-01-10  Martin Liska  <mliska@suse.cz>

PR bootstrap/82831
* basic-block.h (CLEANUP_NO_PARTITIONING): New define.
* bb-reorder.c (pass_reorder_blocks::execute): Do not clean up
partitioning.
* cfgcleanup.c (try_optimize_cfg): Fix up partitioning if
CLEANUP_NO_PARTITIONING is not set.

From-SVN: r256422

Mostly revert r254296

r254296 added support for (const ...) wrappers around vectors,
but in the end the agreement was to use a variable-length
encoding of CONST_VECTOR (and VECTOR_CST) instead.  This patch
therefore reverts the bits that are no longer needed.

The rtl.texi part isn't a full revert, since r254296 also updated the
documentation to mention unspecs in address calculations, and to relax
the requirement that the mode had to be Pmode.

2018-01-10  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
* doc/rtl.texi: Remove documentation of (const ...) wrappers
for vectors, as a partial revert of r254296.
* rtl.h (const_vec_p): Delete.
(const_vec_duplicate_p): Don't test for vector CONSTs.
(unwrap_const_vec_duplicate, const_vec_series_p): Likewise.
* expmed.c (make_tree): Likewise.

Revert:
* common.md (E, F): Use CONSTANT_P instead of checking for
CONST_VECTOR.
* emit-rtl.c (gen_lowpart_common): Use const_vec_p instead of
checking for CONST_VECTOR.

From-SVN: r256421

re PR rtl-optimization/83575 (ICE: verify_flow_info failed (error: multiple hot/cold transitions found))

PR middle-end/83575
* predict.c (force_edge_cold): Handle in more sane way edges
with no prediction.

From-SVN: r256420

runtime: work around escaping closure in export_test.go

    When compiling runtime, it is not allowed for local variables
    and closures to be heap allocated. In one test, there is a go
    statement with a closure. In the gc compiler, it distinguishes
    capturing variable by value vs. by address, and rewrites it to
    passing the captured values as arguments. Currently we don't
    have this, and the escape analysis decides to heap allocate the
    closure and also the captured variables, which is not allowed.
    Work around it by passing the variables explicitly.

    This is in preparation of turning on escape analysis for the
    runtime.

    Reviewed-on: https://go-review.googlesource.com/86245

From-SVN: r256419

runtime: noescape some functions/variables

    This is in preparation of turning on escape analysis for the
    runtime.

    - In gccgo, systemstack is implemented with mcall, which is not
      go:noescape. Wrap the closure in noescape so the escape analysis
      does not think it escapes.

    - Mark some C functions go:noescape. They do not leak arguments.

    - Use noescape function to make a few local variables' addresses
      not escape. The escape analysis cannot figure out because they
      are assigned to pointer indirections.

    Reviewed-on: https://go-review.googlesource.com/86244

From-SVN: r256418

cmd/go: add AIX support

    For gccgo code avoid --whole-archive and -(.  Use -blibpath instead of
    -rpath.

    Reviewed-on: https://go-review.googlesource.com/86956

From-SVN: r256417

libgo: add aix build tags

    Reviewed-on: https://go-review.googlesource.com/86936

From-SVN: r256416

Daily bump.

From-SVN: r256415

compiler: use temporary variable for stack allocation

    Currently, allocation expression that can be allocated on stack
    is implemented with __builtin_alloca, which turns into
    __morestack_allocate_stack_space, which may call C malloc. This
    may be slow. Also if this happens during certain runtime
    functions (e.g. write barrier), bad things might happen (when
    the escape analysis is enabled for the runtime). Make a temporary
    variable on stack for the allocation instead.

    Also remove the write barrier in the assignment in building heap
    expression when it is stack allocated.

    Reviewed-on: https://go-review.googlesource.com/86242

From-SVN: r256412

compiler: set captured variable address to nonescape until further flooded

    The escape analysis models closures by flowing captured variable
    address to the closure node. However, the escape state for the
    address expressions remained unset as ESCAPE_UNKNOWN. This
    caused later passes to conclude that the address escapes. Fix this by
    setting its escape state to ESCAPE_NONE first. If it escapes
    (because the closure escapes), the flood phase will set its
    escape state properly.

    Reviewed-on: https://go-review.googlesource.com/86240

From-SVN: r256411

compiler: stack allocate defer thunk

    Defer statement may need to allocate a thunk. When it is not
    inside a loop, this can be stack allocated, as it runs before
    the function finishes.

    Reviewed-on: https://go-review.googlesource.com/85639

From-SVN: r256410

* es.po: Update.

From-SVN: r256408

compiler: make non-escaping Bound_method_expression not heap allocate

    Bound_method_expression needs a closure. Stack allocate the
    closure when it does not escape.

    Reviewed-on: https://go-review.googlesource.com/85638

From-SVN: r256407

compiler: move some escape check to Mark_address_taken

    Move some check of escape state earlier, from get_backend to
    Mark_address_taken. So we can reclaim escape analysis Nodes
    before kicking off the backend (not done in this CL). Also it
    makes it easier to check variables and closures do not escape
    when the escape analysis is run for the runtime package (also
    not done in this CL).

    Reviewed-on: https://go-review.googlesource.com/85735

From-SVN: r256406

compiler: support go:noescape cross package

    CL 83876 added support of go:noescape pragma, but it only works
    for functions called from the same package. The pragma did not
    take effect for exported functions that are not called from
    the same package. The reason is that top level function
    declarations are not traversed, and only reached from calls
    from other functions. This CL adds this support. The Traverse
    class is extended with a mode to traverse function declarations.

    Reviewed-on: https://go-review.googlesource.com/85637

From-SVN: r256405

compiler: stack allocate non-escaping makeslice

    If we're making a slice of constant size that does not need to
    escape, allocate it on stack.

    In lower, do not create temporaries for constant size makeslice,
    so that it is easier to detect the slice is constant size later.

    Reviewed-on: https://go-review.googlesource.com/85636

From-SVN: r256404

compiler: delay escaping sliced arrays

    Arrays that are sliced are set to escape in type checking, very
    early in compilation. The escape analysis runs later but cannot
    undo it. This CL changes it to not escape in the early stage.
    Later the escape analysis will make it escape when needed.

    Reviewed-on: https://go-review.googlesource.com/85635

From-SVN: r256403

i386: Add a test for PR target/78585

PR target/78585 has been fixed for GCC 7 by

commit 7ed04d053eead43d87dff40fb4e2904219afc4d5
Author: jakub <jakub@138bc75d-0d04-0410-961f-82ee72b054a4>
Date:   Wed Nov 30 13:02:07 2016 +0000

* config/i386/i386.c (dimode_scalar_chain::convert_op): Avoid
sharing the SUBREG rtx between move and following insn.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@243018 138bc75d-0d04-0410-961f-82ee72b054a4

PR target/78585:
* gcc.target/i386/pr78585.c: New test.

From-SVN: r256402

PR libstdc++/80276 fix pretty printers for array smart pointers

PR libstdc++/80276
* python/libstdcxx/v6/printers.py (SharedPointerPrinter)
(UniquePointerPrinter): Print correct template argument, not type of
the pointer.
(TemplateTypePrinter._recognizer.recognize): Handle failure to lookup
a type.
* testsuite/libstdc++-prettyprinters/cxx11.cc: Test unique_ptr of
array type.
* testsuite/libstdc++-prettyprinters/cxx17.cc: Test shared_ptr and
weak_ptr of array types.

From-SVN: r256400

os/signal/internal/pty: build on Solaris

    Patch from Rainer Orth.

    Reviewed-on: https://go-review.googlesource.com/87037

From-SVN: r256399

compiler: make top-level decl for address-taken non-escaping locals

    If a local variable's address is taken and passed out of its
    lexical scope, GCC backend may reuse the stack slot for the
    variable, not knowing it is still live through a pointer. In
    this case, we create a top-level temporary variable and let the
    user-defined variable refer to the temporary variable as its
    storage location. As the temporary variable is declared at the
    top level, its stack slot will remain live throughout the
    function.

    Reviewed-on: https://go-review.googlesource.com/84675

* go-gcc.cc (local_variable): Add decl_var parameter.

From-SVN: r256398

re PR c++/83734 (ice in cxx_eval _statement_list, at cp/constexpr.c:3869)

PR c++/83734
* constexpr.c (cxx_eval_statement_list): Ignore DEBUG_BEGIN_STMTs
in STATEMENT_LIST.  Remove unneeded assert.

* g++.dg/cpp0x/pr83734.C: New test.

From-SVN: r256397

re PR libstdc++/83709 (Inserting duplicates into an unordered associative containers causes the container to invalidate iterators)

2018-01-09  François Dumont  <fdumont@gcc.gnu.org>

PR libstdc++/83709
* include/bits/hashtable_policy.h
(__distance_fwd(_Iterator, _Iterator, input_iterator_tag)): Return 1 if
__first != __last.
(_Insert_base::_M_insert_range(_Ite, _Ite, _NodeGetter, true_type)): New.
(_Insert_base::_M_insert_range(_Ite, _Ite, _NodeGetter, false_type)):
Add false_type parameter.
(_Insert_base::insert): Adapt.
* include/bits/hashtable.h (_Hashtable::operator=(initializzr_list<>)):
Adapt.
(_Hashtable::_M_insert(_Arg&&, const _NodeGen&, true_type, size_t)):
 Add __n_elt parameter, defaulted to 1.
(_Hashtable::_M_insert_unique_node): Likewise. Use it to call rehash
policy _M_need_rehash.
(_Hashtable::_M_merge_unique): Pass target number of elements to add to
produce only 1 rehash if necessary.
* testsuite/23_containers/unordered_map/insert/83709.cc: New.
* testsuite/23_containers/unordered_set/insert/83709.cc: New.

From-SVN: r256396

altivec.md (p8_vmrgow): Add support for V2DI, V2DF, V4SI, V4SF types.

gcc/ChangeLog:

2018-01-09  Carl Love  <cel@us.ibm.com>

* config/rs6002/altivec.md (p8_vmrgow): Add support for V2DI, V2DF,
V4SI, V4SF types.
(p8_vmrgew): Add support for V2DI, V2DF, V4SF types.
* config/rs6000/rs6000-builtin.def: Add definitions for FLOAT2_V2DF,
VMRGEW_V2DI, VMRGEW_V2DF, VMRGEW_V4SF, VMRGOW_V4SI, VMRGOW_V4SF,
VMRGOW_V2DI, VMRGOW_V2DF.  Remove definition for VMRGOW.
* config/rs6000/rs6000-c.c (VSX_BUILTIN_VEC_FLOAT2,
P8V_BUILTIN_VEC_VMRGEW, P8V_BUILTIN_VEC_VMRGOW):  Add definitions.
* config/rs6000/rs6000-protos.h: Add extern defition for
rs6000_generate_float2_double_code.
* config/rs6000/rs6000.c (rs6000_generate_float2_double_code): Add
function.
* config/rs6000/vsx.md (vsx_xvcdpsp): Add define_insn.
(float2_v2df): Add define_expand.

gcc/testsuite/ChangeLog:

2017-01-09 Carl Love  <cel@us.ibm.com>

* gcc.target/powerpc/builtins-1.c (main): Add tests for vec_mergee and
vec_mergeo builtins with float, double, long long, unsigned long long,
bool long long  arguments.
* gcc.target/powerpc/builtins-3-runnable.c (main): Add test for
vec_float2 with double arguments.
* gcc.target/powerpc/builtins-mergew-mergow.c: New runable test for the
vec_mergew and vec_mergow builtins.

From-SVN: r256395

compiler: add escape analysis debug hash

    Add a flag -fgo-debug-escape-hash for debugging escape analysis.
    It takes a binary string, optionally led by a "-", as argument.
    When specified, the escape analysis runs only on functions whose
    name is hashed to a value with matching suffix. The "-" sign
    negates the match, i.e. the analysis runs only on functions with
    non-matching hash.

    Reviewed-on: https://go-review.googlesource.com/83878

* lang.opt (fgo-debug-escape-hash): New option.
* go-c.h (struct go_create_gogo_args): Add debug_escape_hash
field.
* go-lang.c (go_langhook_init): Set debug_escape_hash field.
* gccgo.texi (Invoking gccgo): Document -fgo-debug-escape-hash.

From-SVN: r256393