This patch modifies the analysis of assignment statements to detect an illegal
attempt to alter the value of single protected type Part_Of constituent when
inside a protected function.
2018-01-11 Hristian Kirtchev <kirtchev@adacore.com>
gcc/ada/
* sem_ch5.adb (Analyze_Assignment): Assignments to variables that act
as Part_Of consituents of single protected types are illegal when they
take place inside a protected function.
(Diagnose_Non_Variable_Lhs): Use Within_Function to check for an
enclosing function.
(Is_Protected_Part_Of_Constituent): New routine.
(Within_Function): New routine.
gcc/testsuite/
* gnat.dg/protected_func.adb, gnat.dg/protected_func.ads: New testcase.
From-SVN: r256520
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
* 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
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.
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
