From 5d09245e6a54b290b5f44b686214b41cf555152a Mon Sep 17 00:00:00 2001 From: Arnaud Charlet Date: Mon, 9 Aug 2004 14:24:25 +0200 Subject: [multiple changes] 2004-08-09 Thomas Quinot * g-socket.adb (Abort_Selector): Initialize Buf to prevent valgrind from complaining on potential uninitialized reference. Change calls to GNAT.Sockets.Thin.Is_Socket_In_Set to account for new specification and test explicitly for non-zero return value. * g-socthi.ads (Is_Socket_In_Set): Declare imported function as returning C.int, to avoid using a derived boolean type. * exp_ch5.adb (Make_Tag_Ctrl_Assignments): Use Duplicate_Subexpr_No_Checks in preference to direct use of Remove_Side_Effects and New_Copy_Tree. Clear Comes_From_Source on prefix of 'Size attribute reference. * g-socthi.adb, g-socthi-vms.adb, g-socthi-mingw.adb, g-socthi-vxworks.adb: Change calls to GNAT.Sockets.Thin.Is_Socket_In_Set to account for new specification and test explicitly for non-zero return value. * g-socthi-vms.ads, g-socthi-mingw.ads, g-socthi-vxworks.ads: (Is_Socket_In_Set): Declare imported function as returning C.int, to avoid using a derived boolean type. 2004-08-09 Albert Lee * system-irix-n32.ads: Refine tasking priority constants for IRIX. 2004-08-09 Pascal Obry * gnat_ugn.texi: Document new way to build DLLs on Windows using GCC's -shared option. * mlib-tgt-mingw.adb (Build_Dynamic_Library): Pass GCC's options into Options_2 parameter (options put after object files). 2004-08-09 Olivier Hainque * decl.c (gnat_to_gnu_entity) : Adjust condition to ignore overflows on low and high bounds of an index to also account for differences in signedness between sizetype and gnu_index_subtype. These are as legitimate as the ones caused by a lower TYPE_PRECISION on sizetype. 2004-08-09 Robert Dewar * s-solita.ads, s-solita.adb: Minor reformatting * gnat_rm.texi: Add documentation for pragma Profile (Restricted) Move pragma Restricted_Run_Time, No_Run_Time, Ravenscar to new obsolescent section Add note that No_Implicit_Conditionals does not suppress run time constraint checks. * vms_conv.ads: Minor reformatting * s-secsta.adb: Use SS_Ptr instead of Mark_Id as stack pointer (cleanup and necessary for following change). (Mark): Return new format Mark_Id containing sec stack address (Release): Use sec stack address from Mark_Id avoiding Self call * s-secsta.ads: Define SS_Ptr to be used instead of Mark_Id as stack pointer (cleanup and necessary for following change). Define Mark_Id as record containing address of secondary stack, that way Release does not need to find the stack again, decreasing the number of calls to Self and improving efficiency. * sem_util.ads: Add a ??? comment for Is_Local_Variable_Reference * sem_ch5.adb (Analyze_Case_Statement): Add circuitry to track value of case variable into the individual case branches when possible. * sem_ch11.adb: Minor reformatting * prj.ads: Correct spelling of suffixs * prj-nmsc.adb: Minor reformatting Correct spelling suffixs throughout (also in identifiers) * freeze.adb: Minor spelling correction * exp_ch2.adb: Cleanups to handling of Current_Value (no functional effect). * bld.adb: Correct spelling of suffixs * einfo.adb (Enclosing_Dynamic_Scope): Defend against junk argument 2004-08-09 Ed Schonberg PR ada/15408 * sem_ch7.adb (Install_Private_Declarations): In the body of the package or of a child, private entities are both immediately_visible and not hidden. 2004-08-09 Ed Schonberg * sem_eval.adb (Eval_Integer_Literal): If the context is Any_Integer, there are no range checks on the value of the literal. * exp_ch7.adb (Insert_Actions_In_Scope_Around): If the node being wrapped is the triggering alternative of an asynchronous select, action statements mustbe inserted before the select itself. * sem_attr.adb (Analyze_Attribute, case 'Size): Handle properly the case where the prefix is a protected function call. (Resolve_Attribute, case 'Access): The attribute reference on a subprogram is legal in a generic body if the subprogram is declared elsewhere. 2004-08-09 Vincent Celier * makegpr.adb (Build_Library): Link with g++ if C++ is one of the languages, otherwise building the library may fail with unresolved symbols. (Compile_Sources): Do not build libraries if -c switch is used * gnatlink.adb (Process_Args): New switches -M and -Mmap (Write_Usage): If map file creation is supported, output new switches -M and -Mmap. (Gnatlink): When -M is specified, add the necessary switch(es) to the gcc call, when supported. * Makefile.in: Added indepsw.o to the object list for gnatlink Specified the AIX, GNU/Linux and Windows versions of indepsw.adb * indepsw-aix.adb, indepsw-linux.adb, indepsw-mingw.adb, indepsw.adb, indepsw.ads: New files. 2004-08-09 Bernard Banner * system-vxworks-x86.ads, s-vxwork-x86.ads: New files. * Makefile.in: add section for vxworks x86 2004-08-09 Hristian Kirtchev * exp_ch3.adb (Build_Init_Statements): Add extra condition to deal with per-object constrained components where the discriminant is of an Access type. (Build_Record_Init_Proc): Add condition to prevent the inheritance of the parent initialization procedure for derived Unchecked_Unions. Instead, derived Unchecked_Unions build their own initialization procedure. (Build_Variant_Record_Equality): Implement Unchecked_Union equality. Check the body of the subprogram for details. (Freeze_Record_Type): Prevent the inheritance of discriminant checking functions for derived Unchecked_Union types by introducing a condition. Allow the creation of TSS equality functions for Unchecked_Unions. (Make_Eq_Case): Rename formal parameter Node to E in function signature. Add formal parameter Discr to function signature. Discr is used to control the generated case statement for Unchecked_Union types. (Make_Eq_If): Rename formal parameter Node to E in function signature. * exp_ch4.adb (Build_Equality_Call): Implement equality calls for Unchecked_Unions. Check the body of the subprogram for details. (Expand_Composite_Equality): Augment composite type equality to include correct handling of Unchecked_Union components. (Expand_N_In): Add condition to detect illegal membership tests when the subtype mark is a constrained Unchecked_Union and the expression lacks inferable discriminants, and build a Raise_Program_Error node. (Expand_N_Op_Eq): Add function Has_Unconstrained_UU_Component. Used to detect types that contain components of unconstrained Unchecked_Union subtype. Add condition to detect equality between types that have an unconstrained Unchecked_Union component, and build a Raise_Program_Error node. Add condition to detect equality between Unchecked_Union types that lack inferable discriminants, and build a Raise_Program_Error node. Otherwise build a TSS equality function call. (Expand_N_Type_Conversion): Add condition to detect illegal conversions from a derived Unchecked_Union to an unconstrained non-Unchecked_Union with the operand lacking inferable discriminants, and build a Raise_ Program_Error node. (Expand_Record_Equality): Remove guard that prevents Unchecked_Union composite equality. (Has_Inferable_Discriminants): Implement new predicate for objects and expressions of Unchecked_Union type. Check the body of subprogram for details. (Has_Unconstrained_UU_Components): Add function Component_Is_Unconstrained_UU. It is used to detect whether a single component is of an unconstrained Unchecked_Union subtype. Add function Variant_Is_Unconstrained_UU. It is used to detect whether a single component inside a variant is of an unconstrained Unchecked_Union type. * exp_ch5.adb (Expand_Assign_Record): Add condition to copy the inferred discriminant values. Add condition to generate a case statement with an inferred discriminant as the switch. (Make_Component_List_Assign): Introduce a Boolean flag that determines the behaviour of the subprogram in the presence of an Unchecked_Union. Add condition to trigger the usage of the inferred discriminant value as the generated case statement switch. (Make_Field_Assign): Introduce a Boolean flag that determines the behaviour of the subprogram in the presence of an Unchecked_Union. Add condition to trigger the usage of the inferred discriminant value as the right-hand side of the generated assignment. * exp_ch6.adb (Expand_Call): Add condition to skip extra actual parameter generation when dealing with Unchecked_Unions. * checks.adb (Apply_Discriminant_Check): Do not apply discriminant checks for Unchecked_Unions. * einfo.ads: Update comment on usage of flag Has_Per_Object_Constraint * exp_attr.adb (Expand_N_Attribute_Reference): Produce Raise_Program_Error nodes for the execution of Read and Write attributes of Unchecked_Union types and the execution of Input and Output attributes of Unchecked_Union types that lack default discriminant values. * sem_prag.adb (Analyze_Pragma): Remodel the analysis of pragma Unchecked_Union. Add procedure Check_Component. It is used to inspect per-object constrained components of Unchecked_Unions for being Unchecked_Unions themselves. Add procedure Check_Variant. It is used to check individual components withing a variant. * sem_res.adb (Resolve_Comparison_Op): Remove guard that prevents comparison of Unchecked_Unions. (Resolve_Equality_OP): Remove guard that prevents equality between Unchecked_Unions. * sem_util.adb (Build_Component_Subtype): Add guard to prevent creation of component subtypes for Unchecked_Union components. (Get_Actual_Subtype): Add condition that returs the Unchecked_Union type since it is the actual subtype. * sem_ch12.adb (Instantiate_Type): Add condition to detect the correct pass of Unchecked_Union subtypes as generic actuals to formal types that lack known_discriminant_parts or that are derived Unchecked_Union types, and do nothing. In any other case, produce an error message. * sem_ch3.adb (Analyze_Component_Declaration): Add function Contains_POC. It determines whether a constraint uses the discriminant of an enclosing record type. Add condition to detect per-object constrained component and set the appropriate flag. (Derived_Type_Declaration): Remove guard that prevents derivation from Unchecked_Union types. (Process_Subtype): Remove quard that prevents the creation of Unchecked_ Union subtypes. * sem_ch4.adb (Analyze_Selected_Component): Correct the detection of references to Unchecked_Union discriminants. * sem_ch6.adb (Create_Extra_Formals): Add condition to skip extra formal generation when dealing with Unchecked_Unions. (Set_Actual_Subtypes): Add condition to prevent generation of actual subtypes for Unchecked_Unions. * sem_ch7.adb (Analyze_Package_Specification): Add procedure Inspect_Unchecked_Union_Completion. It is used to detect incorrect completions of discriminated partial views by Unchecked_Unions and produce an error message. 2004-08-09 Richard Kenner * trans.c (struct stmt_group): New field, GLOBAL. (global_stmt_group, gnu_elab_proc_decl, build_unit_elab): Deleted. (struct elab_info): New struct. (elab_info_list, gnu_elab_proc_stack): New variables. (Compilation_Unit_to_gnu): New procedure. (gigi): Call it and also handle elaboration procs we've saved. (gnat_init_stmt_group): Don't set global_stmt_group; instead initialize global field from parent. (gnat_to_gnu): Get decl from gnu_elab_proc_stack. (gnat_to_gnu, case N_Compilation_Unit): Call Compilation_Unit_to_gnu. (start_stmt_group): Initialize global field from parent. (add_decl_expr): Set to global for current statement group. (gnat_gimplify_expr, case NULL_EXPR): Add operand 0 to pre list, not post. * utils.c (global_bindings_p): True when no current_function_decl; no longer check current_binding_level. 2004-08-09 Ben Brosgol * xgnatugn.adb: Added logic to deal with @ifset/@ifclear for edition choice. * gnat_rm.texi, gnat_ugn.texi: Added edition conditionalization logic. From-SVN: r85714 --- gcc/ada/exp_ch3.adb | 206 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 164 insertions(+), 42 deletions(-) (limited to 'gcc/ada/exp_ch3.adb') diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index 3fec8c15780..39d704efab5 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -179,21 +179,27 @@ package body Exp_Ch3 is -- Check if E is defined in the RTL (in a child of Ada or System). Used -- to avoid to bring in the overhead of _Input, _Output for tagged types. - function Make_Eq_Case (Node : Node_Id; CL : Node_Id) return List_Id; + function Make_Eq_Case + (E : Entity_Id; + CL : Node_Id; + Discr : Entity_Id := Empty) return List_Id; -- Building block for variant record equality. Defined to share the -- code between the tagged and non-tagged case. Given a Component_List -- node CL, it generates an 'if' followed by a 'case' statement that -- compares all components of local temporaries named X and Y (that - -- are declared as formals at some upper level). Node provides the - -- Sloc to be used for the generated code. + -- are declared as formals at some upper level). E provides the Sloc to be + -- used for the generated code. Discr is used as the case statement switch + -- in the case of Unchecked_Union equality. - function Make_Eq_If (Node : Node_Id; L : List_Id) return Node_Id; + function Make_Eq_If + (E : Entity_Id; + L : List_Id) return Node_Id; -- Building block for variant record equality. Defined to share the -- code between the tagged and non-tagged case. Given the list of -- components (or discriminants) L, it generates a return statement -- that compares all components of local temporaries named X and Y - -- (that are declared as formals at some upper level). Node provides - -- the Sloc to be used for the generated code. + -- (that are declared as formals at some upper level). E provides the Sloc + -- to be used for the generated code. procedure Make_Predefined_Primitive_Specs (Tag_Typ : Entity_Id; @@ -1920,6 +1926,39 @@ package body Exp_Ch3 is Id : Entity_Id; Typ : Entity_Id; + function Has_Access_Constraint (E : Entity_Id) return Boolean; + -- Components with access discriminants that depend on the current + -- instance must be initialized after all other components. + + --------------------------- + -- Has_Access_Constraint -- + --------------------------- + + function Has_Access_Constraint (E : Entity_Id) return Boolean is + Disc : Entity_Id; + T : constant Entity_Id := Etype (E); + + begin + if Has_Per_Object_Constraint (E) + and then Has_Discriminants (T) + then + Disc := First_Discriminant (T); + while Present (Disc) loop + if Is_Access_Type (Etype (Disc)) then + return True; + end if; + + Next_Discriminant (Disc); + end loop; + + return False; + else + return False; + end if; + end Has_Access_Constraint; + + -- Start of processing for Build_Init_Statements + begin if Null_Present (Comp_List) then return New_List (Make_Null_Statement (Loc)); @@ -1934,7 +1973,7 @@ package body Exp_Ch3 is Per_Object_Constraint_Components := False; - -- First step : regular components. + -- First step : regular components Decl := First_Non_Pragma (Component_Items (Comp_List)); while Present (Decl) loop @@ -1945,7 +1984,7 @@ package body Exp_Ch3 is Id := Defining_Identifier (Decl); Typ := Etype (Id); - if Has_Per_Object_Constraint (Id) + if Has_Access_Constraint (Id) and then No (Expression (Decl)) then -- Skip processing for now and ask for a second pass @@ -2025,7 +2064,7 @@ package body Exp_Ch3 is Id := Defining_Identifier (Decl); Typ := Etype (Id); - if Has_Per_Object_Constraint (Id) + if Has_Access_Constraint (Id) and then No (Expression (Decl)) then if Has_Non_Null_Base_Init_Proc (Typ) then @@ -2457,6 +2496,7 @@ package body Exp_Ch3 is if Is_Derived_Type (Rec_Type) and then not Is_Tagged_Type (Rec_Type) + and then not Is_Unchecked_Union (Rec_Type) and then not Has_New_Non_Standard_Rep (Rec_Type) and then not Parent_Subtype_Renaming_Discrims and then Has_Non_Null_Base_Init_Proc (Etype (Rec_Type)) @@ -2466,7 +2506,9 @@ package body Exp_Ch3 is -- Otherwise if we need an initialization procedure, then build one, -- mark it as public and inlinable and as having a completion. - elsif Requires_Init_Proc (Rec_Type) then + elsif Requires_Init_Proc (Rec_Type) + or else Is_Unchecked_Union (Rec_Type) + then Build_Init_Procedure; Set_Is_Public (Proc_Id, Is_Public (Pe)); @@ -2849,9 +2891,14 @@ package body Exp_Ch3 is Def : constant Node_Id := Parent (Typ); Comps : constant Node_Id := Component_List (Type_Definition (Def)); Stmts : constant List_Id := New_List; + Pspecs : constant List_Id := New_List; begin + -- Derived Unchecked_Union types no longer inherit the equality function + -- of their parent. + if Is_Derived_Type (Typ) + and then not Is_Unchecked_Union (Typ) and then not Has_New_Non_Standard_Rep (Typ) then declare @@ -2871,34 +2918,86 @@ package body Exp_Ch3 is Specification => Make_Function_Specification (Loc, Defining_Unit_Name => F, - Parameter_Specifications => New_List ( - Make_Parameter_Specification (Loc, - Defining_Identifier => X, - Parameter_Type => New_Reference_To (Typ, Loc)), - - Make_Parameter_Specification (Loc, - Defining_Identifier => Y, - Parameter_Type => New_Reference_To (Typ, Loc))), - + Parameter_Specifications => Pspecs, Subtype_Mark => New_Reference_To (Standard_Boolean, Loc)), - Declarations => New_List, Handled_Statement_Sequence => Make_Handled_Sequence_Of_Statements (Loc, Statements => Stmts))); - -- For unchecked union case, raise program error. This will only - -- happen in the case of dynamic dispatching for a tagged type, - -- since in the static cases it is a compile time error. + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => X, + Parameter_Type => New_Reference_To (Typ, Loc))); + + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => Y, + Parameter_Type => New_Reference_To (Typ, Loc))); + + -- Unchecked_Unions require additional machinery to support equality. + -- Two extra parameters (A and B) are added to the equality function + -- parameter list in order to capture the inferred values of the + -- discriminants in later calls. + + if Is_Unchecked_Union (Typ) then + declare + Discr_Type : constant Node_Id := Etype (First_Discriminant (Typ)); + + A : constant Node_Id := + Make_Defining_Identifier (Loc, + Chars => Name_A); + + B : constant Node_Id := + Make_Defining_Identifier (Loc, + Chars => Name_B); + + begin + -- Add A and B to the parameter list + + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => A, + Parameter_Type => New_Reference_To (Discr_Type, Loc))); + + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => B, + Parameter_Type => New_Reference_To (Discr_Type, Loc))); + + -- Generate the following header code to compare the inferred + -- discriminants: + + -- if a /= b then + -- return False; + -- end if; + + Append_To (Stmts, + Make_If_Statement (Loc, + Condition => + Make_Op_Ne (Loc, + Left_Opnd => New_Reference_To (A, Loc), + Right_Opnd => New_Reference_To (B, Loc)), + Then_Statements => New_List ( + Make_Return_Statement (Loc, + Expression => New_Occurrence_Of (Standard_False, Loc))))); + + -- Generate component-by-component comparison. Note that we must + -- propagate one of the inferred discriminant formals to act as + -- the case statement switch. + + Append_List_To (Stmts, + Make_Eq_Case (Typ, Comps, A)); + + end; + + -- Normal case (not unchecked union) - if Has_Unchecked_Union (Typ) then - Append_To (Stmts, - Make_Raise_Program_Error (Loc, - Reason => PE_Unchecked_Union_Restriction)); else Append_To (Stmts, Make_Eq_If (Typ, Discriminant_Specifications (Def))); + Append_List_To (Stmts, Make_Eq_Case (Typ, Comps)); end if; @@ -4160,6 +4259,12 @@ package body Exp_Ch3 is elsif Is_Derived_Type (Def_Id) and then not Is_Tagged_Type (Def_Id) + + -- If we have a derived Unchecked_Union, we do not inherit the + -- discriminant checking functions from the parent type since the + -- discriminants are non existent. + + and then not Is_Unchecked_Union (Def_Id) and then Has_Discriminants (Def_Id) then declare @@ -4329,7 +4434,6 @@ package body Exp_Ch3 is begin if Present (Comps) and then Present (Variant_Part (Comps)) - and then not Is_Unchecked_Union (Def_Id) then Build_Variant_Record_Equality (Def_Id); end if; @@ -5108,14 +5212,18 @@ package body Exp_Ch3 is -- when Vn => on subcomponents -- end case; - function Make_Eq_Case (Node : Node_Id; CL : Node_Id) return List_Id is - Loc : constant Source_Ptr := Sloc (Node); + function Make_Eq_Case + (E : Entity_Id; + CL : Node_Id; + Discr : Entity_Id := Empty) return List_Id + is + Loc : constant Source_Ptr := Sloc (E); Result : constant List_Id := New_List; Variant : Node_Id; Alt_List : List_Id; begin - Append_To (Result, Make_Eq_If (Node, Component_Items (CL))); + Append_To (Result, Make_Eq_If (E, Component_Items (CL))); if No (Variant_Part (CL)) then return Result; @@ -5133,18 +5241,29 @@ package body Exp_Ch3 is Append_To (Alt_List, Make_Case_Statement_Alternative (Loc, Discrete_Choices => New_Copy_List (Discrete_Choices (Variant)), - Statements => Make_Eq_Case (Node, Component_List (Variant)))); + Statements => Make_Eq_Case (E, Component_List (Variant)))); Next_Non_Pragma (Variant); end loop; - Append_To (Result, - Make_Case_Statement (Loc, - Expression => - Make_Selected_Component (Loc, - Prefix => Make_Identifier (Loc, Name_X), - Selector_Name => New_Copy (Name (Variant_Part (CL)))), - Alternatives => Alt_List)); + -- If we have an Unchecked_Union, use one of the parameters that + -- captures the discriminants. + + if Is_Unchecked_Union (E) then + Append_To (Result, + Make_Case_Statement (Loc, + Expression => New_Reference_To (Discr, Loc), + Alternatives => Alt_List)); + + else + Append_To (Result, + Make_Case_Statement (Loc, + Expression => + Make_Selected_Component (Loc, + Prefix => Make_Identifier (Loc, Name_X), + Selector_Name => New_Copy (Name (Variant_Part (CL)))), + Alternatives => Alt_List)); + end if; return Result; end Make_Eq_Case; @@ -5166,8 +5285,11 @@ package body Exp_Ch3 is -- or a null statement if the list L is empty - function Make_Eq_If (Node : Node_Id; L : List_Id) return Node_Id is - Loc : constant Source_Ptr := Sloc (Node); + function Make_Eq_If + (E : Entity_Id; + L : List_Id) return Node_Id + is + Loc : constant Source_Ptr := Sloc (E); C : Node_Id; Field_Name : Name_Id; Cond : Node_Id; @@ -5213,7 +5335,7 @@ package body Exp_Ch3 is else return - Make_Implicit_If_Statement (Node, + Make_Implicit_If_Statement (E, Condition => Cond, Then_Statements => New_List ( Make_Return_Statement (Loc, -- cgit v1.2.1