1. 11 Jan, 2018 40 commits
    • [Ada] Bump copyright notices to 2018 · 4dfba737
      2018-01-11  Arnaud Charlet  <charlet@adacore.com>
      
      gcc/ada/
      
      	Bump copyright notices to 2018.
      
      From-SVN: r256519
      Arnaud Charlet committed
    • [Ada] Minor reformatting · 27d357ca
      2018-01-11  Hristian Kirtchev  <kirtchev@adacore.com>
      
      gcc/ada/
      
      	* binde.adb, par-ch6.adb, par-ch9.adb, sem_ch12.adb, sem_ch13.adb:
      	Minor reformatting.
      
      From-SVN: r256518
      Hristian Kirtchev committed
    • [Ada] No error on missing enclosing parentheses in Expression Function · cb488118
      This patch fixes an issue whereby an expression within an expression
      function declaration or completion without proper parenthesization is
      incorrectly accepted by the compiler.
      
      2018-01-11  Justin Squirek  <squirek@adacore.com>
      
      gcc/ada/
      
      	* par-ch6.adb (Scan_Body_Or_Expression_Function): Add additional check
      	to make sure a given expression function is properly parenthesized.
      
      gcc/testsuite/
      
      	* gnat.dg/expr_func4.adb: New testcase.
      
      From-SVN: r256517
      Justin Squirek committed
    • [Ada] Missing diagnostic of categorization dependency · ed27b86b
      This patch modifies the analysis of subprogram bodies to catch a case where a
      pure subprogram body unit depends on non-pure units.
      
      2018-01-11  Hristian Kirtchev  <kirtchev@adacore.com>
      
      gcc/ada/
      
      	* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Check the
      	categorization of a subprogram body which does not complete a previous
      	declaration.
      
      gcc/testsuite/
      
      	* gnat.dg/pure_subp_body.adb, gnat.dg/pure_subp_body_pkg.ads: New
      	testcase.
      
      From-SVN: r256516
      Hristian Kirtchev committed
    • [Ada] Incorrect diagnostic on illegal with clause · 715a5d51
      This patch updates the detection of illegal with clauses which import private
      child packages to properly detect a grandchild of Ada.
      
      ------------
      -- Source --
      ------------
      
      --  fake.ads
      
      package Fake is
      end Fake;
      
      --  fake-ada.ads
      
      package Fake.Ada is
      end Fake.Ada;
      
      --  fake-ada-text_io.ads
      
      package Fake.Ada.Text_IO is
      end Fake.Ada.Text_IO;
      
      --  fake-ada-text_io-float_io.ads
      
      private generic
         type Num is digits <>;
      
      package Fake.Ada.Text_IO.Float_IO is
      end Fake.Ada.Text_IO.Float_IO;
      
      --  fake-float_io.ads
      
      private generic
         type Num is digits <>;
      
      package Fake.Float_IO is
      end Fake.Float_IO;
      
      --  main.ads
      
      with Fake.Ada.Text_IO.Float_IO;
      with Fake.Float_IO;
      
      package Main is
      end Main;
      
      ----------------------------
      -- Compilation and output --
      ----------------------------
      
      $ gcc -c main.ads
      main.ads:1:06: unit in with clause is private child unit
      main.ads:1:06: current unit must also have parent "Text_IO"
      main.ads:2:06: unit in with clause is private child unit
      main.ads:2:06: current unit must also have parent "Fake"
      
      2018-01-11  Hristian Kirtchev  <kirtchev@adacore.com>
      
      gcc/ada/
      
      	* sem_ch10.adb (Check_Private_Child_Unit): Ensure that the enclosing
      	scope of package Ada is Standard.
      
      From-SVN: r256515
      Hristian Kirtchev committed
    • [Ada] Spurious error on referene to subcoponrnt in dynamic predicate · a2fd4f0e
      This patch fixes a visibility error in the expression for a dynamic predicate
      of a record type, when the expression contains a reference to a subcomponent
      of the record given by a selected component whose prefix is the name of the
      enclosing component.
      
      Executing
      
         gnatmake -q -gnata main
         ./main
      
      must yield:
      
         TGV OK
         Amtrak broken, as usual
      
      ----
      with Text_IO; use Text_IO;
      with Recpred; use Recpred;
      procedure Main is
         TGV : Train_Data;
         Amtrak : Train_Data;
      begin
        TGV  := (20, (10,10));
        Put_Line ("TGV OK");
      
        begin
           Amtrak := (30, (40, 40));
        exception
           when Others =>
              Put_Line ("Amtrak broken, as usual");
        end;
      end;
      ----
      package Recpred is
      
         type Train_Position is record
            TTD : Integer;
            VSS : Integer;
         end record;
      
         type Train_Data is record
            MA             : Integer;
            Front_Position : Train_Position;
         end record
           with Dynamic_Predicate => MA >= Front_Position.TTD;
      
      end Recpred;
      
      2018-01-11  Ed Schonberg  <schonberg@adacore.com>
      
      gcc/ada/
      
      	* sem_ch13.adb (Replace_Type_Ref): Handle properly reference to a
      	subcomponent of the current entity when building the body for a dynamic
      	predicate function for a record with composite subcomponents.
      
      From-SVN: r256514
      Ed Schonberg committed
    • [Ada] Secondary stack leaks during object initialization · 6560f851
      This patch modifies the transient scope mechanism to prevent secondary stack
      leaks during object initialization. The modifications are as follows:
      
      1) Prior to this change, the secondary stack was never managed within type
      initialization procedures, for reasons unknown. It is speculated that the
      controlled type model used at that time may have influenced this decision.
      The secondary stack is now managed within type initialization procedures
      in order to recover the memory once individual components or whole objects
      are initialized.
      
      2) A transient scope now delegates the secondary stack management to an
      enclosing scope if there is no suitable context to wrap. This ensures that
      the requirement to manage the secondary stack is not lost when the scope was
      established for that purpose in mind.
      
      3) A previous mechanism which examined the definition of a type (recursively)
      to determine whether the type will involve the secondary stack was removed
      because a) the mechanism could not detect this need with certainty, and b) the
      trigger for secondary stack usage is now moved to the resolution of function
      calls, which is always accurate.
      
      ------------
      -- Source --
      ------------
      
      --  types.ads
      
      with Ada.Finalization; use Ada.Finalization;
      
      package Types is
         type Ctrl is new Controlled with record
            Id : Integer;
         end record;
      
         procedure Initialize (Obj : in out Ctrl);
      
         function Make_Ctrl return Ctrl;
         function Make_Ctrl_From (Obj : Ctrl) return Ctrl;
      
         type Constr is array (1 .. 3) of Ctrl;
         type Unconstr is array (Integer range <>) of Ctrl;
      
         function Make_Constr return Constr;
         function Make_Unconstr (Low : Integer; High : Integer) return Unconstr;
      
         type Rec_1 is new Controlled with record
            Comp : Ctrl := Make_Ctrl;
         end record;
      
         type Rec_2 is new Controlled with record
            Comp : Ctrl := Make_Ctrl_From (Make_Ctrl);
         end record;
      
         type Rec_3 is new Controlled with record
            Comp : Constr := Make_Constr;
         end record;
      
         type Rec_4 is new Controlled with record
            Comp : Unconstr (1 .. 3) := Make_Unconstr (1, 3);
         end record;
      
         type Rec_5 is record
            Comp : Integer := 1 + Make_Ctrl.Id;
         end record;
      
         type Rec_6 is record
            Comp : Boolean := (for all X in 1 .. Make_Ctrl.Id =>
                                 X = Make_Ctrl.Id);
         end record;
      end Types;
      
      --  types.adb
      
      package body Types is
         Id_Gen : Integer := 0;
      
         procedure Initialize (Obj : in out Ctrl) is
         begin
            Id_Gen := Id_Gen + 1;
            Obj.Id := Id_Gen;
         end Initialize;
      
         function Make_Constr return Constr is
            Result : constant Constr := (others => Make_Ctrl);
         begin
            return Result;
         end Make_Constr;
      
         function Make_Ctrl return Ctrl is
            Result : Ctrl;
         begin
            return Result;
         end Make_Ctrl;
      
         function Make_Ctrl_From (Obj : Ctrl) return Ctrl is
            Result : Ctrl;
         begin
            Result.Id := Obj.Id;
            return Result;
         end Make_Ctrl_From;
      
         function Make_Unconstr (Low : Integer; High : Integer) return Unconstr is
            Result : constant Unconstr (Low .. High) := (others => Make_Ctrl);
         begin
            return Result;
         end Make_Unconstr;
      end Types;
      
      --  maker.ads
      
      generic
         type Obj_Typ is private;
      procedure Maker (Count : Positive);
      
      --  maker.adb
      
      procedure Maker (Count : Positive) is
         procedure Create is
            Obj : Obj_Typ;
            pragma Warnings (Off, Obj);
         begin null; end Create;
      
      begin
         for Iter in 1 .. Count loop
            Create;
         end loop;
      end Maker;
      
      --  leaks.adb
      
      with Maker;
      with Types; use Types;
      
      with Maker;
      with Types; use Types;
      
      procedure Leaks is
         procedure Make_1 is new Maker (Rec_1);
         procedure Make_2 is new Maker (Rec_2);
         procedure Make_3 is new Maker (Rec_3);
         procedure Make_4 is new Maker (Rec_4);
         procedure Make_5 is new Maker (Rec_5);
         procedure Make_6 is new Maker (Rec_6);
      
      begin
         Make_1 (5_000);
         Make_2 (5_000);
         Make_3 (5_000);
         Make_4 (5_000);
         Make_5 (5_000);
         Make_6 (5_000);
      end Leaks;
      
      ----------------------------
      -- Compilation and output --
      ----------------------------
      
      $ gnatmake -q leaks.adb
      $ valgrind ./leaks > leaks.txt 2>&1
      $ grep -c "still reachable" leaks.txt
      0
      
      2018-01-11  Hristian Kirtchev  <kirtchev@adacore.com>
      
      gcc/ada/
      
      	* exp_aggr.adb (Convert_Aggr_In_Object_Decl): Update the call to
      	Establish_Transient_Scope.
      	(Convert_To_Assignments): Update the call to Establish_Transient_Scope.
      	(Expand_Array_Aggregate): Update the call to Establish_Transient_Scope.
      	* exp_ch6.adb (Expand_Call_Helper): Update the call to
      	Establish_Transient_Scope.
      	(Make_Build_In_Place_Call_In_Object_Declaration): Update the call to
      	Establish_Transient_Scope.
      	* exp_ch7.adb (Establish_Transient_Scope): Restructured. Delegate the
      	management of the secondary stack to an enclosing scope if there is no
      	suitable construct to wrap, and the transient scope was intended to
      	manage the secondary stack.
      	(Find_Node_To_Be_Wrapped): Restructured. A case_statement_alternative
      	is a valid boundary for a transient expression which comes from the
      	statements of the alternative, otherwise alternatives cannot be
      	wrapped. Assignments of controlled objects which have controlled
      	actions suppressed now stop the traversal as there is no point in
      	looking for an enclosing construct. Add several N_xxx_Body choices to
      	the termination conditions for completeness.
      	* exp_ch7.ads (Establish_Transient_Scope): Update the parameter profile
      	and the associated comment on usage.
      	* exp_smem.adb (Add_Shared_Var_Lock_Procs): Update the call to
      	Establish_Transient_Scope.
      	(Add_Write_After): Update the call to Establish_Transient_Scope.
      	* sem_res.adb (Check_Initialization_Call): Removed.
      	(Resolve_Actuals): Account for additional cases where finalization
      	actions are required by utilizing predicate Needs_Finalization rather
      	than Is_Controlled.
      	(Resolve_Call): Type initialization procedures can now utilize
      	transient scopes to manage the secondary stack, thus preventing leaks
      	during initialization.  Remove the previous kludgy algorithm which
      	attempts to manage the secondary stack at the object creation site.
      
      From-SVN: r256513
      Hristian Kirtchev committed
    • [Ada] QNX: various runtime fixes for file I/O, timers, timezone · c9e80306
      2018-01-11  Jerome Lambourg  <lambourg@adacore.com>
      
      gcc/ada/
      
      	* libgnat/g-soliop__qnx.ads: New.
      	* adaint.c, adaint.h, cstreams.c, s-oscons-tmplt.c, sysdep.c: Update
      	for QNX.
      
      From-SVN: r256512
      Jerome Lambourg committed
    • [Ada] Null procedures not allowed in protected definitions · 4727f693
      The syntax rules do not allow null procedures in protected definitions. This
      patch fixes a bug that accidentally allowed them.
      
      2018-01-11  Bob Duff  <duff@adacore.com>
      
      gcc/ada/
      
      	* par-ch9.adb (P_Protected_Operation_Declaration_Opt): Give an error if
      	a null procedure occurs in a protected definition.
      
      gcc/testsuite/
      
      	* gnat.dg/protected_null.adb: New testcase.
      
      From-SVN: r256511
      Bob Duff committed
    • [Ada] Minor reformatting · 1ceee6a1
      2018-01-11  Bob Duff  <duff@adacore.com>
      
      gcc/ada/
      
      	* binderr.ads, namet.ads: Minor reformatting.
      
      From-SVN: r256510
      Bob Duff committed
    • [Ada] Improve documentation of xml2gnat · e22e7f06
      2018-01-11  Bob Duff  <duff@adacore.com>
      
      gcc/ada/
      
      	* doc/gnat_ugn/gnat_utility_programs.rst: Improve documentation of
      	xml2gnat.
      
      From-SVN: r256509
      Bob Duff committed
    • [Ada] gnatbind -f switch gives an error for duplicates · 8207dc23
      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
      Bob Duff committed
    • [Ada] Crash on expression function as completion, with implicit dereference · 52c5090a
      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
      Ed Schonberg committed
    • [Ada] Add Sphinx option -W to treat warnings as errors · 2e01b698
      2018-01-11  Ben Brosgol  <brosgol@adacore.com>
      
      gcc/ada/
      
      	* doc/Makefile: Add Sphinx option -W to treat warnings as errors.
      
      From-SVN: r256506
      Ben Brosgol committed
    • [Ada] Minor type/wording corrections · f5c31a46
      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
      Ben Brosgol committed
    • [Ada] Warning on use of predefined operations on an actual fixed-point type · 07733aa1
      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
      Ed Schonberg committed
    • exp_util.adb (Remove_Side_Effects): No action done for functions returning… · 78cac738
      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
      Javier Miranda committed
    • [Ada] Annotate standard File_Type with Default_Initial_Condition (for SPARK) · 210fef2d
      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
      Piotr Trojanek committed
    • [Ada] New implementation for Normalize_Pathname · 7d1553e2
      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
      Pascal Obry committed
    • [Ada] Update gnatpp documentation after engine change · 1646b09f
      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
      Bob Duff committed
    • [Ada] Secondary stack leak due to controlled component · 7460ccc7
      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
      Hristian Kirtchev committed
    • [Ada] Update description of restriction SPARK_05 with SPARK 2014 · a5b2e440
      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
      Yannick Moy committed
    • [Ada] Minor layout fix in documentation sources · 151af7d2
      2018-01-11  Vasiliy Fofanov  <fofanov@adacore.com>
      
      gcc/ada/
      
      	* doc/gnat_ugn/gnat_utility_programs.rst: Fix layout.
      
      From-SVN: r256497
      Vasiliy Fofanov committed
    • [Ada] Minor reformatting · 10fdda1c
      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
      Hristian Kirtchev committed
    • [Ada] Handling of pragma Predicate · 4d6000d7
      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
      Ed Schonberg committed
    • [Ada] Enable sigtramp for aarch64-vx7 · 19fb0439
      2018-01-11  Doug Rupp  <rupp@adacore.com>
      
      gcc/ada/
      
      	* init.c (vxworks): Add macro checks for __aarch64__.
      
      From-SVN: r256494
      Doug Rupp committed
    • [Ada] Different runtime behavior of Predicate_Failure · 80631298
      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
      Hristian Kirtchev committed
    • [Ada] Integer overflow in SS_Allocate · 6a5e79b4
      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
      Patrick Bernardi committed
    • [Ada] Illegal protected calls in inherited pre/postconditions · 5cb78fb8
      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
      Ed Schonberg committed
    • [Ada] Encoding of with clauses in ALI files · 94ce4941
      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
      Hristian Kirtchev committed
    • [Ada] Finding proper scope when inside entry body · 77519270
      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
      Hristian Kirtchev committed
    • [Ada] Aspect/pragma Secondary_Stack_Size can evaluate non-literals as zero · a40d9947
      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
      Patrick Bernardi committed
    • [Ada] Minor reformatting · 6b199a18
      2018-01-11  Justin Squirek  <squirek@adacore.com>
      
      gcc/ada/
      
      	* sem_ch8.adb: Minor comment fix.
      
      From-SVN: r256487
      Justin Squirek committed
    • [Ada] Missing finalization in case expression · 05344a33
      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
      Hristian Kirtchev committed
    • [Ada] Crash on iterated_component_association in expression function · d940c627
      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
      Ed Schonberg committed
    • [Ada] Wrong column in sloc of "expect name" error for loop variant · c8f25817
      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
      Justin Squirek committed
    • [Ada] Inconsistent scope chain due to quantified expression · 51f3e4e1
      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
      Hristian Kirtchev committed
    • [Ada] Fix minor comment issues · 593e3172
      2018-01-11  Piotr Trojanek  <trojanek@adacore.com>
      
      gcc/ada/
      
      	* sem_ch13.adb (Build_Predicate_Functions): Fix minor issues in
      	comment.
      
      From-SVN: r256482
      Piotr Trojanek committed
    • einfo.ads, einfo.adb (Activation_Record_Component, [...]): Allow E_Discriminant. · 89a4fa68
      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
      Arnaud Charlet committed
    • re PR tree-optimization/83189 (internal compiler error: in probability_in, at profile-count.h:1050) · 29c02e65
      
      	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
      Jan Hubicka committed