URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [exp_attr.adb] - Rev 717
Go to most recent revision | Compare with Previous | Blame | View Log
------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- E X P _ A T T R -- -- -- -- B o d y -- -- -- -- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- -- -- -- GNAT is free software; you can redistribute it and/or modify it under -- -- terms of the GNU General Public License as published by the Free Soft- -- -- ware Foundation; either version 3, or (at your option) any later ver- -- -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- -- for more details. You should have received a copy of the GNU General -- -- Public License distributed with GNAT; see file COPYING3. If not, go to -- -- http://www.gnu.org/licenses for a complete copy of the license. -- -- -- -- GNAT was originally developed by the GNAT team at New York University. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- -- -- ------------------------------------------------------------------------------ with Atree; use Atree; with Checks; use Checks; with Einfo; use Einfo; with Elists; use Elists; with Exp_Atag; use Exp_Atag; with Exp_Ch2; use Exp_Ch2; with Exp_Ch3; use Exp_Ch3; with Exp_Ch6; use Exp_Ch6; with Exp_Ch9; use Exp_Ch9; with Exp_Dist; use Exp_Dist; with Exp_Imgv; use Exp_Imgv; with Exp_Pakd; use Exp_Pakd; with Exp_Strm; use Exp_Strm; with Exp_Tss; use Exp_Tss; with Exp_Util; use Exp_Util; with Exp_VFpt; use Exp_VFpt; with Fname; use Fname; with Freeze; use Freeze; with Gnatvsn; use Gnatvsn; with Itypes; use Itypes; with Lib; use Lib; with Namet; use Namet; with Nmake; use Nmake; with Nlists; use Nlists; with Opt; use Opt; with Restrict; use Restrict; with Rident; use Rident; with Rtsfind; use Rtsfind; with Sem; use Sem; with Sem_Aux; use Sem_Aux; with Sem_Ch6; use Sem_Ch6; with Sem_Ch7; use Sem_Ch7; with Sem_Ch8; use Sem_Ch8; with Sem_Eval; use Sem_Eval; with Sem_Res; use Sem_Res; with Sem_Util; use Sem_Util; with Sinfo; use Sinfo; with Snames; use Snames; with Stand; use Stand; with Stringt; use Stringt; with Targparm; use Targparm; with Tbuild; use Tbuild; with Ttypes; use Ttypes; with Uintp; use Uintp; with Uname; use Uname; with Validsw; use Validsw; package body Exp_Attr is ----------------------- -- Local Subprograms -- ----------------------- procedure Compile_Stream_Body_In_Scope (N : Node_Id; Decl : Node_Id; Arr : Entity_Id; Check : Boolean); -- The body for a stream subprogram may be generated outside of the scope -- of the type. If the type is fully private, it may depend on the full -- view of other types (e.g. indexes) that are currently private as well. -- We install the declarations of the package in which the type is declared -- before compiling the body in what is its proper environment. The Check -- parameter indicates if checks are to be suppressed for the stream body. -- We suppress checks for array/record reads, since the rule is that these -- are like assignments, out of range values due to uninitialized storage, -- or other invalid values do NOT cause a Constraint_Error to be raised. procedure Expand_Access_To_Protected_Op (N : Node_Id; Pref : Node_Id; Typ : Entity_Id); -- An attribute reference to a protected subprogram is transformed into -- a pair of pointers: one to the object, and one to the operations. -- This expansion is performed for 'Access and for 'Unrestricted_Access. procedure Expand_Fpt_Attribute (N : Node_Id; Pkg : RE_Id; Nam : Name_Id; Args : List_Id); -- This procedure expands a call to a floating-point attribute function. -- N is the attribute reference node, and Args is a list of arguments to -- be passed to the function call. Pkg identifies the package containing -- the appropriate instantiation of System.Fat_Gen. Float arguments in Args -- have already been converted to the floating-point type for which Pkg was -- instantiated. The Nam argument is the relevant attribute processing -- routine to be called. This is the same as the attribute name, except in -- the Unaligned_Valid case. procedure Expand_Fpt_Attribute_R (N : Node_Id); -- This procedure expands a call to a floating-point attribute function -- that takes a single floating-point argument. The function to be called -- is always the same as the attribute name. procedure Expand_Fpt_Attribute_RI (N : Node_Id); -- This procedure expands a call to a floating-point attribute function -- that takes one floating-point argument and one integer argument. The -- function to be called is always the same as the attribute name. procedure Expand_Fpt_Attribute_RR (N : Node_Id); -- This procedure expands a call to a floating-point attribute function -- that takes two floating-point arguments. The function to be called -- is always the same as the attribute name. procedure Expand_Pred_Succ (N : Node_Id); -- Handles expansion of Pred or Succ attributes for case of non-real -- operand with overflow checking required. function Get_Index_Subtype (N : Node_Id) return Entity_Id; -- Used for Last, Last, and Length, when the prefix is an array type. -- Obtains the corresponding index subtype. procedure Find_Fat_Info (T : Entity_Id; Fat_Type : out Entity_Id; Fat_Pkg : out RE_Id); -- Given a floating-point type T, identifies the package containing the -- attributes for this type (returned in Fat_Pkg), and the corresponding -- type for which this package was instantiated from Fat_Gen. Error if T -- is not a floating-point type. function Find_Stream_Subprogram (Typ : Entity_Id; Nam : TSS_Name_Type) return Entity_Id; -- Returns the stream-oriented subprogram attribute for Typ. For tagged -- types, the corresponding primitive operation is looked up, else the -- appropriate TSS from the type itself, or from its closest ancestor -- defining it, is returned. In both cases, inheritance of representation -- aspects is thus taken into account. function Full_Base (T : Entity_Id) return Entity_Id; -- The stream functions need to examine the underlying representation of -- composite types. In some cases T may be non-private but its base type -- is, in which case the function returns the corresponding full view. function Get_Stream_Convert_Pragma (T : Entity_Id) return Node_Id; -- Given a type, find a corresponding stream convert pragma that applies to -- the implementation base type of this type (Typ). If found, return the -- pragma node, otherwise return Empty if no pragma is found. function Is_Constrained_Packed_Array (Typ : Entity_Id) return Boolean; -- Utility for array attributes, returns true on packed constrained -- arrays, and on access to same. function Is_Inline_Floating_Point_Attribute (N : Node_Id) return Boolean; -- Returns true iff the given node refers to an attribute call that -- can be expanded directly by the back end and does not need front end -- expansion. Typically used for rounding and truncation attributes that -- appear directly inside a conversion to integer. ---------------------------------- -- Compile_Stream_Body_In_Scope -- ---------------------------------- procedure Compile_Stream_Body_In_Scope (N : Node_Id; Decl : Node_Id; Arr : Entity_Id; Check : Boolean) is Installed : Boolean := False; Scop : constant Entity_Id := Scope (Arr); Curr : constant Entity_Id := Current_Scope; begin if Is_Hidden (Arr) and then not In_Open_Scopes (Scop) and then Ekind (Scop) = E_Package then Push_Scope (Scop); Install_Visible_Declarations (Scop); Install_Private_Declarations (Scop); Installed := True; -- The entities in the package are now visible, but the generated -- stream entity must appear in the current scope (usually an -- enclosing stream function) so that itypes all have their proper -- scopes. Push_Scope (Curr); end if; if Check then Insert_Action (N, Decl); else Insert_Action (N, Decl, Suppress => All_Checks); end if; if Installed then -- Remove extra copy of current scope, and package itself Pop_Scope; End_Package_Scope (Scop); end if; end Compile_Stream_Body_In_Scope; ----------------------------------- -- Expand_Access_To_Protected_Op -- ----------------------------------- procedure Expand_Access_To_Protected_Op (N : Node_Id; Pref : Node_Id; Typ : Entity_Id) is -- The value of the attribute_reference is a record containing two -- fields: an access to the protected object, and an access to the -- subprogram itself. The prefix is a selected component. Loc : constant Source_Ptr := Sloc (N); Agg : Node_Id; Btyp : constant Entity_Id := Base_Type (Typ); Sub : Entity_Id; Sub_Ref : Node_Id; E_T : constant Entity_Id := Equivalent_Type (Btyp); Acc : constant Entity_Id := Etype (Next_Component (First_Component (E_T))); Obj_Ref : Node_Id; Curr : Entity_Id; function May_Be_External_Call return Boolean; -- If the 'Access is to a local operation, but appears in a context -- where it may lead to a call from outside the object, we must treat -- this as an external call. Clearly we cannot tell without full -- flow analysis, and a subsequent call that uses this 'Access may -- lead to a bounded error (trying to seize locks twice, e.g.). For -- now we treat 'Access as a potential external call if it is an actual -- in a call to an outside subprogram. -------------------------- -- May_Be_External_Call -- -------------------------- function May_Be_External_Call return Boolean is Subp : Entity_Id; Par : Node_Id := Parent (N); begin -- Account for the case where the Access attribute is part of a -- named parameter association. if Nkind (Par) = N_Parameter_Association then Par := Parent (Par); end if; if Nkind_In (Par, N_Procedure_Call_Statement, N_Function_Call) and then Is_Entity_Name (Name (Par)) then Subp := Entity (Name (Par)); return not In_Open_Scopes (Scope (Subp)); else return False; end if; end May_Be_External_Call; -- Start of processing for Expand_Access_To_Protected_Op begin -- Within the body of the protected type, the prefix designates a local -- operation, and the object is the first parameter of the corresponding -- protected body of the current enclosing operation. if Is_Entity_Name (Pref) then if May_Be_External_Call then Sub := New_Occurrence_Of (External_Subprogram (Entity (Pref)), Loc); else Sub := New_Occurrence_Of (Protected_Body_Subprogram (Entity (Pref)), Loc); end if; -- Don't traverse the scopes when the attribute occurs within an init -- proc, because we directly use the _init formal of the init proc in -- that case. Curr := Current_Scope; if not Is_Init_Proc (Curr) then pragma Assert (In_Open_Scopes (Scope (Entity (Pref)))); while Scope (Curr) /= Scope (Entity (Pref)) loop Curr := Scope (Curr); end loop; end if; -- In case of protected entries the first formal of its Protected_ -- Body_Subprogram is the address of the object. if Ekind (Curr) = E_Entry then Obj_Ref := New_Occurrence_Of (First_Formal (Protected_Body_Subprogram (Curr)), Loc); -- If the current scope is an init proc, then use the address of the -- _init formal as the object reference. elsif Is_Init_Proc (Curr) then Obj_Ref := Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (First_Formal (Curr), Loc), Attribute_Name => Name_Address); -- In case of protected subprograms the first formal of its -- Protected_Body_Subprogram is the object and we get its address. else Obj_Ref := Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (First_Formal (Protected_Body_Subprogram (Curr)), Loc), Attribute_Name => Name_Address); end if; -- Case where the prefix is not an entity name. Find the -- version of the protected operation to be called from -- outside the protected object. else Sub := New_Occurrence_Of (External_Subprogram (Entity (Selector_Name (Pref))), Loc); Obj_Ref := Make_Attribute_Reference (Loc, Prefix => Relocate_Node (Prefix (Pref)), Attribute_Name => Name_Address); end if; Sub_Ref := Make_Attribute_Reference (Loc, Prefix => Sub, Attribute_Name => Name_Access); -- We set the type of the access reference to the already generated -- access_to_subprogram type, and declare the reference analyzed, to -- prevent further expansion when the enclosing aggregate is analyzed. Set_Etype (Sub_Ref, Acc); Set_Analyzed (Sub_Ref); Agg := Make_Aggregate (Loc, Expressions => New_List (Obj_Ref, Sub_Ref)); -- Sub_Ref has been marked as analyzed, but we still need to make sure -- Sub is correctly frozen. Freeze_Before (N, Entity (Sub)); Rewrite (N, Agg); Analyze_And_Resolve (N, E_T); -- For subsequent analysis, the node must retain its type. The backend -- will replace it with the equivalent type where needed. Set_Etype (N, Typ); end Expand_Access_To_Protected_Op; -------------------------- -- Expand_Fpt_Attribute -- -------------------------- procedure Expand_Fpt_Attribute (N : Node_Id; Pkg : RE_Id; Nam : Name_Id; Args : List_Id) is Loc : constant Source_Ptr := Sloc (N); Typ : constant Entity_Id := Etype (N); Fnm : Node_Id; begin -- The function name is the selected component Attr_xxx.yyy where -- Attr_xxx is the package name, and yyy is the argument Nam. -- Note: it would be more usual to have separate RE entries for each -- of the entities in the Fat packages, but first they have identical -- names (so we would have to have lots of renaming declarations to -- meet the normal RE rule of separate names for all runtime entities), -- and second there would be an awful lot of them! Fnm := Make_Selected_Component (Loc, Prefix => New_Reference_To (RTE (Pkg), Loc), Selector_Name => Make_Identifier (Loc, Nam)); -- The generated call is given the provided set of parameters, and then -- wrapped in a conversion which converts the result to the target type -- We use the base type as the target because a range check may be -- required. Rewrite (N, Unchecked_Convert_To (Base_Type (Etype (N)), Make_Function_Call (Loc, Name => Fnm, Parameter_Associations => Args))); Analyze_And_Resolve (N, Typ); end Expand_Fpt_Attribute; ---------------------------- -- Expand_Fpt_Attribute_R -- ---------------------------- -- The single argument is converted to its root type to call the -- appropriate runtime function, with the actual call being built -- by Expand_Fpt_Attribute procedure Expand_Fpt_Attribute_R (N : Node_Id) is E1 : constant Node_Id := First (Expressions (N)); Ftp : Entity_Id; Pkg : RE_Id; begin Find_Fat_Info (Etype (E1), Ftp, Pkg); Expand_Fpt_Attribute (N, Pkg, Attribute_Name (N), New_List (Unchecked_Convert_To (Ftp, Relocate_Node (E1)))); end Expand_Fpt_Attribute_R; ----------------------------- -- Expand_Fpt_Attribute_RI -- ----------------------------- -- The first argument is converted to its root type and the second -- argument is converted to standard long long integer to call the -- appropriate runtime function, with the actual call being built -- by Expand_Fpt_Attribute procedure Expand_Fpt_Attribute_RI (N : Node_Id) is E1 : constant Node_Id := First (Expressions (N)); Ftp : Entity_Id; Pkg : RE_Id; E2 : constant Node_Id := Next (E1); begin Find_Fat_Info (Etype (E1), Ftp, Pkg); Expand_Fpt_Attribute (N, Pkg, Attribute_Name (N), New_List ( Unchecked_Convert_To (Ftp, Relocate_Node (E1)), Unchecked_Convert_To (Standard_Integer, Relocate_Node (E2)))); end Expand_Fpt_Attribute_RI; ----------------------------- -- Expand_Fpt_Attribute_RR -- ----------------------------- -- The two arguments are converted to their root types to call the -- appropriate runtime function, with the actual call being built -- by Expand_Fpt_Attribute procedure Expand_Fpt_Attribute_RR (N : Node_Id) is E1 : constant Node_Id := First (Expressions (N)); Ftp : Entity_Id; Pkg : RE_Id; E2 : constant Node_Id := Next (E1); begin Find_Fat_Info (Etype (E1), Ftp, Pkg); Expand_Fpt_Attribute (N, Pkg, Attribute_Name (N), New_List ( Unchecked_Convert_To (Ftp, Relocate_Node (E1)), Unchecked_Convert_To (Ftp, Relocate_Node (E2)))); end Expand_Fpt_Attribute_RR; ---------------------------------- -- Expand_N_Attribute_Reference -- ---------------------------------- procedure Expand_N_Attribute_Reference (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); Typ : constant Entity_Id := Etype (N); Btyp : constant Entity_Id := Base_Type (Typ); Pref : constant Node_Id := Prefix (N); Ptyp : constant Entity_Id := Etype (Pref); Exprs : constant List_Id := Expressions (N); Id : constant Attribute_Id := Get_Attribute_Id (Attribute_Name (N)); procedure Rewrite_Stream_Proc_Call (Pname : Entity_Id); -- Rewrites a stream attribute for Read, Write or Output with the -- procedure call. Pname is the entity for the procedure to call. ------------------------------ -- Rewrite_Stream_Proc_Call -- ------------------------------ procedure Rewrite_Stream_Proc_Call (Pname : Entity_Id) is Item : constant Node_Id := Next (First (Exprs)); Formal : constant Entity_Id := Next_Formal (First_Formal (Pname)); Formal_Typ : constant Entity_Id := Etype (Formal); Is_Written : constant Boolean := (Ekind (Formal) /= E_In_Parameter); begin -- The expansion depends on Item, the second actual, which is -- the object being streamed in or out. -- If the item is a component of a packed array type, and -- a conversion is needed on exit, we introduce a temporary to -- hold the value, because otherwise the packed reference will -- not be properly expanded. if Nkind (Item) = N_Indexed_Component and then Is_Packed (Base_Type (Etype (Prefix (Item)))) and then Base_Type (Etype (Item)) /= Base_Type (Formal_Typ) and then Is_Written then declare Temp : constant Entity_Id := Make_Temporary (Loc, 'V'); Decl : Node_Id; Assn : Node_Id; begin Decl := Make_Object_Declaration (Loc, Defining_Identifier => Temp, Object_Definition => New_Occurrence_Of (Formal_Typ, Loc)); Set_Etype (Temp, Formal_Typ); Assn := Make_Assignment_Statement (Loc, Name => New_Copy_Tree (Item), Expression => Unchecked_Convert_To (Etype (Item), New_Occurrence_Of (Temp, Loc))); Rewrite (Item, New_Occurrence_Of (Temp, Loc)); Insert_Actions (N, New_List ( Decl, Make_Procedure_Call_Statement (Loc, Name => New_Occurrence_Of (Pname, Loc), Parameter_Associations => Exprs), Assn)); Rewrite (N, Make_Null_Statement (Loc)); return; end; end if; -- For the class-wide dispatching cases, and for cases in which -- the base type of the second argument matches the base type of -- the corresponding formal parameter (that is to say the stream -- operation is not inherited), we are all set, and can use the -- argument unchanged. -- For all other cases we do an unchecked conversion of the second -- parameter to the type of the formal of the procedure we are -- calling. This deals with the private type cases, and with going -- to the root type as required in elementary type case. if not Is_Class_Wide_Type (Entity (Pref)) and then not Is_Class_Wide_Type (Etype (Item)) and then Base_Type (Etype (Item)) /= Base_Type (Formal_Typ) then Rewrite (Item, Unchecked_Convert_To (Formal_Typ, Relocate_Node (Item))); -- For untagged derived types set Assignment_OK, to prevent -- copies from being created when the unchecked conversion -- is expanded (which would happen in Remove_Side_Effects -- if Expand_N_Unchecked_Conversion were allowed to call -- Force_Evaluation). The copy could violate Ada semantics -- in cases such as an actual that is an out parameter. -- Note that this approach is also used in exp_ch7 for calls -- to controlled type operations to prevent problems with -- actuals wrapped in unchecked conversions. if Is_Untagged_Derivation (Etype (Expression (Item))) then Set_Assignment_OK (Item); end if; end if; -- The stream operation to call maybe a renaming created by -- an attribute definition clause, and may not be frozen yet. -- Ensure that it has the necessary extra formals. if not Is_Frozen (Pname) then Create_Extra_Formals (Pname); end if; -- And now rewrite the call Rewrite (N, Make_Procedure_Call_Statement (Loc, Name => New_Occurrence_Of (Pname, Loc), Parameter_Associations => Exprs)); Analyze (N); end Rewrite_Stream_Proc_Call; -- Start of processing for Expand_N_Attribute_Reference begin -- Do required validity checking, if enabled. Do not apply check to -- output parameters of an Asm instruction, since the value of this -- is not set till after the attribute has been elaborated, and do -- not apply the check to the arguments of a 'Read or 'Input attribute -- reference since the scalar argument is an OUT scalar. if Validity_Checks_On and then Validity_Check_Operands and then Id /= Attribute_Asm_Output and then Id /= Attribute_Read and then Id /= Attribute_Input then declare Expr : Node_Id; begin Expr := First (Expressions (N)); while Present (Expr) loop Ensure_Valid (Expr); Next (Expr); end loop; end; end if; -- Ada 2005 (AI-318-02): If attribute prefix is a call to a build-in- -- place function, then a temporary return object needs to be created -- and access to it must be passed to the function. Currently we limit -- such functions to those with inherently limited result subtypes, but -- eventually we plan to expand the functions that are treated as -- build-in-place to include other composite result types. if Ada_Version >= Ada_2005 and then Is_Build_In_Place_Function_Call (Pref) then Make_Build_In_Place_Call_In_Anonymous_Context (Pref); end if; -- If prefix is a protected type name, this is a reference to the -- current instance of the type. For a component definition, nothing -- to do (expansion will occur in the init proc). In other contexts, -- rewrite into reference to current instance. if Is_Protected_Self_Reference (Pref) and then not (Nkind_In (Parent (N), N_Index_Or_Discriminant_Constraint, N_Discriminant_Association) and then Nkind (Parent (Parent (Parent (Parent (N))))) = N_Component_Definition) then Rewrite (Pref, Concurrent_Ref (Pref)); Analyze (Pref); end if; -- Remaining processing depends on specific attribute case Id is -- Attributes related to Ada 2012 iterators (placeholder ???) when Attribute_Constant_Indexing => null; when Attribute_Default_Iterator => null; when Attribute_Implicit_Dereference => null; when Attribute_Iterator_Element => null; when Attribute_Variable_Indexing => null; ------------ -- Access -- ------------ when Attribute_Access | Attribute_Unchecked_Access | Attribute_Unrestricted_Access => Access_Cases : declare Ref_Object : constant Node_Id := Get_Referenced_Object (Pref); Btyp_DDT : Entity_Id; function Enclosing_Object (N : Node_Id) return Node_Id; -- If N denotes a compound name (selected component, indexed -- component, or slice), returns the name of the outermost such -- enclosing object. Otherwise returns N. If the object is a -- renaming, then the renamed object is returned. ---------------------- -- Enclosing_Object -- ---------------------- function Enclosing_Object (N : Node_Id) return Node_Id is Obj_Name : Node_Id; begin Obj_Name := N; while Nkind_In (Obj_Name, N_Selected_Component, N_Indexed_Component, N_Slice) loop Obj_Name := Prefix (Obj_Name); end loop; return Get_Referenced_Object (Obj_Name); end Enclosing_Object; -- Local declarations Enc_Object : constant Node_Id := Enclosing_Object (Ref_Object); -- Start of processing for Access_Cases begin Btyp_DDT := Designated_Type (Btyp); -- Handle designated types that come from the limited view if Ekind (Btyp_DDT) = E_Incomplete_Type and then From_With_Type (Btyp_DDT) and then Present (Non_Limited_View (Btyp_DDT)) then Btyp_DDT := Non_Limited_View (Btyp_DDT); elsif Is_Class_Wide_Type (Btyp_DDT) and then Ekind (Etype (Btyp_DDT)) = E_Incomplete_Type and then From_With_Type (Etype (Btyp_DDT)) and then Present (Non_Limited_View (Etype (Btyp_DDT))) and then Present (Class_Wide_Type (Non_Limited_View (Etype (Btyp_DDT)))) then Btyp_DDT := Class_Wide_Type (Non_Limited_View (Etype (Btyp_DDT))); end if; -- In order to improve the text of error messages, the designated -- type of access-to-subprogram itypes is set by the semantics as -- the associated subprogram entity (see sem_attr). Now we replace -- such node with the proper E_Subprogram_Type itype. if Id = Attribute_Unrestricted_Access and then Is_Subprogram (Directly_Designated_Type (Typ)) then -- The following conditions ensure that this special management -- is done only for "Address!(Prim'Unrestricted_Access)" nodes. -- At this stage other cases in which the designated type is -- still a subprogram (instead of an E_Subprogram_Type) are -- wrong because the semantics must have overridden the type of -- the node with the type imposed by the context. if Nkind (Parent (N)) = N_Unchecked_Type_Conversion and then Etype (Parent (N)) = RTE (RE_Prim_Ptr) then Set_Etype (N, RTE (RE_Prim_Ptr)); else declare Subp : constant Entity_Id := Directly_Designated_Type (Typ); Etyp : Entity_Id; Extra : Entity_Id := Empty; New_Formal : Entity_Id; Old_Formal : Entity_Id := First_Formal (Subp); Subp_Typ : Entity_Id; begin Subp_Typ := Create_Itype (E_Subprogram_Type, N); Set_Etype (Subp_Typ, Etype (Subp)); Set_Returns_By_Ref (Subp_Typ, Returns_By_Ref (Subp)); if Present (Old_Formal) then New_Formal := New_Copy (Old_Formal); Set_First_Entity (Subp_Typ, New_Formal); loop Set_Scope (New_Formal, Subp_Typ); Etyp := Etype (New_Formal); -- Handle itypes. There is no need to duplicate -- here the itypes associated with record types -- (i.e the implicit full view of private types). if Is_Itype (Etyp) and then Ekind (Base_Type (Etyp)) /= E_Record_Type then Extra := New_Copy (Etyp); Set_Parent (Extra, New_Formal); Set_Etype (New_Formal, Extra); Set_Scope (Extra, Subp_Typ); end if; Extra := New_Formal; Next_Formal (Old_Formal); exit when No (Old_Formal); Set_Next_Entity (New_Formal, New_Copy (Old_Formal)); Next_Entity (New_Formal); end loop; Set_Next_Entity (New_Formal, Empty); Set_Last_Entity (Subp_Typ, Extra); end if; -- Now that the explicit formals have been duplicated, -- any extra formals needed by the subprogram must be -- created. if Present (Extra) then Set_Extra_Formal (Extra, Empty); end if; Create_Extra_Formals (Subp_Typ); Set_Directly_Designated_Type (Typ, Subp_Typ); end; end if; end if; if Is_Access_Protected_Subprogram_Type (Btyp) then Expand_Access_To_Protected_Op (N, Pref, Typ); -- If prefix is a type name, this is a reference to the current -- instance of the type, within its initialization procedure. elsif Is_Entity_Name (Pref) and then Is_Type (Entity (Pref)) then declare Par : Node_Id; Formal : Entity_Id; begin -- If the current instance name denotes a task type, then -- the access attribute is rewritten to be the name of the -- "_task" parameter associated with the task type's task -- procedure. An unchecked conversion is applied to ensure -- a type match in cases of expander-generated calls (e.g. -- init procs). if Is_Task_Type (Entity (Pref)) then Formal := First_Entity (Get_Task_Body_Procedure (Entity (Pref))); while Present (Formal) loop exit when Chars (Formal) = Name_uTask; Next_Entity (Formal); end loop; pragma Assert (Present (Formal)); Rewrite (N, Unchecked_Convert_To (Typ, New_Occurrence_Of (Formal, Loc))); Set_Etype (N, Typ); -- The expression must appear in a default expression, -- (which in the initialization procedure is the -- right-hand side of an assignment), and not in a -- discriminant constraint. else Par := Parent (N); while Present (Par) loop exit when Nkind (Par) = N_Assignment_Statement; if Nkind (Par) = N_Component_Declaration then return; end if; Par := Parent (Par); end loop; if Present (Par) then Rewrite (N, Make_Attribute_Reference (Loc, Prefix => Make_Identifier (Loc, Name_uInit), Attribute_Name => Attribute_Name (N))); Analyze_And_Resolve (N, Typ); end if; end if; end; -- If the prefix of an Access attribute is a dereference of an -- access parameter (or a renaming of such a dereference, or a -- subcomponent of such a dereference) and the context is a -- general access type (including the type of an object or -- component with an access_definition, but not the anonymous -- type of an access parameter or access discriminant), then -- apply an accessibility check to the access parameter. We used -- to rewrite the access parameter as a type conversion, but that -- could only be done if the immediate prefix of the Access -- attribute was the dereference, and didn't handle cases where -- the attribute is applied to a subcomponent of the dereference, -- since there's generally no available, appropriate access type -- to convert to in that case. The attribute is passed as the -- point to insert the check, because the access parameter may -- come from a renaming, possibly in a different scope, and the -- check must be associated with the attribute itself. elsif Id = Attribute_Access and then Nkind (Enc_Object) = N_Explicit_Dereference and then Is_Entity_Name (Prefix (Enc_Object)) and then (Ekind (Btyp) = E_General_Access_Type or else Is_Local_Anonymous_Access (Btyp)) and then Ekind (Entity (Prefix (Enc_Object))) in Formal_Kind and then Ekind (Etype (Entity (Prefix (Enc_Object)))) = E_Anonymous_Access_Type and then Present (Extra_Accessibility (Entity (Prefix (Enc_Object)))) then Apply_Accessibility_Check (Prefix (Enc_Object), Typ, N); -- Ada 2005 (AI-251): If the designated type is an interface we -- add an implicit conversion to force the displacement of the -- pointer to reference the secondary dispatch table. elsif Is_Interface (Btyp_DDT) and then (Comes_From_Source (N) or else Comes_From_Source (Ref_Object) or else (Nkind (Ref_Object) in N_Has_Chars and then Chars (Ref_Object) = Name_uInit)) then if Nkind (Ref_Object) /= N_Explicit_Dereference then -- No implicit conversion required if types match, or if -- the prefix is the class_wide_type of the interface. In -- either case passing an object of the interface type has -- already set the pointer correctly. if Btyp_DDT = Etype (Ref_Object) or else (Is_Class_Wide_Type (Etype (Ref_Object)) and then Class_Wide_Type (Btyp_DDT) = Etype (Ref_Object)) then null; else Rewrite (Prefix (N), Convert_To (Btyp_DDT, New_Copy_Tree (Prefix (N)))); Analyze_And_Resolve (Prefix (N), Btyp_DDT); end if; -- When the object is an explicit dereference, convert the -- dereference's prefix. else declare Obj_DDT : constant Entity_Id := Base_Type (Directly_Designated_Type (Etype (Prefix (Ref_Object)))); begin -- No implicit conversion required if designated types -- match, or if we have an unrestricted access. if Obj_DDT /= Btyp_DDT and then Id /= Attribute_Unrestricted_Access and then not (Is_Class_Wide_Type (Obj_DDT) and then Etype (Obj_DDT) = Btyp_DDT) then Rewrite (N, Convert_To (Typ, New_Copy_Tree (Prefix (Ref_Object)))); Analyze_And_Resolve (N, Typ); end if; end; end if; end if; end Access_Cases; -------------- -- Adjacent -- -------------- -- Transforms 'Adjacent into a call to the floating-point attribute -- function Adjacent in Fat_xxx (where xxx is the root type) when Attribute_Adjacent => Expand_Fpt_Attribute_RR (N); ------------- -- Address -- ------------- when Attribute_Address => Address : declare Task_Proc : Entity_Id; begin -- If the prefix is a task or a task type, the useful address is that -- of the procedure for the task body, i.e. the actual program unit. -- We replace the original entity with that of the procedure. if Is_Entity_Name (Pref) and then Is_Task_Type (Entity (Pref)) then Task_Proc := Next_Entity (Root_Type (Ptyp)); while Present (Task_Proc) loop exit when Ekind (Task_Proc) = E_Procedure and then Etype (First_Formal (Task_Proc)) = Corresponding_Record_Type (Ptyp); Next_Entity (Task_Proc); end loop; if Present (Task_Proc) then Set_Entity (Pref, Task_Proc); Set_Etype (Pref, Etype (Task_Proc)); end if; -- Similarly, the address of a protected operation is the address -- of the corresponding protected body, regardless of the protected -- object from which it is selected. elsif Nkind (Pref) = N_Selected_Component and then Is_Subprogram (Entity (Selector_Name (Pref))) and then Is_Protected_Type (Scope (Entity (Selector_Name (Pref)))) then Rewrite (Pref, New_Occurrence_Of ( External_Subprogram (Entity (Selector_Name (Pref))), Loc)); elsif Nkind (Pref) = N_Explicit_Dereference and then Ekind (Ptyp) = E_Subprogram_Type and then Convention (Ptyp) = Convention_Protected then -- The prefix is be a dereference of an access_to_protected_ -- subprogram. The desired address is the second component of -- the record that represents the access. declare Addr : constant Entity_Id := Etype (N); Ptr : constant Node_Id := Prefix (Pref); T : constant Entity_Id := Equivalent_Type (Base_Type (Etype (Ptr))); begin Rewrite (N, Unchecked_Convert_To (Addr, Make_Selected_Component (Loc, Prefix => Unchecked_Convert_To (T, Ptr), Selector_Name => New_Occurrence_Of ( Next_Entity (First_Entity (T)), Loc)))); Analyze_And_Resolve (N, Addr); end; -- Ada 2005 (AI-251): Class-wide interface objects are always -- "displaced" to reference the tag associated with the interface -- type. In order to obtain the real address of such objects we -- generate a call to a run-time subprogram that returns the base -- address of the object. -- This processing is not needed in the VM case, where dispatching -- issues are taken care of by the virtual machine. elsif Is_Class_Wide_Type (Ptyp) and then Is_Interface (Ptyp) and then Tagged_Type_Expansion and then not (Nkind (Pref) in N_Has_Entity and then Is_Subprogram (Entity (Pref))) then Rewrite (N, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Base_Address), Loc), Parameter_Associations => New_List ( Relocate_Node (N)))); Analyze (N); return; end if; -- Deal with packed array reference, other cases are handled by -- the back end. if Involves_Packed_Array_Reference (Pref) then Expand_Packed_Address_Reference (N); end if; end Address; --------------- -- Alignment -- --------------- when Attribute_Alignment => Alignment : declare New_Node : Node_Id; begin -- For class-wide types, X'Class'Alignment is transformed into a -- direct reference to the Alignment of the class type, so that the -- back end does not have to deal with the X'Class'Alignment -- reference. if Is_Entity_Name (Pref) and then Is_Class_Wide_Type (Entity (Pref)) then Rewrite (Prefix (N), New_Occurrence_Of (Entity (Pref), Loc)); return; -- For x'Alignment applied to an object of a class wide type, -- transform X'Alignment into a call to the predefined primitive -- operation _Alignment applied to X. elsif Is_Class_Wide_Type (Ptyp) then New_Node := Make_Attribute_Reference (Loc, Prefix => Pref, Attribute_Name => Name_Tag); if VM_Target = No_VM then New_Node := Build_Get_Alignment (Loc, New_Node); else New_Node := Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Get_Alignment), Loc), Parameter_Associations => New_List (New_Node)); end if; -- Case where the context is a specific integer type with which -- the original attribute was compatible. The function has a -- specific type as well, so to preserve the compatibility we -- must convert explicitly. if Typ /= Standard_Integer then New_Node := Convert_To (Typ, New_Node); end if; Rewrite (N, New_Node); Analyze_And_Resolve (N, Typ); return; -- For all other cases, we just have to deal with the case of -- the fact that the result can be universal. else Apply_Universal_Integer_Attribute_Checks (N); end if; end Alignment; --------------- -- AST_Entry -- --------------- when Attribute_AST_Entry => AST_Entry : declare Ttyp : Entity_Id; T_Id : Node_Id; Eent : Entity_Id; Entry_Ref : Node_Id; -- The reference to the entry or entry family Index : Node_Id; -- The index expression for an entry family reference, or -- the Empty if Entry_Ref references a simple entry. begin if Nkind (Pref) = N_Indexed_Component then Entry_Ref := Prefix (Pref); Index := First (Expressions (Pref)); else Entry_Ref := Pref; Index := Empty; end if; -- Get expression for Task_Id and the entry entity if Nkind (Entry_Ref) = N_Selected_Component then T_Id := Make_Attribute_Reference (Loc, Attribute_Name => Name_Identity, Prefix => Prefix (Entry_Ref)); Ttyp := Etype (Prefix (Entry_Ref)); Eent := Entity (Selector_Name (Entry_Ref)); else T_Id := Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Current_Task), Loc)); Eent := Entity (Entry_Ref); -- We have to find the enclosing task to get the task type -- There must be one, since we already validated this earlier Ttyp := Current_Scope; while not Is_Task_Type (Ttyp) loop Ttyp := Scope (Ttyp); end loop; end if; -- Now rewrite the attribute with a call to Create_AST_Handler Rewrite (N, Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Create_AST_Handler), Loc), Parameter_Associations => New_List ( T_Id, Entry_Index_Expression (Loc, Eent, Index, Ttyp)))); Analyze_And_Resolve (N, RTE (RE_AST_Handler)); end AST_Entry; --------- -- Bit -- --------- -- We compute this if a packed array reference was present, otherwise we -- leave the computation up to the back end. when Attribute_Bit => if Involves_Packed_Array_Reference (Pref) then Expand_Packed_Bit_Reference (N); else Apply_Universal_Integer_Attribute_Checks (N); end if; ------------------ -- Bit_Position -- ------------------ -- We compute this if a component clause was present, otherwise we leave -- the computation up to the back end, since we don't know what layout -- will be chosen. -- Note that the attribute can apply to a naked record component -- in generated code (i.e. the prefix is an identifier that -- references the component or discriminant entity). when Attribute_Bit_Position => Bit_Position : declare CE : Entity_Id; begin if Nkind (Pref) = N_Identifier then CE := Entity (Pref); else CE := Entity (Selector_Name (Pref)); end if; if Known_Static_Component_Bit_Offset (CE) then Rewrite (N, Make_Integer_Literal (Loc, Intval => Component_Bit_Offset (CE))); Analyze_And_Resolve (N, Typ); else Apply_Universal_Integer_Attribute_Checks (N); end if; end Bit_Position; ------------------ -- Body_Version -- ------------------ -- A reference to P'Body_Version or P'Version is expanded to -- Vnn : Unsigned; -- pragma Import (C, Vnn, "uuuuT"); -- ... -- Get_Version_String (Vnn) -- where uuuu is the unit name (dots replaced by double underscore) -- and T is B for the cases of Body_Version, or Version applied to a -- subprogram acting as its own spec, and S for Version applied to a -- subprogram spec or package. This sequence of code references the -- unsigned constant created in the main program by the binder. -- A special exception occurs for Standard, where the string returned -- is a copy of the library string in gnatvsn.ads. when Attribute_Body_Version | Attribute_Version => Version : declare E : constant Entity_Id := Make_Temporary (Loc, 'V'); Pent : Entity_Id; S : String_Id; begin -- If not library unit, get to containing library unit Pent := Entity (Pref); while Pent /= Standard_Standard and then Scope (Pent) /= Standard_Standard and then not Is_Child_Unit (Pent) loop Pent := Scope (Pent); end loop; -- Special case Standard and Standard.ASCII if Pent = Standard_Standard or else Pent = Standard_ASCII then Rewrite (N, Make_String_Literal (Loc, Strval => Verbose_Library_Version)); -- All other cases else -- Build required string constant Get_Name_String (Get_Unit_Name (Pent)); Start_String; for J in 1 .. Name_Len - 2 loop if Name_Buffer (J) = '.' then Store_String_Chars ("__"); else Store_String_Char (Get_Char_Code (Name_Buffer (J))); end if; end loop; -- Case of subprogram acting as its own spec, always use body if Nkind (Declaration_Node (Pent)) in N_Subprogram_Specification and then Nkind (Parent (Declaration_Node (Pent))) = N_Subprogram_Body and then Acts_As_Spec (Parent (Declaration_Node (Pent))) then Store_String_Chars ("B"); -- Case of no body present, always use spec elsif not Unit_Requires_Body (Pent) then Store_String_Chars ("S"); -- Otherwise use B for Body_Version, S for spec elsif Id = Attribute_Body_Version then Store_String_Chars ("B"); else Store_String_Chars ("S"); end if; S := End_String; Lib.Version_Referenced (S); -- Insert the object declaration Insert_Actions (N, New_List ( Make_Object_Declaration (Loc, Defining_Identifier => E, Object_Definition => New_Occurrence_Of (RTE (RE_Unsigned), Loc)))); -- Set entity as imported with correct external name Set_Is_Imported (E); Set_Interface_Name (E, Make_String_Literal (Loc, S)); -- Set entity as internal to ensure proper Sprint output of its -- implicit importation. Set_Is_Internal (E); -- And now rewrite original reference Rewrite (N, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Get_Version_String), Loc), Parameter_Associations => New_List ( New_Occurrence_Of (E, Loc)))); end if; Analyze_And_Resolve (N, RTE (RE_Version_String)); end Version; ------------- -- Ceiling -- ------------- -- Transforms 'Ceiling into a call to the floating-point attribute -- function Ceiling in Fat_xxx (where xxx is the root type) when Attribute_Ceiling => Expand_Fpt_Attribute_R (N); -------------- -- Callable -- -------------- -- Transforms 'Callable attribute into a call to the Callable function when Attribute_Callable => Callable : begin -- We have an object of a task interface class-wide type as a prefix -- to Callable. Generate: -- callable (Task_Id (Pref._disp_get_task_id)); if Ada_Version >= Ada_2005 and then Ekind (Ptyp) = E_Class_Wide_Type and then Is_Interface (Ptyp) and then Is_Task_Interface (Ptyp) then Rewrite (N, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Callable), Loc), Parameter_Associations => New_List ( Make_Unchecked_Type_Conversion (Loc, Subtype_Mark => New_Reference_To (RTE (RO_ST_Task_Id), Loc), Expression => Make_Selected_Component (Loc, Prefix => New_Copy_Tree (Pref), Selector_Name => Make_Identifier (Loc, Name_uDisp_Get_Task_Id)))))); else Rewrite (N, Build_Call_With_Task (Pref, RTE (RE_Callable))); end if; Analyze_And_Resolve (N, Standard_Boolean); end Callable; ------------ -- Caller -- ------------ -- Transforms 'Caller attribute into a call to either the -- Task_Entry_Caller or the Protected_Entry_Caller function. when Attribute_Caller => Caller : declare Id_Kind : constant Entity_Id := RTE (RO_AT_Task_Id); Ent : constant Entity_Id := Entity (Pref); Conctype : constant Entity_Id := Scope (Ent); Nest_Depth : Integer := 0; Name : Node_Id; S : Entity_Id; begin -- Protected case if Is_Protected_Type (Conctype) then case Corresponding_Runtime_Package (Conctype) is when System_Tasking_Protected_Objects_Entries => Name := New_Reference_To (RTE (RE_Protected_Entry_Caller), Loc); when System_Tasking_Protected_Objects_Single_Entry => Name := New_Reference_To (RTE (RE_Protected_Single_Entry_Caller), Loc); when others => raise Program_Error; end case; Rewrite (N, Unchecked_Convert_To (Id_Kind, Make_Function_Call (Loc, Name => Name, Parameter_Associations => New_List ( New_Reference_To (Find_Protection_Object (Current_Scope), Loc))))); -- Task case else -- Determine the nesting depth of the E'Caller attribute, that -- is, how many accept statements are nested within the accept -- statement for E at the point of E'Caller. The runtime uses -- this depth to find the specified entry call. for J in reverse 0 .. Scope_Stack.Last loop S := Scope_Stack.Table (J).Entity; -- We should not reach the scope of the entry, as it should -- already have been checked in Sem_Attr that this attribute -- reference is within a matching accept statement. pragma Assert (S /= Conctype); if S = Ent then exit; elsif Is_Entry (S) then Nest_Depth := Nest_Depth + 1; end if; end loop; Rewrite (N, Unchecked_Convert_To (Id_Kind, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Task_Entry_Caller), Loc), Parameter_Associations => New_List ( Make_Integer_Literal (Loc, Intval => Int (Nest_Depth)))))); end if; Analyze_And_Resolve (N, Id_Kind); end Caller; ------------- -- Compose -- ------------- -- Transforms 'Compose into a call to the floating-point attribute -- function Compose in Fat_xxx (where xxx is the root type) -- Note: we strictly should have special code here to deal with the -- case of absurdly negative arguments (less than Integer'First) -- which will return a (signed) zero value, but it hardly seems -- worth the effort. Absurdly large positive arguments will raise -- constraint error which is fine. when Attribute_Compose => Expand_Fpt_Attribute_RI (N); ----------------- -- Constrained -- ----------------- when Attribute_Constrained => Constrained : declare Formal_Ent : constant Entity_Id := Param_Entity (Pref); function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean; -- Ada 2005 (AI-363): Returns True if the object name Obj denotes a -- view of an aliased object whose subtype is constrained. --------------------------------- -- Is_Constrained_Aliased_View -- --------------------------------- function Is_Constrained_Aliased_View (Obj : Node_Id) return Boolean is E : Entity_Id; begin if Is_Entity_Name (Obj) then E := Entity (Obj); if Present (Renamed_Object (E)) then return Is_Constrained_Aliased_View (Renamed_Object (E)); else return Is_Aliased (E) and then Is_Constrained (Etype (E)); end if; else return Is_Aliased_View (Obj) and then (Is_Constrained (Etype (Obj)) or else (Nkind (Obj) = N_Explicit_Dereference and then not Effectively_Has_Constrained_Partial_View (Typ => Base_Type (Etype (Obj)), Scop => Current_Scope))); end if; end Is_Constrained_Aliased_View; -- Start of processing for Constrained begin -- Reference to a parameter where the value is passed as an extra -- actual, corresponding to the extra formal referenced by the -- Extra_Constrained field of the corresponding formal. If this -- is an entry in-parameter, it is replaced by a constant renaming -- for which Extra_Constrained is never created. if Present (Formal_Ent) and then Ekind (Formal_Ent) /= E_Constant and then Present (Extra_Constrained (Formal_Ent)) then Rewrite (N, New_Occurrence_Of (Extra_Constrained (Formal_Ent), Sloc (N))); -- For variables with a Extra_Constrained field, we use the -- corresponding entity. elsif Nkind (Pref) = N_Identifier and then Ekind (Entity (Pref)) = E_Variable and then Present (Extra_Constrained (Entity (Pref))) then Rewrite (N, New_Occurrence_Of (Extra_Constrained (Entity (Pref)), Sloc (N))); -- For all other entity names, we can tell at compile time elsif Is_Entity_Name (Pref) then declare Ent : constant Entity_Id := Entity (Pref); Res : Boolean; begin -- (RM J.4) obsolescent cases if Is_Type (Ent) then -- Private type if Is_Private_Type (Ent) then Res := not Has_Discriminants (Ent) or else Is_Constrained (Ent); -- It not a private type, must be a generic actual type -- that corresponded to a private type. We know that this -- correspondence holds, since otherwise the reference -- within the generic template would have been illegal. else if Is_Composite_Type (Underlying_Type (Ent)) then Res := Is_Constrained (Ent); else Res := True; end if; end if; -- If the prefix is not a variable or is aliased, then -- definitely true; if it's a formal parameter without an -- associated extra formal, then treat it as constrained. -- Ada 2005 (AI-363): An aliased prefix must be known to be -- constrained in order to set the attribute to True. elsif not Is_Variable (Pref) or else Present (Formal_Ent) or else (Ada_Version < Ada_2005 and then Is_Aliased_View (Pref)) or else (Ada_Version >= Ada_2005 and then Is_Constrained_Aliased_View (Pref)) then Res := True; -- Variable case, look at type to see if it is constrained. -- Note that the one case where this is not accurate (the -- procedure formal case), has been handled above. -- We use the Underlying_Type here (and below) in case the -- type is private without discriminants, but the full type -- has discriminants. This case is illegal, but we generate it -- internally for passing to the Extra_Constrained parameter. else -- In Ada 2012, test for case of a limited tagged type, in -- which case the attribute is always required to return -- True. The underlying type is tested, to make sure we also -- return True for cases where there is an unconstrained -- object with an untagged limited partial view which has -- defaulted discriminants (such objects always produce a -- False in earlier versions of Ada). (Ada 2012: AI05-0214) Res := Is_Constrained (Underlying_Type (Etype (Ent))) or else (Ada_Version >= Ada_2012 and then Is_Tagged_Type (Underlying_Type (Ptyp)) and then Is_Limited_Type (Ptyp)); end if; Rewrite (N, New_Reference_To (Boolean_Literals (Res), Loc)); end; -- Prefix is not an entity name. These are also cases where we can -- always tell at compile time by looking at the form and type of the -- prefix. If an explicit dereference of an object with constrained -- partial view, this is unconstrained (Ada 2005: AI95-0363). If the -- underlying type is a limited tagged type, then Constrained is -- required to always return True (Ada 2012: AI05-0214). else Rewrite (N, New_Reference_To ( Boolean_Literals ( not Is_Variable (Pref) or else (Nkind (Pref) = N_Explicit_Dereference and then not Effectively_Has_Constrained_Partial_View (Typ => Base_Type (Ptyp), Scop => Current_Scope)) or else Is_Constrained (Underlying_Type (Ptyp)) or else (Ada_Version >= Ada_2012 and then Is_Tagged_Type (Underlying_Type (Ptyp)) and then Is_Limited_Type (Ptyp))), Loc)); end if; Analyze_And_Resolve (N, Standard_Boolean); end Constrained; --------------- -- Copy_Sign -- --------------- -- Transforms 'Copy_Sign into a call to the floating-point attribute -- function Copy_Sign in Fat_xxx (where xxx is the root type) when Attribute_Copy_Sign => Expand_Fpt_Attribute_RR (N); ----------- -- Count -- ----------- -- Transforms 'Count attribute into a call to the Count function when Attribute_Count => Count : declare Call : Node_Id; Conctyp : Entity_Id; Entnam : Node_Id; Entry_Id : Entity_Id; Index : Node_Id; Name : Node_Id; begin -- If the prefix is a member of an entry family, retrieve both -- entry name and index. For a simple entry there is no index. if Nkind (Pref) = N_Indexed_Component then Entnam := Prefix (Pref); Index := First (Expressions (Pref)); else Entnam := Pref; Index := Empty; end if; Entry_Id := Entity (Entnam); -- Find the concurrent type in which this attribute is referenced -- (there had better be one). Conctyp := Current_Scope; while not Is_Concurrent_Type (Conctyp) loop Conctyp := Scope (Conctyp); end loop; -- Protected case if Is_Protected_Type (Conctyp) then case Corresponding_Runtime_Package (Conctyp) is when System_Tasking_Protected_Objects_Entries => Name := New_Reference_To (RTE (RE_Protected_Count), Loc); Call := Make_Function_Call (Loc, Name => Name, Parameter_Associations => New_List ( New_Reference_To (Find_Protection_Object (Current_Scope), Loc), Entry_Index_Expression (Loc, Entry_Id, Index, Scope (Entry_Id)))); when System_Tasking_Protected_Objects_Single_Entry => Name := New_Reference_To (RTE (RE_Protected_Count_Entry), Loc); Call := Make_Function_Call (Loc, Name => Name, Parameter_Associations => New_List ( New_Reference_To (Find_Protection_Object (Current_Scope), Loc))); when others => raise Program_Error; end case; -- Task case else Call := Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Task_Count), Loc), Parameter_Associations => New_List ( Entry_Index_Expression (Loc, Entry_Id, Index, Scope (Entry_Id)))); end if; -- The call returns type Natural but the context is universal integer -- so any integer type is allowed. The attribute was already resolved -- so its Etype is the required result type. If the base type of the -- context type is other than Standard.Integer we put in a conversion -- to the required type. This can be a normal typed conversion since -- both input and output types of the conversion are integer types if Base_Type (Typ) /= Base_Type (Standard_Integer) then Rewrite (N, Convert_To (Typ, Call)); else Rewrite (N, Call); end if; Analyze_And_Resolve (N, Typ); end Count; --------------------- -- Descriptor_Size -- --------------------- when Attribute_Descriptor_Size => -- Attribute Descriptor_Size is handled by the back end when applied -- to an unconstrained array type. if Is_Array_Type (Ptyp) and then not Is_Constrained (Ptyp) then Apply_Universal_Integer_Attribute_Checks (N); -- For any other type, the descriptor size is 0 because there is no -- actual descriptor, but the result is not formally static. else Rewrite (N, Make_Integer_Literal (Loc, 0)); Analyze (N); Set_Is_Static_Expression (N, False); end if; --------------- -- Elab_Body -- --------------- -- This processing is shared by Elab_Spec -- What we do is to insert the following declarations -- procedure tnn; -- pragma Import (C, enn, "name___elabb/s"); -- and then the Elab_Body/Spec attribute is replaced by a reference -- to this defining identifier. when Attribute_Elab_Body | Attribute_Elab_Spec => -- Leave attribute unexpanded in CodePeer mode: the gnat2scil -- back-end knows how to handle these attributes directly. if CodePeer_Mode then return; end if; Elab_Body : declare Ent : constant Entity_Id := Make_Temporary (Loc, 'E'); Str : String_Id; Lang : Node_Id; procedure Make_Elab_String (Nod : Node_Id); -- Given Nod, an identifier, or a selected component, put the -- image into the current string literal, with double underline -- between components. ---------------------- -- Make_Elab_String -- ---------------------- procedure Make_Elab_String (Nod : Node_Id) is begin if Nkind (Nod) = N_Selected_Component then Make_Elab_String (Prefix (Nod)); case VM_Target is when JVM_Target => Store_String_Char ('$'); when CLI_Target => Store_String_Char ('.'); when No_VM => Store_String_Char ('_'); Store_String_Char ('_'); end case; Get_Name_String (Chars (Selector_Name (Nod))); else pragma Assert (Nkind (Nod) = N_Identifier); Get_Name_String (Chars (Nod)); end if; Store_String_Chars (Name_Buffer (1 .. Name_Len)); end Make_Elab_String; -- Start of processing for Elab_Body/Elab_Spec begin -- First we need to prepare the string literal for the name of -- the elaboration routine to be referenced. Start_String; Make_Elab_String (Pref); if VM_Target = No_VM then Store_String_Chars ("___elab"); Lang := Make_Identifier (Loc, Name_C); else Store_String_Chars ("._elab"); Lang := Make_Identifier (Loc, Name_Ada); end if; if Id = Attribute_Elab_Body then Store_String_Char ('b'); else Store_String_Char ('s'); end if; Str := End_String; Insert_Actions (N, New_List ( Make_Subprogram_Declaration (Loc, Specification => Make_Procedure_Specification (Loc, Defining_Unit_Name => Ent)), Make_Pragma (Loc, Chars => Name_Import, Pragma_Argument_Associations => New_List ( Make_Pragma_Argument_Association (Loc, Expression => Lang), Make_Pragma_Argument_Association (Loc, Expression => Make_Identifier (Loc, Chars (Ent))), Make_Pragma_Argument_Association (Loc, Expression => Make_String_Literal (Loc, Str)))))); Set_Entity (N, Ent); Rewrite (N, New_Occurrence_Of (Ent, Loc)); end Elab_Body; -------------------- -- Elab_Subp_Body -- -------------------- -- Always ignored. In CodePeer mode, gnat2scil knows how to handle -- this attribute directly, and if we are not in CodePeer mode it is -- entirely ignored ??? when Attribute_Elab_Subp_Body => return; ---------------- -- Elaborated -- ---------------- -- Elaborated is always True for preelaborated units, predefined units, -- pure units and units which have Elaborate_Body pragmas. These units -- have no elaboration entity. -- Note: The Elaborated attribute is never passed to the back end when Attribute_Elaborated => Elaborated : declare Ent : constant Entity_Id := Entity (Pref); begin if Present (Elaboration_Entity (Ent)) then Rewrite (N, Make_Op_Ne (Loc, Left_Opnd => New_Occurrence_Of (Elaboration_Entity (Ent), Loc), Right_Opnd => Make_Integer_Literal (Loc, Uint_0))); Analyze_And_Resolve (N, Typ); else Rewrite (N, New_Occurrence_Of (Standard_True, Loc)); end if; end Elaborated; -------------- -- Enum_Rep -- -------------- when Attribute_Enum_Rep => Enum_Rep : begin -- X'Enum_Rep (Y) expands to -- target-type (Y) -- This is simply a direct conversion from the enumeration type to -- the target integer type, which is treated by the back end as a -- normal integer conversion, treating the enumeration type as an -- integer, which is exactly what we want! We set Conversion_OK to -- make sure that the analyzer does not complain about what otherwise -- might be an illegal conversion. if Is_Non_Empty_List (Exprs) then Rewrite (N, OK_Convert_To (Typ, Relocate_Node (First (Exprs)))); -- X'Enum_Rep where X is an enumeration literal is replaced by -- the literal value. elsif Ekind (Entity (Pref)) = E_Enumeration_Literal then Rewrite (N, Make_Integer_Literal (Loc, Enumeration_Rep (Entity (Pref)))); -- If this is a renaming of a literal, recover the representation -- of the original. elsif Ekind (Entity (Pref)) = E_Constant and then Present (Renamed_Object (Entity (Pref))) and then Ekind (Entity (Renamed_Object (Entity (Pref)))) = E_Enumeration_Literal then Rewrite (N, Make_Integer_Literal (Loc, Enumeration_Rep (Entity (Renamed_Object (Entity (Pref)))))); -- X'Enum_Rep where X is an object does a direct unchecked conversion -- of the object value, as described for the type case above. else Rewrite (N, OK_Convert_To (Typ, Relocate_Node (Pref))); end if; Set_Etype (N, Typ); Analyze_And_Resolve (N, Typ); end Enum_Rep; -------------- -- Enum_Val -- -------------- when Attribute_Enum_Val => Enum_Val : declare Expr : Node_Id; Btyp : constant Entity_Id := Base_Type (Ptyp); begin -- X'Enum_Val (Y) expands to -- [constraint_error when _rep_to_pos (Y, False) = -1, msg] -- X!(Y); Expr := Unchecked_Convert_To (Ptyp, First (Exprs)); Insert_Action (N, Make_Raise_Constraint_Error (Loc, Condition => Make_Op_Eq (Loc, Left_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Btyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => New_List ( Relocate_Node (Duplicate_Subexpr (Expr)), New_Occurrence_Of (Standard_False, Loc))), Right_Opnd => Make_Integer_Literal (Loc, -1)), Reason => CE_Range_Check_Failed)); Rewrite (N, Expr); Analyze_And_Resolve (N, Ptyp); end Enum_Val; -------------- -- Exponent -- -------------- -- Transforms 'Exponent into a call to the floating-point attribute -- function Exponent in Fat_xxx (where xxx is the root type) when Attribute_Exponent => Expand_Fpt_Attribute_R (N); ------------------ -- External_Tag -- ------------------ -- transforme X'External_Tag into Ada.Tags.External_Tag (X'tag) when Attribute_External_Tag => External_Tag : begin Rewrite (N, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_External_Tag), Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Attribute_Name => Name_Tag, Prefix => Prefix (N))))); Analyze_And_Resolve (N, Standard_String); end External_Tag; ----------- -- First -- ----------- when Attribute_First => -- If the prefix type is a constrained packed array type which -- already has a Packed_Array_Type representation defined, then -- replace this attribute with a direct reference to 'First of the -- appropriate index subtype (since otherwise the back end will try -- to give us the value of 'First for this implementation type). if Is_Constrained_Packed_Array (Ptyp) then Rewrite (N, Make_Attribute_Reference (Loc, Attribute_Name => Name_First, Prefix => New_Reference_To (Get_Index_Subtype (N), Loc))); Analyze_And_Resolve (N, Typ); elsif Is_Access_Type (Ptyp) then Apply_Access_Check (N); end if; --------------- -- First_Bit -- --------------- -- Compute this if component clause was present, otherwise we leave the -- computation to be completed in the back-end, since we don't know what -- layout will be chosen. when Attribute_First_Bit => First_Bit_Attr : declare CE : constant Entity_Id := Entity (Selector_Name (Pref)); begin -- In Ada 2005 (or later) if we have the standard nondefault -- bit order, then we return the original value as given in -- the component clause (RM 2005 13.5.2(3/2)). if Present (Component_Clause (CE)) and then Ada_Version >= Ada_2005 and then not Reverse_Bit_Order (Scope (CE)) then Rewrite (N, Make_Integer_Literal (Loc, Intval => Expr_Value (First_Bit (Component_Clause (CE))))); Analyze_And_Resolve (N, Typ); -- Otherwise (Ada 83/95 or Ada 2005 or later with reverse bit order), -- rewrite with normalized value if we know it statically. elsif Known_Static_Component_Bit_Offset (CE) then Rewrite (N, Make_Integer_Literal (Loc, Component_Bit_Offset (CE) mod System_Storage_Unit)); Analyze_And_Resolve (N, Typ); -- Otherwise left to back end, just do universal integer checks else Apply_Universal_Integer_Attribute_Checks (N); end if; end First_Bit_Attr; ----------------- -- Fixed_Value -- ----------------- -- We transform: -- fixtype'Fixed_Value (integer-value) -- into -- fixtype(integer-value) -- We do all the required analysis of the conversion here, because we do -- not want this to go through the fixed-point conversion circuits. Note -- that the back end always treats fixed-point as equivalent to the -- corresponding integer type anyway. when Attribute_Fixed_Value => Fixed_Value : begin Rewrite (N, Make_Type_Conversion (Loc, Subtype_Mark => New_Occurrence_Of (Entity (Pref), Loc), Expression => Relocate_Node (First (Exprs)))); Set_Etype (N, Entity (Pref)); Set_Analyzed (N); -- Note: it might appear that a properly analyzed unchecked conversion -- would be just fine here, but that's not the case, since the full -- range checks performed by the following call are critical! Apply_Type_Conversion_Checks (N); end Fixed_Value; ----------- -- Floor -- ----------- -- Transforms 'Floor into a call to the floating-point attribute -- function Floor in Fat_xxx (where xxx is the root type) when Attribute_Floor => Expand_Fpt_Attribute_R (N); ---------- -- Fore -- ---------- -- For the fixed-point type Typ: -- Typ'Fore -- expands into -- Result_Type (System.Fore (Universal_Real (Type'First)), -- Universal_Real (Type'Last)) -- Note that we know that the type is a non-static subtype, or Fore -- would have itself been computed dynamically in Eval_Attribute. when Attribute_Fore => Fore : begin Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Fore), Loc), Parameter_Associations => New_List ( Convert_To (Universal_Real, Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Ptyp, Loc), Attribute_Name => Name_First)), Convert_To (Universal_Real, Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Ptyp, Loc), Attribute_Name => Name_Last)))))); Analyze_And_Resolve (N, Typ); end Fore; -------------- -- Fraction -- -------------- -- Transforms 'Fraction into a call to the floating-point attribute -- function Fraction in Fat_xxx (where xxx is the root type) when Attribute_Fraction => Expand_Fpt_Attribute_R (N); -------------- -- From_Any -- -------------- when Attribute_From_Any => From_Any : declare P_Type : constant Entity_Id := Etype (Pref); Decls : constant List_Id := New_List; begin Rewrite (N, Build_From_Any_Call (P_Type, Relocate_Node (First (Exprs)), Decls)); Insert_Actions (N, Decls); Analyze_And_Resolve (N, P_Type); end From_Any; -------------- -- Identity -- -------------- -- For an exception returns a reference to the exception data: -- Exception_Id!(Prefix'Reference) -- For a task it returns a reference to the _task_id component of -- corresponding record: -- taskV!(Prefix)._Task_Id, converted to the type Task_Id defined -- in Ada.Task_Identification when Attribute_Identity => Identity : declare Id_Kind : Entity_Id; begin if Ptyp = Standard_Exception_Type then Id_Kind := RTE (RE_Exception_Id); if Present (Renamed_Object (Entity (Pref))) then Set_Entity (Pref, Renamed_Object (Entity (Pref))); end if; Rewrite (N, Unchecked_Convert_To (Id_Kind, Make_Reference (Loc, Pref))); else Id_Kind := RTE (RO_AT_Task_Id); -- If the prefix is a task interface, the Task_Id is obtained -- dynamically through a dispatching call, as for other task -- attributes applied to interfaces. if Ada_Version >= Ada_2005 and then Ekind (Ptyp) = E_Class_Wide_Type and then Is_Interface (Ptyp) and then Is_Task_Interface (Ptyp) then Rewrite (N, Unchecked_Convert_To (Id_Kind, Make_Selected_Component (Loc, Prefix => New_Copy_Tree (Pref), Selector_Name => Make_Identifier (Loc, Name_uDisp_Get_Task_Id)))); else Rewrite (N, Unchecked_Convert_To (Id_Kind, Concurrent_Ref (Pref))); end if; end if; Analyze_And_Resolve (N, Id_Kind); end Identity; ----------- -- Image -- ----------- -- Image attribute is handled in separate unit Exp_Imgv when Attribute_Image => Exp_Imgv.Expand_Image_Attribute (N); --------- -- Img -- --------- -- X'Img is expanded to typ'Image (X), where typ is the type of X when Attribute_Img => Img : begin Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Ptyp, Loc), Attribute_Name => Name_Image, Expressions => New_List (Relocate_Node (Pref)))); Analyze_And_Resolve (N, Standard_String); end Img; ----------- -- Input -- ----------- when Attribute_Input => Input : declare P_Type : constant Entity_Id := Entity (Pref); B_Type : constant Entity_Id := Base_Type (P_Type); U_Type : constant Entity_Id := Underlying_Type (P_Type); Strm : constant Node_Id := First (Exprs); Fname : Entity_Id; Decl : Node_Id; Call : Node_Id; Prag : Node_Id; Arg2 : Node_Id; Rfunc : Node_Id; Cntrl : Node_Id := Empty; -- Value for controlling argument in call. Always Empty except in -- the dispatching (class-wide type) case, where it is a reference -- to the dummy object initialized to the right internal tag. procedure Freeze_Stream_Subprogram (F : Entity_Id); -- The expansion of the attribute reference may generate a call to -- a user-defined stream subprogram that is frozen by the call. This -- can lead to access-before-elaboration problem if the reference -- appears in an object declaration and the subprogram body has not -- been seen. The freezing of the subprogram requires special code -- because it appears in an expanded context where expressions do -- not freeze their constituents. ------------------------------ -- Freeze_Stream_Subprogram -- ------------------------------ procedure Freeze_Stream_Subprogram (F : Entity_Id) is Decl : constant Node_Id := Unit_Declaration_Node (F); Bod : Node_Id; begin -- If this is user-defined subprogram, the corresponding -- stream function appears as a renaming-as-body, and the -- user subprogram must be retrieved by tree traversal. if Present (Decl) and then Nkind (Decl) = N_Subprogram_Declaration and then Present (Corresponding_Body (Decl)) then Bod := Corresponding_Body (Decl); if Nkind (Unit_Declaration_Node (Bod)) = N_Subprogram_Renaming_Declaration then Set_Is_Frozen (Entity (Name (Unit_Declaration_Node (Bod)))); end if; end if; end Freeze_Stream_Subprogram; -- Start of processing for Input begin -- If no underlying type, we have an error that will be diagnosed -- elsewhere, so here we just completely ignore the expansion. if No (U_Type) then return; end if; -- If there is a TSS for Input, just call it Fname := Find_Stream_Subprogram (P_Type, TSS_Stream_Input); if Present (Fname) then null; else -- If there is a Stream_Convert pragma, use it, we rewrite -- sourcetyp'Input (stream) -- as -- sourcetyp (streamread (strmtyp'Input (stream))); -- where streamread is the given Read function that converts an -- argument of type strmtyp to type sourcetyp or a type from which -- it is derived (extra conversion required for the derived case). Prag := Get_Stream_Convert_Pragma (P_Type); if Present (Prag) then Arg2 := Next (First (Pragma_Argument_Associations (Prag))); Rfunc := Entity (Expression (Arg2)); Rewrite (N, Convert_To (B_Type, Make_Function_Call (Loc, Name => New_Occurrence_Of (Rfunc, Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (First_Formal (Rfunc)), Loc), Attribute_Name => Name_Input, Expressions => Exprs))))); Analyze_And_Resolve (N, B_Type); return; -- Elementary types elsif Is_Elementary_Type (U_Type) then -- A special case arises if we have a defined _Read routine, -- since in this case we are required to call this routine. if Present (TSS (Base_Type (U_Type), TSS_Stream_Read)) then Build_Record_Or_Elementary_Input_Function (Loc, U_Type, Decl, Fname); Insert_Action (N, Decl); -- For normal cases, we call the I_xxx routine directly else Rewrite (N, Build_Elementary_Input_Call (N)); Analyze_And_Resolve (N, P_Type); return; end if; -- Array type case elsif Is_Array_Type (U_Type) then Build_Array_Input_Function (Loc, U_Type, Decl, Fname); Compile_Stream_Body_In_Scope (N, Decl, U_Type, Check => False); -- Dispatching case with class-wide type elsif Is_Class_Wide_Type (P_Type) then -- No need to do anything else compiling under restriction -- No_Dispatching_Calls. During the semantic analysis we -- already notified such violation. if Restriction_Active (No_Dispatching_Calls) then return; end if; declare Rtyp : constant Entity_Id := Root_Type (P_Type); Dnn : Entity_Id; Decl : Node_Id; Expr : Node_Id; begin -- Read the internal tag (RM 13.13.2(34)) and use it to -- initialize a dummy tag object: -- Dnn : Ada.Tags.Tag := -- Descendant_Tag (String'Input (Strm), P_Type); -- This dummy object is used only to provide a controlling -- argument for the eventual _Input call. Descendant_Tag is -- called rather than Internal_Tag to ensure that we have a -- tag for a type that is descended from the prefix type and -- declared at the same accessibility level (the exception -- Tag_Error will be raised otherwise). The level check is -- required for Ada 2005 because tagged types can be -- extended in nested scopes (AI-344). Expr := Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Descendant_Tag), Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Standard_String, Loc), Attribute_Name => Name_Input, Expressions => New_List ( Relocate_Node (Duplicate_Subexpr (Strm)))), Make_Attribute_Reference (Loc, Prefix => New_Reference_To (P_Type, Loc), Attribute_Name => Name_Tag))); Dnn := Make_Temporary (Loc, 'D', Expr); Decl := Make_Object_Declaration (Loc, Defining_Identifier => Dnn, Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc), Expression => Expr); Insert_Action (N, Decl); -- Now we need to get the entity for the call, and construct -- a function call node, where we preset a reference to Dnn -- as the controlling argument (doing an unchecked convert -- to the class-wide tagged type to make it look like a real -- tagged object). Fname := Find_Prim_Op (Rtyp, TSS_Stream_Input); Cntrl := Unchecked_Convert_To (P_Type, New_Occurrence_Of (Dnn, Loc)); Set_Etype (Cntrl, P_Type); Set_Parent (Cntrl, N); end; -- For tagged types, use the primitive Input function elsif Is_Tagged_Type (U_Type) then Fname := Find_Prim_Op (U_Type, TSS_Stream_Input); -- All other record type cases, including protected records. The -- latter only arise for expander generated code for handling -- shared passive partition access. else pragma Assert (Is_Record_Type (U_Type) or else Is_Protected_Type (U_Type)); -- Ada 2005 (AI-216): Program_Error is raised executing default -- implementation of the Input attribute of an unchecked union -- type if the type lacks default discriminant values. if Is_Unchecked_Union (Base_Type (U_Type)) and then No (Discriminant_Constraint (U_Type)) then Insert_Action (N, Make_Raise_Program_Error (Loc, Reason => PE_Unchecked_Union_Restriction)); return; end if; -- Build the type's Input function, passing the subtype rather -- than its base type, because checks are needed in the case of -- constrained discriminants (see Ada 2012 AI05-0192). Build_Record_Or_Elementary_Input_Function (Loc, U_Type, Decl, Fname); Insert_Action (N, Decl); if Nkind (Parent (N)) = N_Object_Declaration and then Is_Record_Type (U_Type) then -- The stream function may contain calls to user-defined -- Read procedures for individual components. declare Comp : Entity_Id; Func : Entity_Id; begin Comp := First_Component (U_Type); while Present (Comp) loop Func := Find_Stream_Subprogram (Etype (Comp), TSS_Stream_Read); if Present (Func) then Freeze_Stream_Subprogram (Func); end if; Next_Component (Comp); end loop; end; end if; end if; end if; -- If we fall through, Fname is the function to be called. The result -- is obtained by calling the appropriate function, then converting -- the result. The conversion does a subtype check. Call := Make_Function_Call (Loc, Name => New_Occurrence_Of (Fname, Loc), Parameter_Associations => New_List ( Relocate_Node (Strm))); Set_Controlling_Argument (Call, Cntrl); Rewrite (N, Unchecked_Convert_To (P_Type, Call)); Analyze_And_Resolve (N, P_Type); if Nkind (Parent (N)) = N_Object_Declaration then Freeze_Stream_Subprogram (Fname); end if; end Input; ------------------- -- Integer_Value -- ------------------- -- We transform -- inttype'Fixed_Value (fixed-value) -- into -- inttype(integer-value)) -- we do all the required analysis of the conversion here, because we do -- not want this to go through the fixed-point conversion circuits. Note -- that the back end always treats fixed-point as equivalent to the -- corresponding integer type anyway. when Attribute_Integer_Value => Integer_Value : begin Rewrite (N, Make_Type_Conversion (Loc, Subtype_Mark => New_Occurrence_Of (Entity (Pref), Loc), Expression => Relocate_Node (First (Exprs)))); Set_Etype (N, Entity (Pref)); Set_Analyzed (N); -- Note: it might appear that a properly analyzed unchecked conversion -- would be just fine here, but that's not the case, since the full -- range checks performed by the following call are critical! Apply_Type_Conversion_Checks (N); end Integer_Value; ------------------- -- Invalid_Value -- ------------------- when Attribute_Invalid_Value => Rewrite (N, Get_Simple_Init_Val (Ptyp, N)); ---------- -- Last -- ---------- when Attribute_Last => -- If the prefix type is a constrained packed array type which -- already has a Packed_Array_Type representation defined, then -- replace this attribute with a direct reference to 'Last of the -- appropriate index subtype (since otherwise the back end will try -- to give us the value of 'Last for this implementation type). if Is_Constrained_Packed_Array (Ptyp) then Rewrite (N, Make_Attribute_Reference (Loc, Attribute_Name => Name_Last, Prefix => New_Reference_To (Get_Index_Subtype (N), Loc))); Analyze_And_Resolve (N, Typ); elsif Is_Access_Type (Ptyp) then Apply_Access_Check (N); end if; -------------- -- Last_Bit -- -------------- -- We compute this if a component clause was present, otherwise we leave -- the computation up to the back end, since we don't know what layout -- will be chosen. when Attribute_Last_Bit => Last_Bit_Attr : declare CE : constant Entity_Id := Entity (Selector_Name (Pref)); begin -- In Ada 2005 (or later) if we have the standard nondefault -- bit order, then we return the original value as given in -- the component clause (RM 2005 13.5.2(4/2)). if Present (Component_Clause (CE)) and then Ada_Version >= Ada_2005 and then not Reverse_Bit_Order (Scope (CE)) then Rewrite (N, Make_Integer_Literal (Loc, Intval => Expr_Value (Last_Bit (Component_Clause (CE))))); Analyze_And_Resolve (N, Typ); -- Otherwise (Ada 83/95 or Ada 2005 or later with reverse bit order), -- rewrite with normalized value if we know it statically. elsif Known_Static_Component_Bit_Offset (CE) and then Known_Static_Esize (CE) then Rewrite (N, Make_Integer_Literal (Loc, Intval => (Component_Bit_Offset (CE) mod System_Storage_Unit) + Esize (CE) - 1)); Analyze_And_Resolve (N, Typ); -- Otherwise leave to back end, just apply universal integer checks else Apply_Universal_Integer_Attribute_Checks (N); end if; end Last_Bit_Attr; ------------------ -- Leading_Part -- ------------------ -- Transforms 'Leading_Part into a call to the floating-point attribute -- function Leading_Part in Fat_xxx (where xxx is the root type) -- Note: strictly, we should generate special case code to deal with -- absurdly large positive arguments (greater than Integer'Last), which -- result in returning the first argument unchanged, but it hardly seems -- worth the effort. We raise constraint error for absurdly negative -- arguments which is fine. when Attribute_Leading_Part => Expand_Fpt_Attribute_RI (N); ------------ -- Length -- ------------ when Attribute_Length => declare Ityp : Entity_Id; Xnum : Uint; begin -- Processing for packed array types if Is_Array_Type (Ptyp) and then Is_Packed (Ptyp) then Ityp := Get_Index_Subtype (N); -- If the index type, Ityp, is an enumeration type with holes, -- then we calculate X'Length explicitly using -- Typ'Max -- (0, Ityp'Pos (X'Last (N)) - -- Ityp'Pos (X'First (N)) + 1); -- Since the bounds in the template are the representation values -- and the back end would get the wrong value. if Is_Enumeration_Type (Ityp) and then Present (Enum_Pos_To_Rep (Base_Type (Ityp))) then if No (Exprs) then Xnum := Uint_1; else Xnum := Expr_Value (First (Expressions (N))); end if; Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Typ, Loc), Attribute_Name => Name_Max, Expressions => New_List (Make_Integer_Literal (Loc, 0), Make_Op_Add (Loc, Left_Opnd => Make_Op_Subtract (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ityp, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => Duplicate_Subexpr (Pref), Attribute_Name => Name_Last, Expressions => New_List ( Make_Integer_Literal (Loc, Xnum))))), Right_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ityp, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => Duplicate_Subexpr_No_Checks (Pref), Attribute_Name => Name_First, Expressions => New_List ( Make_Integer_Literal (Loc, Xnum)))))), Right_Opnd => Make_Integer_Literal (Loc, 1))))); Analyze_And_Resolve (N, Typ, Suppress => All_Checks); return; -- If the prefix type is a constrained packed array type which -- already has a Packed_Array_Type representation defined, then -- replace this attribute with a direct reference to 'Range_Length -- of the appropriate index subtype (since otherwise the back end -- will try to give us the value of 'Length for this -- implementation type). elsif Is_Constrained (Ptyp) then Rewrite (N, Make_Attribute_Reference (Loc, Attribute_Name => Name_Range_Length, Prefix => New_Reference_To (Ityp, Loc))); Analyze_And_Resolve (N, Typ); end if; -- Access type case elsif Is_Access_Type (Ptyp) then Apply_Access_Check (N); -- If the designated type is a packed array type, then we convert -- the reference to: -- typ'Max (0, 1 + -- xtyp'Pos (Pref'Last (Expr)) - -- xtyp'Pos (Pref'First (Expr))); -- This is a bit complex, but it is the easiest thing to do that -- works in all cases including enum types with holes xtyp here -- is the appropriate index type. declare Dtyp : constant Entity_Id := Designated_Type (Ptyp); Xtyp : Entity_Id; begin if Is_Array_Type (Dtyp) and then Is_Packed (Dtyp) then Xtyp := Get_Index_Subtype (N); Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Typ, Loc), Attribute_Name => Name_Max, Expressions => New_List ( Make_Integer_Literal (Loc, 0), Make_Op_Add (Loc, Make_Integer_Literal (Loc, 1), Make_Op_Subtract (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Xtyp, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => Duplicate_Subexpr (Pref), Attribute_Name => Name_Last, Expressions => New_Copy_List (Exprs)))), Right_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Xtyp, Loc), Attribute_Name => Name_Pos, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => Duplicate_Subexpr_No_Checks (Pref), Attribute_Name => Name_First, Expressions => New_Copy_List (Exprs))))))))); Analyze_And_Resolve (N, Typ); end if; end; -- Otherwise leave it to the back end else Apply_Universal_Integer_Attribute_Checks (N); end if; end; ------------- -- Machine -- ------------- -- Transforms 'Machine into a call to the floating-point attribute -- function Machine in Fat_xxx (where xxx is the root type) when Attribute_Machine => Expand_Fpt_Attribute_R (N); ---------------------- -- Machine_Rounding -- ---------------------- -- Transforms 'Machine_Rounding into a call to the floating-point -- attribute function Machine_Rounding in Fat_xxx (where xxx is the root -- type). Expansion is avoided for cases the back end can handle -- directly. when Attribute_Machine_Rounding => if not Is_Inline_Floating_Point_Attribute (N) then Expand_Fpt_Attribute_R (N); end if; ------------------ -- Machine_Size -- ------------------ -- Machine_Size is equivalent to Object_Size, so transform it into -- Object_Size and that way the back end never sees Machine_Size. when Attribute_Machine_Size => Rewrite (N, Make_Attribute_Reference (Loc, Prefix => Prefix (N), Attribute_Name => Name_Object_Size)); Analyze_And_Resolve (N, Typ); -------------- -- Mantissa -- -------------- -- The only case that can get this far is the dynamic case of the old -- Ada 83 Mantissa attribute for the fixed-point case. For this case, -- we expand: -- typ'Mantissa -- into -- ityp (System.Mantissa.Mantissa_Value -- (Integer'Integer_Value (typ'First), -- Integer'Integer_Value (typ'Last))); when Attribute_Mantissa => Mantissa : begin Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Mantissa_Value), Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Standard_Integer, Loc), Attribute_Name => Name_Integer_Value, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ptyp, Loc), Attribute_Name => Name_First))), Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Standard_Integer, Loc), Attribute_Name => Name_Integer_Value, Expressions => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ptyp, Loc), Attribute_Name => Name_Last))))))); Analyze_And_Resolve (N, Typ); end Mantissa; ---------------------------------- -- Max_Size_In_Storage_Elements -- ---------------------------------- when Attribute_Max_Size_In_Storage_Elements => Apply_Universal_Integer_Attribute_Checks (N); -- Heap-allocated controlled objects contain two extra pointers which -- are not part of the actual type. Transform the attribute reference -- into a runtime expression to add the size of the hidden header. -- Do not perform this expansion on .NET/JVM targets because the -- two pointers are already present in the type. if VM_Target = No_VM and then Nkind (N) = N_Attribute_Reference and then Needs_Finalization (Ptyp) and then not Header_Size_Added (N) then Set_Header_Size_Added (N); -- Generate: -- P'Max_Size_In_Storage_Elements + -- Universal_Integer -- (Header_Size_With_Padding (Ptyp'Alignment)) Rewrite (N, Make_Op_Add (Loc, Left_Opnd => Relocate_Node (N), Right_Opnd => Convert_To (Universal_Integer, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Header_Size_With_Padding), Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Ptyp, Loc), Attribute_Name => Name_Alignment)))))); Analyze (N); return; end if; -------------------- -- Mechanism_Code -- -------------------- when Attribute_Mechanism_Code => -- We must replace the prefix in the renamed case if Is_Entity_Name (Pref) and then Present (Alias (Entity (Pref))) then Set_Renamed_Subprogram (Pref, Alias (Entity (Pref))); end if; --------- -- Mod -- --------- when Attribute_Mod => Mod_Case : declare Arg : constant Node_Id := Relocate_Node (First (Exprs)); Hi : constant Node_Id := Type_High_Bound (Etype (Arg)); Modv : constant Uint := Modulus (Btyp); begin -- This is not so simple. The issue is what type to use for the -- computation of the modular value. -- The easy case is when the modulus value is within the bounds -- of the signed integer type of the argument. In this case we can -- just do the computation in that signed integer type, and then -- do an ordinary conversion to the target type. if Modv <= Expr_Value (Hi) then Rewrite (N, Convert_To (Btyp, Make_Op_Mod (Loc, Left_Opnd => Arg, Right_Opnd => Make_Integer_Literal (Loc, Modv)))); -- Here we know that the modulus is larger than type'Last of the -- integer type. There are two cases to consider: -- a) The integer value is non-negative. In this case, it is -- returned as the result (since it is less than the modulus). -- b) The integer value is negative. In this case, we know that the -- result is modulus + value, where the value might be as small as -- -modulus. The trouble is what type do we use to do the subtract. -- No type will do, since modulus can be as big as 2**64, and no -- integer type accommodates this value. Let's do bit of algebra -- modulus + value -- = modulus - (-value) -- = (modulus - 1) - (-value - 1) -- Now modulus - 1 is certainly in range of the modular type. -- -value is in the range 1 .. modulus, so -value -1 is in the -- range 0 .. modulus-1 which is in range of the modular type. -- Furthermore, (-value - 1) can be expressed as -(value + 1) -- which we can compute using the integer base type. -- Once this is done we analyze the conditional expression without -- range checks, because we know everything is in range, and we -- want to prevent spurious warnings on either branch. else Rewrite (N, Make_Conditional_Expression (Loc, Expressions => New_List ( Make_Op_Ge (Loc, Left_Opnd => Duplicate_Subexpr (Arg), Right_Opnd => Make_Integer_Literal (Loc, 0)), Convert_To (Btyp, Duplicate_Subexpr_No_Checks (Arg)), Make_Op_Subtract (Loc, Left_Opnd => Make_Integer_Literal (Loc, Intval => Modv - 1), Right_Opnd => Convert_To (Btyp, Make_Op_Minus (Loc, Right_Opnd => Make_Op_Add (Loc, Left_Opnd => Duplicate_Subexpr_No_Checks (Arg), Right_Opnd => Make_Integer_Literal (Loc, Intval => 1)))))))); end if; Analyze_And_Resolve (N, Btyp, Suppress => All_Checks); end Mod_Case; ----------- -- Model -- ----------- -- Transforms 'Model into a call to the floating-point attribute -- function Model in Fat_xxx (where xxx is the root type) when Attribute_Model => Expand_Fpt_Attribute_R (N); ----------------- -- Object_Size -- ----------------- -- The processing for Object_Size shares the processing for Size --------- -- Old -- --------- when Attribute_Old => Old : declare Tnn : constant Entity_Id := Make_Temporary (Loc, 'T', Pref); Subp : Node_Id; Asn_Stm : Node_Id; begin -- Find the nearest subprogram body, ignoring _Preconditions Subp := N; loop Subp := Parent (Subp); exit when Nkind (Subp) = N_Subprogram_Body and then Chars (Defining_Entity (Subp)) /= Name_uPostconditions; end loop; -- Insert the initialized object declaration at the start of the -- subprogram's declarations. Asn_Stm := Make_Object_Declaration (Loc, Defining_Identifier => Tnn, Constant_Present => True, Object_Definition => New_Occurrence_Of (Etype (N), Loc), Expression => Pref); -- Push the subprogram's scope, so that the object will be analyzed -- in that context (rather than the context of the Precondition -- subprogram) and will have its Scope set properly. if Present (Corresponding_Spec (Subp)) then Push_Scope (Corresponding_Spec (Subp)); else Push_Scope (Defining_Entity (Subp)); end if; if Is_Empty_List (Declarations (Subp)) then Set_Declarations (Subp, New_List (Asn_Stm)); Analyze (Asn_Stm); else Insert_Action (First (Declarations (Subp)), Asn_Stm); end if; Pop_Scope; Rewrite (N, New_Occurrence_Of (Tnn, Loc)); end Old; ---------------------- -- Overlaps_Storage -- ---------------------- when Attribute_Overlaps_Storage => Overlaps_Storage : declare Loc : constant Source_Ptr := Sloc (N); X : constant Node_Id := Prefix (N); Y : constant Node_Id := First (Expressions (N)); -- The argumens X_Addr, Y_Addr : Node_Id; -- the expressions for their integer addresses X_Size, Y_Size : Node_Id; -- the expressions for their sizes Cond : Node_Id; begin -- Attribute expands into: -- if X'Address < Y'address then -- (X'address + X'Size - 1) >= Y'address -- else -- (Y'address + Y'size - 1) >= X'Address -- end if; -- with the proper address operations. We convert addresses to -- integer addresses to use predefined arithmetic. The size is -- expressed in storage units. X_Addr := Unchecked_Convert_To (RTE (RE_Integer_Address), Make_Attribute_Reference (Loc, Attribute_Name => Name_Address, Prefix => New_Copy_Tree (X))); Y_Addr := Unchecked_Convert_To (RTE (RE_Integer_Address), Make_Attribute_Reference (Loc, Attribute_Name => Name_Address, Prefix => New_Copy_Tree (Y))); X_Size := Make_Op_Divide (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Attribute_Name => Name_Size, Prefix => New_Copy_Tree (X)), Right_Opnd => Make_Integer_Literal (Loc, System_Storage_Unit)); Y_Size := Make_Op_Divide (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Attribute_Name => Name_Size, Prefix => New_Copy_Tree (Y)), Right_Opnd => Make_Integer_Literal (Loc, System_Storage_Unit)); Cond := Make_Op_Le (Loc, Left_Opnd => X_Addr, Right_Opnd => Y_Addr); Rewrite (N, Make_Conditional_Expression (Loc, New_List ( Cond, Make_Op_Ge (Loc, Left_Opnd => Make_Op_Add (Loc, Left_Opnd => X_Addr, Right_Opnd => Make_Op_Subtract (Loc, Left_Opnd => X_Size, Right_Opnd => Make_Integer_Literal (Loc, 1))), Right_Opnd => Y_Addr), Make_Op_Ge (Loc, Make_Op_Add (Loc, Left_Opnd => Y_Addr, Right_Opnd => Make_Op_Subtract (Loc, Left_Opnd => Y_Size, Right_Opnd => Make_Integer_Literal (Loc, 1))), Right_Opnd => X_Addr)))); Analyze_And_Resolve (N, Standard_Boolean); end Overlaps_Storage; ------------ -- Output -- ------------ when Attribute_Output => Output : declare P_Type : constant Entity_Id := Entity (Pref); U_Type : constant Entity_Id := Underlying_Type (P_Type); Pname : Entity_Id; Decl : Node_Id; Prag : Node_Id; Arg3 : Node_Id; Wfunc : Node_Id; begin -- If no underlying type, we have an error that will be diagnosed -- elsewhere, so here we just completely ignore the expansion. if No (U_Type) then return; end if; -- If TSS for Output is present, just call it Pname := Find_Stream_Subprogram (P_Type, TSS_Stream_Output); if Present (Pname) then null; else -- If there is a Stream_Convert pragma, use it, we rewrite -- sourcetyp'Output (stream, Item) -- as -- strmtyp'Output (Stream, strmwrite (acttyp (Item))); -- where strmwrite is the given Write function that converts an -- argument of type sourcetyp or a type acctyp, from which it is -- derived to type strmtyp. The conversion to acttyp is required -- for the derived case. Prag := Get_Stream_Convert_Pragma (P_Type); if Present (Prag) then Arg3 := Next (Next (First (Pragma_Argument_Associations (Prag)))); Wfunc := Entity (Expression (Arg3)); Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (Wfunc), Loc), Attribute_Name => Name_Output, Expressions => New_List ( Relocate_Node (First (Exprs)), Make_Function_Call (Loc, Name => New_Occurrence_Of (Wfunc, Loc), Parameter_Associations => New_List ( OK_Convert_To (Etype (First_Formal (Wfunc)), Relocate_Node (Next (First (Exprs))))))))); Analyze (N); return; -- For elementary types, we call the W_xxx routine directly. -- Note that the effect of Write and Output is identical for -- the case of an elementary type, since there are no -- discriminants or bounds. elsif Is_Elementary_Type (U_Type) then -- A special case arises if we have a defined _Write routine, -- since in this case we are required to call this routine. if Present (TSS (Base_Type (U_Type), TSS_Stream_Write)) then Build_Record_Or_Elementary_Output_Procedure (Loc, U_Type, Decl, Pname); Insert_Action (N, Decl); -- For normal cases, we call the W_xxx routine directly else Rewrite (N, Build_Elementary_Write_Call (N)); Analyze (N); return; end if; -- Array type case elsif Is_Array_Type (U_Type) then Build_Array_Output_Procedure (Loc, U_Type, Decl, Pname); Compile_Stream_Body_In_Scope (N, Decl, U_Type, Check => False); -- Class-wide case, first output external tag, then dispatch -- to the appropriate primitive Output function (RM 13.13.2(31)). elsif Is_Class_Wide_Type (P_Type) then -- No need to do anything else compiling under restriction -- No_Dispatching_Calls. During the semantic analysis we -- already notified such violation. if Restriction_Active (No_Dispatching_Calls) then return; end if; Tag_Write : declare Strm : constant Node_Id := First (Exprs); Item : constant Node_Id := Next (Strm); begin -- Ada 2005 (AI-344): Check that the accessibility level -- of the type of the output object is not deeper than -- that of the attribute's prefix type. -- if Get_Access_Level (Item'Tag) -- /= Get_Access_Level (P_Type'Tag) -- then -- raise Tag_Error; -- end if; -- String'Output (Strm, External_Tag (Item'Tag)); -- We cannot figure out a practical way to implement this -- accessibility check on virtual machines, so we omit it. if Ada_Version >= Ada_2005 and then Tagged_Type_Expansion then Insert_Action (N, Make_Implicit_If_Statement (N, Condition => Make_Op_Ne (Loc, Left_Opnd => Build_Get_Access_Level (Loc, Make_Attribute_Reference (Loc, Prefix => Relocate_Node ( Duplicate_Subexpr (Item, Name_Req => True)), Attribute_Name => Name_Tag)), Right_Opnd => Make_Integer_Literal (Loc, Type_Access_Level (P_Type))), Then_Statements => New_List (Make_Raise_Statement (Loc, New_Occurrence_Of ( RTE (RE_Tag_Error), Loc))))); end if; Insert_Action (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Standard_String, Loc), Attribute_Name => Name_Output, Expressions => New_List ( Relocate_Node (Duplicate_Subexpr (Strm)), Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_External_Tag), Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => Relocate_Node (Duplicate_Subexpr (Item, Name_Req => True)), Attribute_Name => Name_Tag)))))); end Tag_Write; Pname := Find_Prim_Op (U_Type, TSS_Stream_Output); -- Tagged type case, use the primitive Output function elsif Is_Tagged_Type (U_Type) then Pname := Find_Prim_Op (U_Type, TSS_Stream_Output); -- All other record type cases, including protected records. -- The latter only arise for expander generated code for -- handling shared passive partition access. else pragma Assert (Is_Record_Type (U_Type) or else Is_Protected_Type (U_Type)); -- Ada 2005 (AI-216): Program_Error is raised when executing -- the default implementation of the Output attribute of an -- unchecked union type if the type lacks default discriminant -- values. if Is_Unchecked_Union (Base_Type (U_Type)) and then No (Discriminant_Constraint (U_Type)) then Insert_Action (N, Make_Raise_Program_Error (Loc, Reason => PE_Unchecked_Union_Restriction)); return; end if; Build_Record_Or_Elementary_Output_Procedure (Loc, Base_Type (U_Type), Decl, Pname); Insert_Action (N, Decl); end if; end if; -- If we fall through, Pname is the name of the procedure to call Rewrite_Stream_Proc_Call (Pname); end Output; --------- -- Pos -- --------- -- For enumeration types with a standard representation, Pos is -- handled by the back end. -- For enumeration types, with a non-standard representation we generate -- a call to the _Rep_To_Pos function created when the type was frozen. -- The call has the form -- _rep_to_pos (expr, flag) -- The parameter flag is True if range checks are enabled, causing -- Program_Error to be raised if the expression has an invalid -- representation, and False if range checks are suppressed. -- For integer types, Pos is equivalent to a simple integer -- conversion and we rewrite it as such when Attribute_Pos => Pos : declare Etyp : Entity_Id := Base_Type (Entity (Pref)); begin -- Deal with zero/non-zero boolean values if Is_Boolean_Type (Etyp) then Adjust_Condition (First (Exprs)); Etyp := Standard_Boolean; Set_Prefix (N, New_Occurrence_Of (Standard_Boolean, Loc)); end if; -- Case of enumeration type if Is_Enumeration_Type (Etyp) then -- Non-standard enumeration type (generate call) if Present (Enum_Pos_To_Rep (Etyp)) then Append_To (Exprs, Rep_To_Pos_Flag (Etyp, Loc)); Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => Exprs))); Analyze_And_Resolve (N, Typ); -- Standard enumeration type (do universal integer check) else Apply_Universal_Integer_Attribute_Checks (N); end if; -- Deal with integer types (replace by conversion) elsif Is_Integer_Type (Etyp) then Rewrite (N, Convert_To (Typ, First (Exprs))); Analyze_And_Resolve (N, Typ); end if; end Pos; -------------- -- Position -- -------------- -- We compute this if a component clause was present, otherwise we leave -- the computation up to the back end, since we don't know what layout -- will be chosen. when Attribute_Position => Position_Attr : declare CE : constant Entity_Id := Entity (Selector_Name (Pref)); begin if Present (Component_Clause (CE)) then -- In Ada 2005 (or later) if we have the standard nondefault -- bit order, then we return the original value as given in -- the component clause (RM 2005 13.5.2(2/2)). if Ada_Version >= Ada_2005 and then not Reverse_Bit_Order (Scope (CE)) then Rewrite (N, Make_Integer_Literal (Loc, Intval => Expr_Value (Position (Component_Clause (CE))))); -- Otherwise (Ada 83 or 95, or reverse bit order specified in -- later Ada version), return the normalized value. else Rewrite (N, Make_Integer_Literal (Loc, Intval => Component_Bit_Offset (CE) / System_Storage_Unit)); end if; Analyze_And_Resolve (N, Typ); -- If back end is doing things, just apply universal integer checks else Apply_Universal_Integer_Attribute_Checks (N); end if; end Position_Attr; ---------- -- Pred -- ---------- -- 1. Deal with enumeration types with holes -- 2. For floating-point, generate call to attribute function -- 3. For other cases, deal with constraint checking when Attribute_Pred => Pred : declare Etyp : constant Entity_Id := Base_Type (Ptyp); begin -- For enumeration types with non-standard representations, we -- expand typ'Pred (x) into -- Pos_To_Rep (Rep_To_Pos (x) - 1) -- If the representation is contiguous, we compute instead -- Lit1 + Rep_to_Pos (x -1), to catch invalid representations. -- The conversion function Enum_Pos_To_Rep is defined on the -- base type, not the subtype, so we have to use the base type -- explicitly for this and other enumeration attributes. if Is_Enumeration_Type (Ptyp) and then Present (Enum_Pos_To_Rep (Etyp)) then if Has_Contiguous_Rep (Etyp) then Rewrite (N, Unchecked_Convert_To (Ptyp, Make_Op_Add (Loc, Left_Opnd => Make_Integer_Literal (Loc, Enumeration_Rep (First_Literal (Ptyp))), Right_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => New_List ( Unchecked_Convert_To (Ptyp, Make_Op_Subtract (Loc, Left_Opnd => Unchecked_Convert_To (Standard_Integer, Relocate_Node (First (Exprs))), Right_Opnd => Make_Integer_Literal (Loc, 1))), Rep_To_Pos_Flag (Ptyp, Loc)))))); else -- Add Boolean parameter True, to request program errror if -- we have a bad representation on our hands. If checks are -- suppressed, then add False instead Append_To (Exprs, Rep_To_Pos_Flag (Ptyp, Loc)); Rewrite (N, Make_Indexed_Component (Loc, Prefix => New_Reference_To (Enum_Pos_To_Rep (Etyp), Loc), Expressions => New_List ( Make_Op_Subtract (Loc, Left_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => Exprs), Right_Opnd => Make_Integer_Literal (Loc, 1))))); end if; Analyze_And_Resolve (N, Typ); -- For floating-point, we transform 'Pred into a call to the Pred -- floating-point attribute function in Fat_xxx (xxx is root type) elsif Is_Floating_Point_Type (Ptyp) then Expand_Fpt_Attribute_R (N); Analyze_And_Resolve (N, Typ); -- For modular types, nothing to do (no overflow, since wraps) elsif Is_Modular_Integer_Type (Ptyp) then null; -- For other types, if argument is marked as needing a range check or -- overflow checking is enabled, we must generate a check. elsif not Overflow_Checks_Suppressed (Ptyp) or else Do_Range_Check (First (Exprs)) then Set_Do_Range_Check (First (Exprs), False); Expand_Pred_Succ (N); end if; end Pred; -------------- -- Priority -- -------------- -- Ada 2005 (AI-327): Dynamic ceiling priorities -- We rewrite X'Priority as the following run-time call: -- Get_Ceiling (X._Object) -- Note that although X'Priority is notionally an object, it is quite -- deliberately not defined as an aliased object in the RM. This means -- that it works fine to rewrite it as a call, without having to worry -- about complications that would other arise from X'Priority'Access, -- which is illegal, because of the lack of aliasing. when Attribute_Priority => declare Call : Node_Id; Conctyp : Entity_Id; Object_Parm : Node_Id; Subprg : Entity_Id; RT_Subprg_Name : Node_Id; begin -- Look for the enclosing concurrent type Conctyp := Current_Scope; while not Is_Concurrent_Type (Conctyp) loop Conctyp := Scope (Conctyp); end loop; pragma Assert (Is_Protected_Type (Conctyp)); -- Generate the actual of the call Subprg := Current_Scope; while not Present (Protected_Body_Subprogram (Subprg)) loop Subprg := Scope (Subprg); end loop; -- Use of 'Priority inside protected entries and barriers (in -- both cases the type of the first formal of their expanded -- subprogram is Address) if Etype (First_Entity (Protected_Body_Subprogram (Subprg))) = RTE (RE_Address) then declare New_Itype : Entity_Id; begin -- In the expansion of protected entries the type of the -- first formal of the Protected_Body_Subprogram is an -- Address. In order to reference the _object component -- we generate: -- type T is access p__ptTV; -- freeze T [] New_Itype := Create_Itype (E_Access_Type, N); Set_Etype (New_Itype, New_Itype); Set_Directly_Designated_Type (New_Itype, Corresponding_Record_Type (Conctyp)); Freeze_Itype (New_Itype, N); -- Generate: -- T!(O)._object'unchecked_access Object_Parm := Make_Attribute_Reference (Loc, Prefix => Make_Selected_Component (Loc, Prefix => Unchecked_Convert_To (New_Itype, New_Reference_To (First_Entity (Protected_Body_Subprogram (Subprg)), Loc)), Selector_Name => Make_Identifier (Loc, Name_uObject)), Attribute_Name => Name_Unchecked_Access); end; -- Use of 'Priority inside a protected subprogram else Object_Parm := Make_Attribute_Reference (Loc, Prefix => Make_Selected_Component (Loc, Prefix => New_Reference_To (First_Entity (Protected_Body_Subprogram (Subprg)), Loc), Selector_Name => Make_Identifier (Loc, Name_uObject)), Attribute_Name => Name_Unchecked_Access); end if; -- Select the appropriate run-time subprogram if Number_Entries (Conctyp) = 0 then RT_Subprg_Name := New_Reference_To (RTE (RE_Get_Ceiling), Loc); else RT_Subprg_Name := New_Reference_To (RTE (RO_PE_Get_Ceiling), Loc); end if; Call := Make_Function_Call (Loc, Name => RT_Subprg_Name, Parameter_Associations => New_List (Object_Parm)); Rewrite (N, Call); -- Avoid the generation of extra checks on the pointer to the -- protected object. Analyze_And_Resolve (N, Typ, Suppress => Access_Check); end; ------------------ -- Range_Length -- ------------------ when Attribute_Range_Length => Range_Length : begin -- The only special processing required is for the case where -- Range_Length is applied to an enumeration type with holes. -- In this case we transform -- X'Range_Length -- to -- X'Pos (X'Last) - X'Pos (X'First) + 1 -- So that the result reflects the proper Pos values instead -- of the underlying representations. if Is_Enumeration_Type (Ptyp) and then Has_Non_Standard_Rep (Ptyp) then Rewrite (N, Make_Op_Add (Loc, Left_Opnd => Make_Op_Subtract (Loc, Left_Opnd => Make_Attribute_Reference (Loc, Attribute_Name => Name_Pos, Prefix => New_Occurrence_Of (Ptyp, Loc), Expressions => New_List ( Make_Attribute_Reference (Loc, Attribute_Name => Name_Last, Prefix => New_Occurrence_Of (Ptyp, Loc)))), Right_Opnd => Make_Attribute_Reference (Loc, Attribute_Name => Name_Pos, Prefix => New_Occurrence_Of (Ptyp, Loc), Expressions => New_List ( Make_Attribute_Reference (Loc, Attribute_Name => Name_First, Prefix => New_Occurrence_Of (Ptyp, Loc))))), Right_Opnd => Make_Integer_Literal (Loc, 1))); Analyze_And_Resolve (N, Typ); -- For all other cases, the attribute is handled by the back end, but -- we need to deal with the case of the range check on a universal -- integer. else Apply_Universal_Integer_Attribute_Checks (N); end if; end Range_Length; ---------- -- Read -- ---------- when Attribute_Read => Read : declare P_Type : constant Entity_Id := Entity (Pref); B_Type : constant Entity_Id := Base_Type (P_Type); U_Type : constant Entity_Id := Underlying_Type (P_Type); Pname : Entity_Id; Decl : Node_Id; Prag : Node_Id; Arg2 : Node_Id; Rfunc : Node_Id; Lhs : Node_Id; Rhs : Node_Id; begin -- If no underlying type, we have an error that will be diagnosed -- elsewhere, so here we just completely ignore the expansion. if No (U_Type) then return; end if; -- The simple case, if there is a TSS for Read, just call it Pname := Find_Stream_Subprogram (P_Type, TSS_Stream_Read); if Present (Pname) then null; else -- If there is a Stream_Convert pragma, use it, we rewrite -- sourcetyp'Read (stream, Item) -- as -- Item := sourcetyp (strmread (strmtyp'Input (Stream))); -- where strmread is the given Read function that converts an -- argument of type strmtyp to type sourcetyp or a type from which -- it is derived. The conversion to sourcetyp is required in the -- latter case. -- A special case arises if Item is a type conversion in which -- case, we have to expand to: -- Itemx := typex (strmread (strmtyp'Input (Stream))); -- where Itemx is the expression of the type conversion (i.e. -- the actual object), and typex is the type of Itemx. Prag := Get_Stream_Convert_Pragma (P_Type); if Present (Prag) then Arg2 := Next (First (Pragma_Argument_Associations (Prag))); Rfunc := Entity (Expression (Arg2)); Lhs := Relocate_Node (Next (First (Exprs))); Rhs := OK_Convert_To (B_Type, Make_Function_Call (Loc, Name => New_Occurrence_Of (Rfunc, Loc), Parameter_Associations => New_List ( Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (First_Formal (Rfunc)), Loc), Attribute_Name => Name_Input, Expressions => New_List ( Relocate_Node (First (Exprs))))))); if Nkind (Lhs) = N_Type_Conversion then Lhs := Expression (Lhs); Rhs := Convert_To (Etype (Lhs), Rhs); end if; Rewrite (N, Make_Assignment_Statement (Loc, Name => Lhs, Expression => Rhs)); Set_Assignment_OK (Lhs); Analyze (N); return; -- For elementary types, we call the I_xxx routine using the first -- parameter and then assign the result into the second parameter. -- We set Assignment_OK to deal with the conversion case. elsif Is_Elementary_Type (U_Type) then declare Lhs : Node_Id; Rhs : Node_Id; begin Lhs := Relocate_Node (Next (First (Exprs))); Rhs := Build_Elementary_Input_Call (N); if Nkind (Lhs) = N_Type_Conversion then Lhs := Expression (Lhs); Rhs := Convert_To (Etype (Lhs), Rhs); end if; Set_Assignment_OK (Lhs); Rewrite (N, Make_Assignment_Statement (Loc, Name => Lhs, Expression => Rhs)); Analyze (N); return; end; -- Array type case elsif Is_Array_Type (U_Type) then Build_Array_Read_Procedure (N, U_Type, Decl, Pname); Compile_Stream_Body_In_Scope (N, Decl, U_Type, Check => False); -- Tagged type case, use the primitive Read function. Note that -- this will dispatch in the class-wide case which is what we want elsif Is_Tagged_Type (U_Type) then Pname := Find_Prim_Op (U_Type, TSS_Stream_Read); -- All other record type cases, including protected records. The -- latter only arise for expander generated code for handling -- shared passive partition access. else pragma Assert (Is_Record_Type (U_Type) or else Is_Protected_Type (U_Type)); -- Ada 2005 (AI-216): Program_Error is raised when executing -- the default implementation of the Read attribute of an -- Unchecked_Union type. if Is_Unchecked_Union (Base_Type (U_Type)) then Insert_Action (N, Make_Raise_Program_Error (Loc, Reason => PE_Unchecked_Union_Restriction)); end if; if Has_Discriminants (U_Type) and then Present (Discriminant_Default_Value (First_Discriminant (U_Type))) then Build_Mutable_Record_Read_Procedure (Loc, Full_Base (U_Type), Decl, Pname); else Build_Record_Read_Procedure (Loc, Full_Base (U_Type), Decl, Pname); end if; -- Suppress checks, uninitialized or otherwise invalid -- data does not cause constraint errors to be raised for -- a complete record read. Insert_Action (N, Decl, All_Checks); end if; end if; Rewrite_Stream_Proc_Call (Pname); end Read; --------- -- Ref -- --------- -- Ref is identical to To_Address, see To_Address for processing --------------- -- Remainder -- --------------- -- Transforms 'Remainder into a call to the floating-point attribute -- function Remainder in Fat_xxx (where xxx is the root type) when Attribute_Remainder => Expand_Fpt_Attribute_RR (N); ------------ -- Result -- ------------ -- Transform 'Result into reference to _Result formal. At the point -- where a legal 'Result attribute is expanded, we know that we are in -- the context of a _Postcondition function with a _Result parameter. when Attribute_Result => Rewrite (N, Make_Identifier (Loc, Chars => Name_uResult)); Analyze_And_Resolve (N, Typ); ----------- -- Round -- ----------- -- The handling of the Round attribute is quite delicate. The processing -- in Sem_Attr introduced a conversion to universal real, reflecting the -- semantics of Round, but we do not want anything to do with universal -- real at runtime, since this corresponds to using floating-point -- arithmetic. -- What we have now is that the Etype of the Round attribute correctly -- indicates the final result type. The operand of the Round is the -- conversion to universal real, described above, and the operand of -- this conversion is the actual operand of Round, which may be the -- special case of a fixed point multiplication or division (Etype = -- universal fixed) -- The exapander will expand first the operand of the conversion, then -- the conversion, and finally the round attribute itself, since we -- always work inside out. But we cannot simply process naively in this -- order. In the semantic world where universal fixed and real really -- exist and have infinite precision, there is no problem, but in the -- implementation world, where universal real is a floating-point type, -- we would get the wrong result. -- So the approach is as follows. First, when expanding a multiply or -- divide whose type is universal fixed, we do nothing at all, instead -- deferring the operation till later. -- The actual processing is done in Expand_N_Type_Conversion which -- handles the special case of Round by looking at its parent to see if -- it is a Round attribute, and if it is, handling the conversion (or -- its fixed multiply/divide child) in an appropriate manner. -- This means that by the time we get to expanding the Round attribute -- itself, the Round is nothing more than a type conversion (and will -- often be a null type conversion), so we just replace it with the -- appropriate conversion operation. when Attribute_Round => Rewrite (N, Convert_To (Etype (N), Relocate_Node (First (Exprs)))); Analyze_And_Resolve (N); -------------- -- Rounding -- -------------- -- Transforms 'Rounding into a call to the floating-point attribute -- function Rounding in Fat_xxx (where xxx is the root type) when Attribute_Rounding => Expand_Fpt_Attribute_R (N); ------------------ -- Same_Storage -- ------------------ when Attribute_Same_Storage => Same_Storage : declare Loc : constant Source_Ptr := Sloc (N); X : constant Node_Id := Prefix (N); Y : constant Node_Id := First (Expressions (N)); -- The arguments X_Addr, Y_Addr : Node_Id; -- Rhe expressions for their addresses X_Size, Y_Size : Node_Id; -- Rhe expressions for their sizes begin -- The attribute is expanded as: -- (X'address = Y'address) -- and then (X'Size = Y'Size) -- If both arguments have the same Etype the second conjunct can be -- omitted. X_Addr := Make_Attribute_Reference (Loc, Attribute_Name => Name_Address, Prefix => New_Copy_Tree (X)); Y_Addr := Make_Attribute_Reference (Loc, Attribute_Name => Name_Address, Prefix => New_Copy_Tree (Y)); X_Size := Make_Attribute_Reference (Loc, Attribute_Name => Name_Size, Prefix => New_Copy_Tree (X)); Y_Size := Make_Attribute_Reference (Loc, Attribute_Name => Name_Size, Prefix => New_Copy_Tree (Y)); if Etype (X) = Etype (Y) then Rewrite (N, (Make_Op_Eq (Loc, Left_Opnd => X_Addr, Right_Opnd => Y_Addr))); else Rewrite (N, Make_Op_And (Loc, Left_Opnd => Make_Op_Eq (Loc, Left_Opnd => X_Addr, Right_Opnd => Y_Addr), Right_Opnd => Make_Op_Eq (Loc, Left_Opnd => X_Size, Right_Opnd => Y_Size))); end if; Analyze_And_Resolve (N, Standard_Boolean); end Same_Storage; ------------- -- Scaling -- ------------- -- Transforms 'Scaling into a call to the floating-point attribute -- function Scaling in Fat_xxx (where xxx is the root type) when Attribute_Scaling => Expand_Fpt_Attribute_RI (N); ------------------------- -- Simple_Storage_Pool -- ------------------------- when Attribute_Simple_Storage_Pool => Rewrite (N, Make_Type_Conversion (Loc, Subtype_Mark => New_Reference_To (Etype (N), Loc), Expression => New_Reference_To (Entity (N), Loc))); Analyze_And_Resolve (N, Typ); ---------- -- Size -- ---------- when Attribute_Size | Attribute_Object_Size | Attribute_Value_Size | Attribute_VADS_Size => Size : declare Siz : Uint; New_Node : Node_Id; begin -- Processing for VADS_Size case. Note that this processing removes -- all traces of VADS_Size from the tree, and completes all required -- processing for VADS_Size by translating the attribute reference -- to an appropriate Size or Object_Size reference. if Id = Attribute_VADS_Size or else (Use_VADS_Size and then Id = Attribute_Size) then -- If the size is specified, then we simply use the specified -- size. This applies to both types and objects. The size of an -- object can be specified in the following ways: -- An explicit size object is given for an object -- A component size is specified for an indexed component -- A component clause is specified for a selected component -- The object is a component of a packed composite object -- If the size is specified, then VADS_Size of an object if (Is_Entity_Name (Pref) and then Present (Size_Clause (Entity (Pref)))) or else (Nkind (Pref) = N_Component_Clause and then (Present (Component_Clause (Entity (Selector_Name (Pref)))) or else Is_Packed (Etype (Prefix (Pref))))) or else (Nkind (Pref) = N_Indexed_Component and then (Component_Size (Etype (Prefix (Pref))) /= 0 or else Is_Packed (Etype (Prefix (Pref))))) then Set_Attribute_Name (N, Name_Size); -- Otherwise if we have an object rather than a type, then the -- VADS_Size attribute applies to the type of the object, rather -- than the object itself. This is one of the respects in which -- VADS_Size differs from Size. else if (not Is_Entity_Name (Pref) or else not Is_Type (Entity (Pref))) and then (Is_Scalar_Type (Ptyp) or else Is_Constrained (Ptyp)) then Rewrite (Pref, New_Occurrence_Of (Ptyp, Loc)); end if; -- For a scalar type for which no size was explicitly given, -- VADS_Size means Object_Size. This is the other respect in -- which VADS_Size differs from Size. if Is_Scalar_Type (Ptyp) and then No (Size_Clause (Ptyp)) then Set_Attribute_Name (N, Name_Object_Size); -- In all other cases, Size and VADS_Size are the sane else Set_Attribute_Name (N, Name_Size); end if; end if; end if; -- For class-wide types, X'Class'Size is transformed into a direct -- reference to the Size of the class type, so that the back end does -- not have to deal with the X'Class'Size reference. if Is_Entity_Name (Pref) and then Is_Class_Wide_Type (Entity (Pref)) then Rewrite (Prefix (N), New_Occurrence_Of (Entity (Pref), Loc)); return; -- For X'Size applied to an object of a class-wide type, transform -- X'Size into a call to the primitive operation _Size applied to X. elsif Is_Class_Wide_Type (Ptyp) or else (Id = Attribute_Size and then Is_Tagged_Type (Ptyp) and then Has_Unknown_Discriminants (Ptyp)) then -- No need to do anything else compiling under restriction -- No_Dispatching_Calls. During the semantic analysis we -- already notified such violation. if Restriction_Active (No_Dispatching_Calls) then return; end if; New_Node := Make_Function_Call (Loc, Name => New_Reference_To (Find_Prim_Op (Ptyp, Name_uSize), Loc), Parameter_Associations => New_List (Pref)); if Typ /= Standard_Long_Long_Integer then -- The context is a specific integer type with which the -- original attribute was compatible. The function has a -- specific type as well, so to preserve the compatibility -- we must convert explicitly. New_Node := Convert_To (Typ, New_Node); end if; Rewrite (N, New_Node); Analyze_And_Resolve (N, Typ); return; -- Case of known RM_Size of a type elsif (Id = Attribute_Size or else Id = Attribute_Value_Size) and then Is_Entity_Name (Pref) and then Is_Type (Entity (Pref)) and then Known_Static_RM_Size (Entity (Pref)) then Siz := RM_Size (Entity (Pref)); -- Case of known Esize of a type elsif Id = Attribute_Object_Size and then Is_Entity_Name (Pref) and then Is_Type (Entity (Pref)) and then Known_Static_Esize (Entity (Pref)) then Siz := Esize (Entity (Pref)); -- Case of known size of object elsif Id = Attribute_Size and then Is_Entity_Name (Pref) and then Is_Object (Entity (Pref)) and then Known_Esize (Entity (Pref)) and then Known_Static_Esize (Entity (Pref)) then Siz := Esize (Entity (Pref)); -- For an array component, we can do Size in the front end -- if the component_size of the array is set. elsif Nkind (Pref) = N_Indexed_Component then Siz := Component_Size (Etype (Prefix (Pref))); -- For a record component, we can do Size in the front end if there -- is a component clause, or if the record is packed and the -- component's size is known at compile time. elsif Nkind (Pref) = N_Selected_Component then declare Rec : constant Entity_Id := Etype (Prefix (Pref)); Comp : constant Entity_Id := Entity (Selector_Name (Pref)); begin if Present (Component_Clause (Comp)) then Siz := Esize (Comp); elsif Is_Packed (Rec) then Siz := RM_Size (Ptyp); else Apply_Universal_Integer_Attribute_Checks (N); return; end if; end; -- All other cases are handled by the back end else Apply_Universal_Integer_Attribute_Checks (N); -- If Size is applied to a formal parameter that is of a packed -- array subtype, then apply Size to the actual subtype. if Is_Entity_Name (Pref) and then Is_Formal (Entity (Pref)) and then Is_Array_Type (Ptyp) and then Is_Packed (Ptyp) then Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Get_Actual_Subtype (Pref), Loc), Attribute_Name => Name_Size)); Analyze_And_Resolve (N, Typ); end if; -- If Size applies to a dereference of an access to unconstrained -- packed array, the back end needs to see its unconstrained -- nominal type, but also a hint to the actual constrained type. if Nkind (Pref) = N_Explicit_Dereference and then Is_Array_Type (Ptyp) and then not Is_Constrained (Ptyp) and then Is_Packed (Ptyp) then Set_Actual_Designated_Subtype (Pref, Get_Actual_Subtype (Pref)); end if; return; end if; -- Common processing for record and array component case if Siz /= No_Uint and then Siz /= 0 then declare CS : constant Boolean := Comes_From_Source (N); begin Rewrite (N, Make_Integer_Literal (Loc, Siz)); -- This integer literal is not a static expression. We do not -- call Analyze_And_Resolve here, because this would activate -- the circuit for deciding that a static value was out of -- range, and we don't want that. -- So just manually set the type, mark the expression as non- -- static, and then ensure that the result is checked properly -- if the attribute comes from source (if it was internally -- generated, we never need a constraint check). Set_Etype (N, Typ); Set_Is_Static_Expression (N, False); if CS then Apply_Constraint_Check (N, Typ); end if; end; end if; end Size; ------------------ -- Storage_Pool -- ------------------ when Attribute_Storage_Pool => Rewrite (N, Make_Type_Conversion (Loc, Subtype_Mark => New_Reference_To (Etype (N), Loc), Expression => New_Reference_To (Entity (N), Loc))); Analyze_And_Resolve (N, Typ); ------------------ -- Storage_Size -- ------------------ when Attribute_Storage_Size => Storage_Size : declare Alloc_Op : Entity_Id := Empty; begin -- Access type case, always go to the root type -- The case of access types results in a value of zero for the case -- where no storage size attribute clause has been given. If a -- storage size has been given, then the attribute is converted -- to a reference to the variable used to hold this value. if Is_Access_Type (Ptyp) then if Present (Storage_Size_Variable (Root_Type (Ptyp))) then Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Typ, Loc), Attribute_Name => Name_Max, Expressions => New_List ( Make_Integer_Literal (Loc, 0), Convert_To (Typ, New_Reference_To (Storage_Size_Variable (Root_Type (Ptyp)), Loc))))); elsif Present (Associated_Storage_Pool (Root_Type (Ptyp))) then -- If the access type is associated with a simple storage pool -- object, then attempt to locate the optional Storage_Size -- function of the simple storage pool type. If not found, -- then the result will default to zero. if Present (Get_Rep_Pragma (Root_Type (Ptyp), Name_Simple_Storage_Pool_Type)) then declare Pool_Type : constant Entity_Id := Base_Type (Etype (Entity (N))); begin Alloc_Op := Get_Name_Entity_Id (Name_Storage_Size); while Present (Alloc_Op) loop if Scope (Alloc_Op) = Scope (Pool_Type) and then Present (First_Formal (Alloc_Op)) and then Etype (First_Formal (Alloc_Op)) = Pool_Type then exit; end if; Alloc_Op := Homonym (Alloc_Op); end loop; end; -- In the normal Storage_Pool case, retrieve the primitive -- function associated with the pool type. else Alloc_Op := Find_Prim_Op (Etype (Associated_Storage_Pool (Root_Type (Ptyp))), Attribute_Name (N)); end if; -- If Storage_Size wasn't found (can only occur in the simple -- storage pool case), then simply use zero for the result. if not Present (Alloc_Op) then Rewrite (N, Make_Integer_Literal (Loc, 0)); -- Otherwise, rewrite the allocator as a call to pool type's -- Storage_Size function. else Rewrite (N, OK_Convert_To (Typ, Make_Function_Call (Loc, Name => New_Reference_To (Alloc_Op, Loc), Parameter_Associations => New_List ( New_Reference_To (Associated_Storage_Pool (Root_Type (Ptyp)), Loc))))); end if; else Rewrite (N, Make_Integer_Literal (Loc, 0)); end if; Analyze_And_Resolve (N, Typ); -- For tasks, we retrieve the size directly from the TCB. The -- size may depend on a discriminant of the type, and therefore -- can be a per-object expression, so type-level information is -- not sufficient in general. There are four cases to consider: -- a) If the attribute appears within a task body, the designated -- TCB is obtained by a call to Self. -- b) If the prefix of the attribute is the name of a task object, -- the designated TCB is the one stored in the corresponding record. -- c) If the prefix is a task type, the size is obtained from the -- size variable created for each task type -- d) If no storage_size was specified for the type , there is no -- size variable, and the value is a system-specific default. else if In_Open_Scopes (Ptyp) then -- Storage_Size (Self) Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Storage_Size), Loc), Parameter_Associations => New_List ( Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Self), Loc)))))); elsif not Is_Entity_Name (Pref) or else not Is_Type (Entity (Pref)) then -- Storage_Size (Rec (Obj).Size) Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Occurrence_Of (RTE (RE_Storage_Size), Loc), Parameter_Associations => New_List ( Make_Selected_Component (Loc, Prefix => Unchecked_Convert_To ( Corresponding_Record_Type (Ptyp), New_Copy_Tree (Pref)), Selector_Name => Make_Identifier (Loc, Name_uTask_Id)))))); elsif Present (Storage_Size_Variable (Ptyp)) then -- Static storage size pragma given for type: retrieve value -- from its allocated storage variable. Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Occurrence_Of ( RTE (RE_Adjust_Storage_Size), Loc), Parameter_Associations => New_List ( New_Reference_To ( Storage_Size_Variable (Ptyp), Loc))))); else -- Get system default Rewrite (N, Convert_To (Typ, Make_Function_Call (Loc, Name => New_Occurrence_Of ( RTE (RE_Default_Stack_Size), Loc)))); end if; Analyze_And_Resolve (N, Typ); end if; end Storage_Size; ----------------- -- Stream_Size -- ----------------- when Attribute_Stream_Size => Rewrite (N, Make_Integer_Literal (Loc, Intval => Get_Stream_Size (Ptyp))); Analyze_And_Resolve (N, Typ); ---------- -- Succ -- ---------- -- 1. Deal with enumeration types with holes -- 2. For floating-point, generate call to attribute function -- 3. For other cases, deal with constraint checking when Attribute_Succ => Succ : declare Etyp : constant Entity_Id := Base_Type (Ptyp); begin -- For enumeration types with non-standard representations, we -- expand typ'Succ (x) into -- Pos_To_Rep (Rep_To_Pos (x) + 1) -- If the representation is contiguous, we compute instead -- Lit1 + Rep_to_Pos (x+1), to catch invalid representations. if Is_Enumeration_Type (Ptyp) and then Present (Enum_Pos_To_Rep (Etyp)) then if Has_Contiguous_Rep (Etyp) then Rewrite (N, Unchecked_Convert_To (Ptyp, Make_Op_Add (Loc, Left_Opnd => Make_Integer_Literal (Loc, Enumeration_Rep (First_Literal (Ptyp))), Right_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => New_List ( Unchecked_Convert_To (Ptyp, Make_Op_Add (Loc, Left_Opnd => Unchecked_Convert_To (Standard_Integer, Relocate_Node (First (Exprs))), Right_Opnd => Make_Integer_Literal (Loc, 1))), Rep_To_Pos_Flag (Ptyp, Loc)))))); else -- Add Boolean parameter True, to request program errror if -- we have a bad representation on our hands. Add False if -- checks are suppressed. Append_To (Exprs, Rep_To_Pos_Flag (Ptyp, Loc)); Rewrite (N, Make_Indexed_Component (Loc, Prefix => New_Reference_To (Enum_Pos_To_Rep (Etyp), Loc), Expressions => New_List ( Make_Op_Add (Loc, Left_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => Exprs), Right_Opnd => Make_Integer_Literal (Loc, 1))))); end if; Analyze_And_Resolve (N, Typ); -- For floating-point, we transform 'Succ into a call to the Succ -- floating-point attribute function in Fat_xxx (xxx is root type) elsif Is_Floating_Point_Type (Ptyp) then Expand_Fpt_Attribute_R (N); Analyze_And_Resolve (N, Typ); -- For modular types, nothing to do (no overflow, since wraps) elsif Is_Modular_Integer_Type (Ptyp) then null; -- For other types, if argument is marked as needing a range check or -- overflow checking is enabled, we must generate a check. elsif not Overflow_Checks_Suppressed (Ptyp) or else Do_Range_Check (First (Exprs)) then Set_Do_Range_Check (First (Exprs), False); Expand_Pred_Succ (N); end if; end Succ; --------- -- Tag -- --------- -- Transforms X'Tag into a direct reference to the tag of X when Attribute_Tag => Tag : declare Ttyp : Entity_Id; Prefix_Is_Type : Boolean; begin if Is_Entity_Name (Pref) and then Is_Type (Entity (Pref)) then Ttyp := Entity (Pref); Prefix_Is_Type := True; else Ttyp := Ptyp; Prefix_Is_Type := False; end if; if Is_Class_Wide_Type (Ttyp) then Ttyp := Root_Type (Ttyp); end if; Ttyp := Underlying_Type (Ttyp); -- Ada 2005: The type may be a synchronized tagged type, in which -- case the tag information is stored in the corresponding record. if Is_Concurrent_Type (Ttyp) then Ttyp := Corresponding_Record_Type (Ttyp); end if; if Prefix_Is_Type then -- For VMs we leave the type attribute unexpanded because -- there's not a dispatching table to reference. if Tagged_Type_Expansion then Rewrite (N, Unchecked_Convert_To (RTE (RE_Tag), New_Reference_To (Node (First_Elmt (Access_Disp_Table (Ttyp))), Loc))); Analyze_And_Resolve (N, RTE (RE_Tag)); end if; -- Ada 2005 (AI-251): The use of 'Tag in the sources always -- references the primary tag of the actual object. If 'Tag is -- applied to class-wide interface objects we generate code that -- displaces "this" to reference the base of the object. elsif Comes_From_Source (N) and then Is_Class_Wide_Type (Etype (Prefix (N))) and then Is_Interface (Etype (Prefix (N))) then -- Generate: -- (To_Tag_Ptr (Prefix'Address)).all -- Note that Prefix'Address is recursively expanded into a call -- to Base_Address (Obj.Tag) -- Not needed for VM targets, since all handled by the VM if Tagged_Type_Expansion then Rewrite (N, Make_Explicit_Dereference (Loc, Unchecked_Convert_To (RTE (RE_Tag_Ptr), Make_Attribute_Reference (Loc, Prefix => Relocate_Node (Pref), Attribute_Name => Name_Address)))); Analyze_And_Resolve (N, RTE (RE_Tag)); end if; else Rewrite (N, Make_Selected_Component (Loc, Prefix => Relocate_Node (Pref), Selector_Name => New_Reference_To (First_Tag_Component (Ttyp), Loc))); Analyze_And_Resolve (N, RTE (RE_Tag)); end if; end Tag; ---------------- -- Terminated -- ---------------- -- Transforms 'Terminated attribute into a call to Terminated function when Attribute_Terminated => Terminated : begin -- The prefix of Terminated is of a task interface class-wide type. -- Generate: -- terminated (Task_Id (Pref._disp_get_task_id)); if Ada_Version >= Ada_2005 and then Ekind (Ptyp) = E_Class_Wide_Type and then Is_Interface (Ptyp) and then Is_Task_Interface (Ptyp) then Rewrite (N, Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Terminated), Loc), Parameter_Associations => New_List ( Make_Unchecked_Type_Conversion (Loc, Subtype_Mark => New_Reference_To (RTE (RO_ST_Task_Id), Loc), Expression => Make_Selected_Component (Loc, Prefix => New_Copy_Tree (Pref), Selector_Name => Make_Identifier (Loc, Name_uDisp_Get_Task_Id)))))); elsif Restricted_Profile then Rewrite (N, Build_Call_With_Task (Pref, RTE (RE_Restricted_Terminated))); else Rewrite (N, Build_Call_With_Task (Pref, RTE (RE_Terminated))); end if; Analyze_And_Resolve (N, Standard_Boolean); end Terminated; ---------------- -- To_Address -- ---------------- -- Transforms System'To_Address (X) and System.Address'Ref (X) into -- unchecked conversion from (integral) type of X to type address. when Attribute_To_Address | Attribute_Ref => Rewrite (N, Unchecked_Convert_To (RTE (RE_Address), Relocate_Node (First (Exprs)))); Analyze_And_Resolve (N, RTE (RE_Address)); ------------ -- To_Any -- ------------ when Attribute_To_Any => To_Any : declare P_Type : constant Entity_Id := Etype (Pref); Decls : constant List_Id := New_List; begin Rewrite (N, Build_To_Any_Call (Convert_To (P_Type, Relocate_Node (First (Exprs))), Decls)); Insert_Actions (N, Decls); Analyze_And_Resolve (N, RTE (RE_Any)); end To_Any; ---------------- -- Truncation -- ---------------- -- Transforms 'Truncation into a call to the floating-point attribute -- function Truncation in Fat_xxx (where xxx is the root type). -- Expansion is avoided for cases the back end can handle directly. when Attribute_Truncation => if not Is_Inline_Floating_Point_Attribute (N) then Expand_Fpt_Attribute_R (N); end if; -------------- -- TypeCode -- -------------- when Attribute_TypeCode => TypeCode : declare P_Type : constant Entity_Id := Etype (Pref); Decls : constant List_Id := New_List; begin Rewrite (N, Build_TypeCode_Call (Loc, P_Type, Decls)); Insert_Actions (N, Decls); Analyze_And_Resolve (N, RTE (RE_TypeCode)); end TypeCode; ----------------------- -- Unbiased_Rounding -- ----------------------- -- Transforms 'Unbiased_Rounding into a call to the floating-point -- attribute function Unbiased_Rounding in Fat_xxx (where xxx is the -- root type). Expansion is avoided for cases the back end can handle -- directly. when Attribute_Unbiased_Rounding => if not Is_Inline_Floating_Point_Attribute (N) then Expand_Fpt_Attribute_R (N); end if; ----------------- -- UET_Address -- ----------------- when Attribute_UET_Address => UET_Address : declare Ent : constant Entity_Id := Make_Temporary (Loc, 'T'); begin Insert_Action (N, Make_Object_Declaration (Loc, Defining_Identifier => Ent, Aliased_Present => True, Object_Definition => New_Occurrence_Of (RTE (RE_Address), Loc))); -- Construct name __gnat_xxx__SDP, where xxx is the unit name -- in normal external form. Get_External_Unit_Name_String (Get_Unit_Name (Pref)); Name_Buffer (1 + 7 .. Name_Len + 7) := Name_Buffer (1 .. Name_Len); Name_Len := Name_Len + 7; Name_Buffer (1 .. 7) := "__gnat_"; Name_Buffer (Name_Len + 1 .. Name_Len + 5) := "__SDP"; Name_Len := Name_Len + 5; Set_Is_Imported (Ent); Set_Interface_Name (Ent, Make_String_Literal (Loc, Strval => String_From_Name_Buffer)); -- Set entity as internal to ensure proper Sprint output of its -- implicit importation. Set_Is_Internal (Ent); Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ent, Loc), Attribute_Name => Name_Address)); Analyze_And_Resolve (N, Typ); end UET_Address; --------------- -- VADS_Size -- --------------- -- The processing for VADS_Size is shared with Size --------- -- Val -- --------- -- For enumeration types with a standard representation, and for all -- other types, Val is handled by the back end. For enumeration types -- with a non-standard representation we use the _Pos_To_Rep array that -- was created when the type was frozen. when Attribute_Val => Val : declare Etyp : constant Entity_Id := Base_Type (Entity (Pref)); begin if Is_Enumeration_Type (Etyp) and then Present (Enum_Pos_To_Rep (Etyp)) then if Has_Contiguous_Rep (Etyp) then declare Rep_Node : constant Node_Id := Unchecked_Convert_To (Etyp, Make_Op_Add (Loc, Left_Opnd => Make_Integer_Literal (Loc, Enumeration_Rep (First_Literal (Etyp))), Right_Opnd => (Convert_To (Standard_Integer, Relocate_Node (First (Exprs)))))); begin Rewrite (N, Unchecked_Convert_To (Etyp, Make_Op_Add (Loc, Left_Opnd => Make_Integer_Literal (Loc, Enumeration_Rep (First_Literal (Etyp))), Right_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc), Parameter_Associations => New_List ( Rep_Node, Rep_To_Pos_Flag (Etyp, Loc)))))); end; else Rewrite (N, Make_Indexed_Component (Loc, Prefix => New_Reference_To (Enum_Pos_To_Rep (Etyp), Loc), Expressions => New_List ( Convert_To (Standard_Integer, Relocate_Node (First (Exprs)))))); end if; Analyze_And_Resolve (N, Typ); -- If the argument is marked as requiring a range check then generate -- it here. elsif Do_Range_Check (First (Exprs)) then Set_Do_Range_Check (First (Exprs), False); Generate_Range_Check (First (Exprs), Etyp, CE_Range_Check_Failed); end if; end Val; ----------- -- Valid -- ----------- -- The code for valid is dependent on the particular types involved. -- See separate sections below for the generated code in each case. when Attribute_Valid => Valid : declare Btyp : Entity_Id := Base_Type (Ptyp); Tst : Node_Id; Save_Validity_Checks_On : constant Boolean := Validity_Checks_On; -- Save the validity checking mode. We always turn off validity -- checking during process of 'Valid since this is one place -- where we do not want the implicit validity checks to intefere -- with the explicit validity check that the programmer is doing. function Make_Range_Test return Node_Id; -- Build the code for a range test of the form -- Btyp!(Pref) in Btyp!(Ptyp'First) .. Btyp!(Ptyp'Last) --------------------- -- Make_Range_Test -- --------------------- function Make_Range_Test return Node_Id is Temp : constant Node_Id := Duplicate_Subexpr (Pref); begin -- The value whose validity is being checked has been captured in -- an object declaration. We certainly don't want this object to -- appear valid because the declaration initializes it! if Is_Entity_Name (Temp) then Set_Is_Known_Valid (Entity (Temp), False); end if; return Make_In (Loc, Left_Opnd => Unchecked_Convert_To (Btyp, Temp), Right_Opnd => Make_Range (Loc, Low_Bound => Unchecked_Convert_To (Btyp, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ptyp, Loc), Attribute_Name => Name_First)), High_Bound => Unchecked_Convert_To (Btyp, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ptyp, Loc), Attribute_Name => Name_Last)))); end Make_Range_Test; -- Start of processing for Attribute_Valid begin -- Do not expand sourced code 'Valid reference in CodePeer mode, -- will be handled by the back-end directly. if CodePeer_Mode and then Comes_From_Source (N) then return; end if; -- Turn off validity checks. We do not want any implicit validity -- checks to intefere with the explicit check from the attribute Validity_Checks_On := False; -- Floating-point case. This case is handled by the Valid attribute -- code in the floating-point attribute run-time library. if Is_Floating_Point_Type (Ptyp) then declare Pkg : RE_Id; Ftp : Entity_Id; begin case Float_Rep (Btyp) is -- For vax fpt types, call appropriate routine in special -- vax floating point unit. No need to worry about loads in -- this case, since these types have no signalling NaN's. when VAX_Native => Expand_Vax_Valid (N); -- The AAMP back end handles Valid for floating-point types when AAMP => Analyze_And_Resolve (Pref, Ptyp); Set_Etype (N, Standard_Boolean); Set_Analyzed (N); when IEEE_Binary => Find_Fat_Info (Ptyp, Ftp, Pkg); -- If the floating-point object might be unaligned, we -- need to call the special routine Unaligned_Valid, -- which makes the needed copy, being careful not to -- load the value into any floating-point register. -- The argument in this case is obj'Address (see -- Unaligned_Valid routine in Fat_Gen). if Is_Possibly_Unaligned_Object (Pref) then Expand_Fpt_Attribute (N, Pkg, Name_Unaligned_Valid, New_List ( Make_Attribute_Reference (Loc, Prefix => Relocate_Node (Pref), Attribute_Name => Name_Address))); -- In the normal case where we are sure the object is -- aligned, we generate a call to Valid, and the argument -- in this case is obj'Unrestricted_Access (after -- converting obj to the right floating-point type). else Expand_Fpt_Attribute (N, Pkg, Name_Valid, New_List ( Make_Attribute_Reference (Loc, Prefix => Unchecked_Convert_To (Ftp, Pref), Attribute_Name => Name_Unrestricted_Access))); end if; end case; -- One more task, we still need a range check. Required -- only if we have a constraint, since the Valid routine -- catches infinities properly (infinities are never valid). -- The way we do the range check is simply to create the -- expression: Valid (N) and then Base_Type(Pref) in Typ. if not Subtypes_Statically_Match (Ptyp, Btyp) then Rewrite (N, Make_And_Then (Loc, Left_Opnd => Relocate_Node (N), Right_Opnd => Make_In (Loc, Left_Opnd => Convert_To (Btyp, Pref), Right_Opnd => New_Occurrence_Of (Ptyp, Loc)))); end if; end; -- Enumeration type with holes -- For enumeration types with holes, the Pos value constructed by -- the Enum_Rep_To_Pos function built in Exp_Ch3 called with a -- second argument of False returns minus one for an invalid value, -- and the non-negative pos value for a valid value, so the -- expansion of X'Valid is simply: -- type(X)'Pos (X) >= 0 -- We can't quite generate it that way because of the requirement -- for the non-standard second argument of False in the resulting -- rep_to_pos call, so we have to explicitly create: -- _rep_to_pos (X, False) >= 0 -- If we have an enumeration subtype, we also check that the -- value is in range: -- _rep_to_pos (X, False) >= 0 -- and then -- (X >= type(X)'First and then type(X)'Last <= X) elsif Is_Enumeration_Type (Ptyp) and then Present (Enum_Pos_To_Rep (Base_Type (Ptyp))) then Tst := Make_Op_Ge (Loc, Left_Opnd => Make_Function_Call (Loc, Name => New_Reference_To (TSS (Base_Type (Ptyp), TSS_Rep_To_Pos), Loc), Parameter_Associations => New_List ( Pref, New_Occurrence_Of (Standard_False, Loc))), Right_Opnd => Make_Integer_Literal (Loc, 0)); if Ptyp /= Btyp and then (Type_Low_Bound (Ptyp) /= Type_Low_Bound (Btyp) or else Type_High_Bound (Ptyp) /= Type_High_Bound (Btyp)) then -- The call to Make_Range_Test will create declarations -- that need a proper insertion point, but Pref is now -- attached to a node with no ancestor. Attach to tree -- even if it is to be rewritten below. Set_Parent (Tst, Parent (N)); Tst := Make_And_Then (Loc, Left_Opnd => Make_Range_Test, Right_Opnd => Tst); end if; Rewrite (N, Tst); -- Fortran convention booleans -- For the very special case of Fortran convention booleans, the -- value is always valid, since it is an integer with the semantics -- that non-zero is true, and any value is permissible. elsif Is_Boolean_Type (Ptyp) and then Convention (Ptyp) = Convention_Fortran then Rewrite (N, New_Occurrence_Of (Standard_True, Loc)); -- For biased representations, we will be doing an unchecked -- conversion without unbiasing the result. That means that the range -- test has to take this into account, and the proper form of the -- test is: -- Btyp!(Pref) < Btyp!(Ptyp'Range_Length) elsif Has_Biased_Representation (Ptyp) then Btyp := RTE (RE_Unsigned_32); Rewrite (N, Make_Op_Lt (Loc, Left_Opnd => Unchecked_Convert_To (Btyp, Duplicate_Subexpr (Pref)), Right_Opnd => Unchecked_Convert_To (Btyp, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Ptyp, Loc), Attribute_Name => Name_Range_Length)))); -- For all other scalar types, what we want logically is a -- range test: -- X in type(X)'First .. type(X)'Last -- But that's precisely what won't work because of possible -- unwanted optimization (and indeed the basic motivation for -- the Valid attribute is exactly that this test does not work!) -- What will work is: -- Btyp!(X) >= Btyp!(type(X)'First) -- and then -- Btyp!(X) <= Btyp!(type(X)'Last) -- where Btyp is an integer type large enough to cover the full -- range of possible stored values (i.e. it is chosen on the basis -- of the size of the type, not the range of the values). We write -- this as two tests, rather than a range check, so that static -- evaluation will easily remove either or both of the checks if -- they can be -statically determined to be true (this happens -- when the type of X is static and the range extends to the full -- range of stored values). -- Unsigned types. Note: it is safe to consider only whether the -- subtype is unsigned, since we will in that case be doing all -- unsigned comparisons based on the subtype range. Since we use the -- actual subtype object size, this is appropriate. -- For example, if we have -- subtype x is integer range 1 .. 200; -- for x'Object_Size use 8; -- Now the base type is signed, but objects of this type are bits -- unsigned, and doing an unsigned test of the range 1 to 200 is -- correct, even though a value greater than 127 looks signed to a -- signed comparison. elsif Is_Unsigned_Type (Ptyp) then if Esize (Ptyp) <= 32 then Btyp := RTE (RE_Unsigned_32); else Btyp := RTE (RE_Unsigned_64); end if; Rewrite (N, Make_Range_Test); -- Signed types else if Esize (Ptyp) <= Esize (Standard_Integer) then Btyp := Standard_Integer; else Btyp := Universal_Integer; end if; Rewrite (N, Make_Range_Test); end if; Analyze_And_Resolve (N, Standard_Boolean); Validity_Checks_On := Save_Validity_Checks_On; end Valid; ----------- -- Value -- ----------- -- Value attribute is handled in separate unit Exp_Imgv when Attribute_Value => Exp_Imgv.Expand_Value_Attribute (N); ----------------- -- Value_Size -- ----------------- -- The processing for Value_Size shares the processing for Size ------------- -- Version -- ------------- -- The processing for Version shares the processing for Body_Version ---------------- -- Wide_Image -- ---------------- -- Wide_Image attribute is handled in separate unit Exp_Imgv when Attribute_Wide_Image => Exp_Imgv.Expand_Wide_Image_Attribute (N); --------------------- -- Wide_Wide_Image -- --------------------- -- Wide_Wide_Image attribute is handled in separate unit Exp_Imgv when Attribute_Wide_Wide_Image => Exp_Imgv.Expand_Wide_Wide_Image_Attribute (N); ---------------- -- Wide_Value -- ---------------- -- We expand typ'Wide_Value (X) into -- typ'Value -- (Wide_String_To_String (X, Wide_Character_Encoding_Method)) -- Wide_String_To_String is a runtime function that converts its wide -- string argument to String, converting any non-translatable characters -- into appropriate escape sequences. This preserves the required -- semantics of Wide_Value in all cases, and results in a very simple -- implementation approach. -- Note: for this approach to be fully standard compliant for the cases -- where typ is Wide_Character and Wide_Wide_Character, the encoding -- method must cover the entire character range (e.g. UTF-8). But that -- is a reasonable requirement when dealing with encoded character -- sequences. Presumably if one of the restrictive encoding mechanisms -- is in use such as Shift-JIS, then characters that cannot be -- represented using this encoding will not appear in any case. when Attribute_Wide_Value => Wide_Value : begin Rewrite (N, Make_Attribute_Reference (Loc, Prefix => Pref, Attribute_Name => Name_Value, Expressions => New_List ( Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Wide_String_To_String), Loc), Parameter_Associations => New_List ( Relocate_Node (First (Exprs)), Make_Integer_Literal (Loc, Intval => Int (Wide_Character_Encoding_Method))))))); Analyze_And_Resolve (N, Typ); end Wide_Value; --------------------- -- Wide_Wide_Value -- --------------------- -- We expand typ'Wide_Value_Value (X) into -- typ'Value -- (Wide_Wide_String_To_String (X, Wide_Character_Encoding_Method)) -- Wide_Wide_String_To_String is a runtime function that converts its -- wide string argument to String, converting any non-translatable -- characters into appropriate escape sequences. This preserves the -- required semantics of Wide_Wide_Value in all cases, and results in a -- very simple implementation approach. -- It's not quite right where typ = Wide_Wide_Character, because the -- encoding method may not cover the whole character type ??? when Attribute_Wide_Wide_Value => Wide_Wide_Value : begin Rewrite (N, Make_Attribute_Reference (Loc, Prefix => Pref, Attribute_Name => Name_Value, Expressions => New_List ( Make_Function_Call (Loc, Name => New_Reference_To (RTE (RE_Wide_Wide_String_To_String), Loc), Parameter_Associations => New_List ( Relocate_Node (First (Exprs)), Make_Integer_Literal (Loc, Intval => Int (Wide_Character_Encoding_Method))))))); Analyze_And_Resolve (N, Typ); end Wide_Wide_Value; --------------------- -- Wide_Wide_Width -- --------------------- -- Wide_Wide_Width attribute is handled in separate unit Exp_Imgv when Attribute_Wide_Wide_Width => Exp_Imgv.Expand_Width_Attribute (N, Wide_Wide); ---------------- -- Wide_Width -- ---------------- -- Wide_Width attribute is handled in separate unit Exp_Imgv when Attribute_Wide_Width => Exp_Imgv.Expand_Width_Attribute (N, Wide); ----------- -- Width -- ----------- -- Width attribute is handled in separate unit Exp_Imgv when Attribute_Width => Exp_Imgv.Expand_Width_Attribute (N, Normal); ----------- -- Write -- ----------- when Attribute_Write => Write : declare P_Type : constant Entity_Id := Entity (Pref); U_Type : constant Entity_Id := Underlying_Type (P_Type); Pname : Entity_Id; Decl : Node_Id; Prag : Node_Id; Arg3 : Node_Id; Wfunc : Node_Id; begin -- If no underlying type, we have an error that will be diagnosed -- elsewhere, so here we just completely ignore the expansion. if No (U_Type) then return; end if; -- The simple case, if there is a TSS for Write, just call it Pname := Find_Stream_Subprogram (P_Type, TSS_Stream_Write); if Present (Pname) then null; else -- If there is a Stream_Convert pragma, use it, we rewrite -- sourcetyp'Output (stream, Item) -- as -- strmtyp'Output (Stream, strmwrite (acttyp (Item))); -- where strmwrite is the given Write function that converts an -- argument of type sourcetyp or a type acctyp, from which it is -- derived to type strmtyp. The conversion to acttyp is required -- for the derived case. Prag := Get_Stream_Convert_Pragma (P_Type); if Present (Prag) then Arg3 := Next (Next (First (Pragma_Argument_Associations (Prag)))); Wfunc := Entity (Expression (Arg3)); Rewrite (N, Make_Attribute_Reference (Loc, Prefix => New_Occurrence_Of (Etype (Wfunc), Loc), Attribute_Name => Name_Output, Expressions => New_List ( Relocate_Node (First (Exprs)), Make_Function_Call (Loc, Name => New_Occurrence_Of (Wfunc, Loc), Parameter_Associations => New_List ( OK_Convert_To (Etype (First_Formal (Wfunc)), Relocate_Node (Next (First (Exprs))))))))); Analyze (N); return; -- For elementary types, we call the W_xxx routine directly elsif Is_Elementary_Type (U_Type) then Rewrite (N, Build_Elementary_Write_Call (N)); Analyze (N); return; -- Array type case elsif Is_Array_Type (U_Type) then Build_Array_Write_Procedure (N, U_Type, Decl, Pname); Compile_Stream_Body_In_Scope (N, Decl, U_Type, Check => False); -- Tagged type case, use the primitive Write function. Note that -- this will dispatch in the class-wide case which is what we want elsif Is_Tagged_Type (U_Type) then Pname := Find_Prim_Op (U_Type, TSS_Stream_Write); -- All other record type cases, including protected records. -- The latter only arise for expander generated code for -- handling shared passive partition access. else pragma Assert (Is_Record_Type (U_Type) or else Is_Protected_Type (U_Type)); -- Ada 2005 (AI-216): Program_Error is raised when executing -- the default implementation of the Write attribute of an -- Unchecked_Union type. However, if the 'Write reference is -- within the generated Output stream procedure, Write outputs -- the components, and the default values of the discriminant -- are streamed by the Output procedure itself. if Is_Unchecked_Union (Base_Type (U_Type)) and not Is_TSS (Current_Scope, TSS_Stream_Output) then Insert_Action (N, Make_Raise_Program_Error (Loc, Reason => PE_Unchecked_Union_Restriction)); end if; if Has_Discriminants (U_Type) and then Present (Discriminant_Default_Value (First_Discriminant (U_Type))) then Build_Mutable_Record_Write_Procedure (Loc, Full_Base (U_Type), Decl, Pname); else Build_Record_Write_Procedure (Loc, Full_Base (U_Type), Decl, Pname); end if; Insert_Action (N, Decl); end if; end if; -- If we fall through, Pname is the procedure to be called Rewrite_Stream_Proc_Call (Pname); end Write; -- Component_Size is handled by the back end, unless the component size -- is known at compile time, which is always true in the packed array -- case. It is important that the packed array case is handled in the -- front end (see Eval_Attribute) since the back end would otherwise get -- confused by the equivalent packed array type. when Attribute_Component_Size => null; -- The following attributes are handled by the back end (except that -- static cases have already been evaluated during semantic processing, -- but in any case the back end should not count on this). The one bit -- of special processing required is that these attributes typically -- generate conditionals in the code, so we need to check the relevant -- restriction. when Attribute_Max | Attribute_Min => Check_Restriction (No_Implicit_Conditionals, N); -- The following attributes are handled by the back end (except that -- static cases have already been evaluated during semantic processing, -- but in any case the back end should not count on this). -- The back end also handles the non-class-wide cases of Size when Attribute_Bit_Order | Attribute_Code_Address | Attribute_Definite | Attribute_Null_Parameter | Attribute_Passed_By_Reference | Attribute_Pool_Address => null; -- The following attributes are also handled by the back end, but return -- a universal integer result, so may need a conversion for checking -- that the result is in range. when Attribute_Aft | Attribute_Max_Alignment_For_Allocation => Apply_Universal_Integer_Attribute_Checks (N); -- The following attributes should not appear at this stage, since they -- have already been handled by the analyzer (and properly rewritten -- with corresponding values or entities to represent the right values) when Attribute_Abort_Signal | Attribute_Address_Size | Attribute_Base | Attribute_Class | Attribute_Compiler_Version | Attribute_Default_Bit_Order | Attribute_Delta | Attribute_Denorm | Attribute_Digits | Attribute_Emax | Attribute_Enabled | Attribute_Epsilon | Attribute_Fast_Math | Attribute_Has_Access_Values | Attribute_Has_Discriminants | Attribute_Has_Tagged_Values | Attribute_Large | Attribute_Machine_Emax | Attribute_Machine_Emin | Attribute_Machine_Mantissa | Attribute_Machine_Overflows | Attribute_Machine_Radix | Attribute_Machine_Rounds | Attribute_Maximum_Alignment | Attribute_Model_Emin | Attribute_Model_Epsilon | Attribute_Model_Mantissa | Attribute_Model_Small | Attribute_Modulus | Attribute_Partition_ID | Attribute_Range | Attribute_Safe_Emax | Attribute_Safe_First | Attribute_Safe_Large | Attribute_Safe_Last | Attribute_Safe_Small | Attribute_Scale | Attribute_Signed_Zeros | Attribute_Small | Attribute_Storage_Unit | Attribute_Stub_Type | Attribute_System_Allocator_Alignment | Attribute_Target_Name | Attribute_Type_Class | Attribute_Type_Key | Attribute_Unconstrained_Array | Attribute_Universal_Literal_String | Attribute_Wchar_T_Size | Attribute_Word_Size => raise Program_Error; -- The Asm_Input and Asm_Output attributes are not expanded at this -- stage, but will be eliminated in the expansion of the Asm call, see -- Exp_Intr for details. So the back end will never see these either. when Attribute_Asm_Input | Attribute_Asm_Output => null; end case; exception when RE_Not_Available => return; end Expand_N_Attribute_Reference; ---------------------- -- Expand_Pred_Succ -- ---------------------- -- For typ'Pred (exp), we generate the check -- [constraint_error when exp = typ'Base'First] -- Similarly, for typ'Succ (exp), we generate the check -- [constraint_error when exp = typ'Base'Last] -- These checks are not generated for modular types, since the proper -- semantics for Succ and Pred on modular types is to wrap, not raise CE. -- We also suppress these checks if we are the right side of an assignment -- statement or the expression of an object declaration, where the flag -- Suppress_Assignment_Checks is set for the assignment/declaration. procedure Expand_Pred_Succ (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); P : constant Node_Id := Parent (N); Cnam : Name_Id; begin if Attribute_Name (N) = Name_Pred then Cnam := Name_First; else Cnam := Name_Last; end if; if not Nkind_In (P, N_Assignment_Statement, N_Object_Declaration) or else not Suppress_Assignment_Checks (P) then Insert_Action (N, Make_Raise_Constraint_Error (Loc, Condition => Make_Op_Eq (Loc, Left_Opnd => Duplicate_Subexpr_Move_Checks (First (Expressions (N))), Right_Opnd => Make_Attribute_Reference (Loc, Prefix => New_Reference_To (Base_Type (Etype (Prefix (N))), Loc), Attribute_Name => Cnam)), Reason => CE_Overflow_Check_Failed)); end if; end Expand_Pred_Succ; ------------------- -- Find_Fat_Info -- ------------------- procedure Find_Fat_Info (T : Entity_Id; Fat_Type : out Entity_Id; Fat_Pkg : out RE_Id) is Btyp : constant Entity_Id := Base_Type (T); Rtyp : constant Entity_Id := Root_Type (T); Digs : constant Nat := UI_To_Int (Digits_Value (Btyp)); begin -- If the base type is VAX float, then get appropriate VAX float type if Vax_Float (Btyp) then case Digs is when 6 => Fat_Type := RTE (RE_Fat_VAX_F); Fat_Pkg := RE_Attr_VAX_F_Float; when 9 => Fat_Type := RTE (RE_Fat_VAX_D); Fat_Pkg := RE_Attr_VAX_D_Float; when 15 => Fat_Type := RTE (RE_Fat_VAX_G); Fat_Pkg := RE_Attr_VAX_G_Float; when others => raise Program_Error; end case; -- If root type is VAX float, this is the case where the library has -- been recompiled in VAX float mode, and we have an IEEE float type. -- This is when we use the special IEEE Fat packages. elsif Vax_Float (Rtyp) then case Digs is when 6 => Fat_Type := RTE (RE_Fat_IEEE_Short); Fat_Pkg := RE_Attr_IEEE_Short; when 15 => Fat_Type := RTE (RE_Fat_IEEE_Long); Fat_Pkg := RE_Attr_IEEE_Long; when others => raise Program_Error; end case; -- If neither the base type nor the root type is VAX_Native then VAX -- float is out of the picture, and we can just use the root type. else Fat_Type := Rtyp; if Fat_Type = Standard_Short_Float then Fat_Pkg := RE_Attr_Short_Float; elsif Fat_Type = Standard_Float then Fat_Pkg := RE_Attr_Float; elsif Fat_Type = Standard_Long_Float then Fat_Pkg := RE_Attr_Long_Float; elsif Fat_Type = Standard_Long_Long_Float then Fat_Pkg := RE_Attr_Long_Long_Float; -- Universal real (which is its own root type) is treated as being -- equivalent to Standard.Long_Long_Float, since it is defined to -- have the same precision as the longest Float type. elsif Fat_Type = Universal_Real then Fat_Type := Standard_Long_Long_Float; Fat_Pkg := RE_Attr_Long_Long_Float; else raise Program_Error; end if; end if; end Find_Fat_Info; ---------------------------- -- Find_Stream_Subprogram -- ---------------------------- function Find_Stream_Subprogram (Typ : Entity_Id; Nam : TSS_Name_Type) return Entity_Id is Base_Typ : constant Entity_Id := Base_Type (Typ); Ent : constant Entity_Id := TSS (Typ, Nam); function Is_Available (Entity : RE_Id) return Boolean; pragma Inline (Is_Available); -- Function to check whether the specified run-time call is available -- in the run time used. In the case of a configurable run time, it -- is normal that some subprograms are not there. -- I don't understand this routine at all, why is this not just a -- call to RTE_Available? And if for some reason we need a different -- routine with different semantics, why is not in Rtsfind ??? ------------------ -- Is_Available -- ------------------ function Is_Available (Entity : RE_Id) return Boolean is begin -- Assume that the unit will always be available when using a -- "normal" (not configurable) run time. return not Configurable_Run_Time_Mode or else RTE_Available (Entity); end Is_Available; -- Start of processing for Find_Stream_Subprogram begin if Present (Ent) then return Ent; end if; -- Stream attributes for strings are expanded into library calls. The -- following checks are disabled when the run-time is not available or -- when compiling predefined types due to bootstrap issues. As a result, -- the compiler will generate in-place stream routines for string types -- that appear in GNAT's library, but will generate calls via rtsfind -- to library routines for user code. -- ??? For now, disable this code for JVM, since this generates a -- VerifyError exception at run time on e.g. c330001. -- This is disabled for AAMP, to avoid creating dependences on files not -- supported in the AAMP library (such as s-fileio.adb). -- Note: In the case of using a configurable run time, it is very likely -- that stream routines for string types are not present (they require -- file system support). In this case, the specific stream routines for -- strings are not used, relying on the regular stream mechanism -- instead. That is why we include the test Is_Available when dealing -- with these cases. if VM_Target /= JVM_Target and then not AAMP_On_Target and then not Is_Predefined_File_Name (Unit_File_Name (Current_Sem_Unit)) then -- String as defined in package Ada if Base_Typ = Standard_String then if Restriction_Active (No_Stream_Optimizations) then if Nam = TSS_Stream_Input and then Is_Available (RE_String_Input) then return RTE (RE_String_Input); elsif Nam = TSS_Stream_Output and then Is_Available (RE_String_Output) then return RTE (RE_String_Output); elsif Nam = TSS_Stream_Read and then Is_Available (RE_String_Read) then return RTE (RE_String_Read); elsif Nam = TSS_Stream_Write and then Is_Available (RE_String_Write) then return RTE (RE_String_Write); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; else if Nam = TSS_Stream_Input and then Is_Available (RE_String_Input_Blk_IO) then return RTE (RE_String_Input_Blk_IO); elsif Nam = TSS_Stream_Output and then Is_Available (RE_String_Output_Blk_IO) then return RTE (RE_String_Output_Blk_IO); elsif Nam = TSS_Stream_Read and then Is_Available (RE_String_Read_Blk_IO) then return RTE (RE_String_Read_Blk_IO); elsif Nam = TSS_Stream_Write and then Is_Available (RE_String_Write_Blk_IO) then return RTE (RE_String_Write_Blk_IO); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; end if; -- Wide_String as defined in package Ada elsif Base_Typ = Standard_Wide_String then if Restriction_Active (No_Stream_Optimizations) then if Nam = TSS_Stream_Input and then Is_Available (RE_Wide_String_Input) then return RTE (RE_Wide_String_Input); elsif Nam = TSS_Stream_Output and then Is_Available (RE_Wide_String_Output) then return RTE (RE_Wide_String_Output); elsif Nam = TSS_Stream_Read and then Is_Available (RE_Wide_String_Read) then return RTE (RE_Wide_String_Read); elsif Nam = TSS_Stream_Write and then Is_Available (RE_Wide_String_Write) then return RTE (RE_Wide_String_Write); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; else if Nam = TSS_Stream_Input and then Is_Available (RE_Wide_String_Input_Blk_IO) then return RTE (RE_Wide_String_Input_Blk_IO); elsif Nam = TSS_Stream_Output and then Is_Available (RE_Wide_String_Output_Blk_IO) then return RTE (RE_Wide_String_Output_Blk_IO); elsif Nam = TSS_Stream_Read and then Is_Available (RE_Wide_String_Read_Blk_IO) then return RTE (RE_Wide_String_Read_Blk_IO); elsif Nam = TSS_Stream_Write and then Is_Available (RE_Wide_String_Write_Blk_IO) then return RTE (RE_Wide_String_Write_Blk_IO); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; end if; -- Wide_Wide_String as defined in package Ada elsif Base_Typ = Standard_Wide_Wide_String then if Restriction_Active (No_Stream_Optimizations) then if Nam = TSS_Stream_Input and then Is_Available (RE_Wide_Wide_String_Input) then return RTE (RE_Wide_Wide_String_Input); elsif Nam = TSS_Stream_Output and then Is_Available (RE_Wide_Wide_String_Output) then return RTE (RE_Wide_Wide_String_Output); elsif Nam = TSS_Stream_Read and then Is_Available (RE_Wide_Wide_String_Read) then return RTE (RE_Wide_Wide_String_Read); elsif Nam = TSS_Stream_Write and then Is_Available (RE_Wide_Wide_String_Write) then return RTE (RE_Wide_Wide_String_Write); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; else if Nam = TSS_Stream_Input and then Is_Available (RE_Wide_Wide_String_Input_Blk_IO) then return RTE (RE_Wide_Wide_String_Input_Blk_IO); elsif Nam = TSS_Stream_Output and then Is_Available (RE_Wide_Wide_String_Output_Blk_IO) then return RTE (RE_Wide_Wide_String_Output_Blk_IO); elsif Nam = TSS_Stream_Read and then Is_Available (RE_Wide_Wide_String_Read_Blk_IO) then return RTE (RE_Wide_Wide_String_Read_Blk_IO); elsif Nam = TSS_Stream_Write and then Is_Available (RE_Wide_Wide_String_Write_Blk_IO) then return RTE (RE_Wide_Wide_String_Write_Blk_IO); elsif Nam /= TSS_Stream_Input and then Nam /= TSS_Stream_Output and then Nam /= TSS_Stream_Read and then Nam /= TSS_Stream_Write then raise Program_Error; end if; end if; end if; end if; if Is_Tagged_Type (Typ) and then Is_Derived_Type (Typ) then return Find_Prim_Op (Typ, Nam); else return Find_Inherited_TSS (Typ, Nam); end if; end Find_Stream_Subprogram; --------------- -- Full_Base -- --------------- function Full_Base (T : Entity_Id) return Entity_Id is BT : Entity_Id; begin BT := Base_Type (T); if Is_Private_Type (BT) and then Present (Full_View (BT)) then BT := Full_View (BT); end if; return BT; end Full_Base; ----------------------- -- Get_Index_Subtype -- ----------------------- function Get_Index_Subtype (N : Node_Id) return Node_Id is P_Type : Entity_Id := Etype (Prefix (N)); Indx : Node_Id; J : Int; begin if Is_Access_Type (P_Type) then P_Type := Designated_Type (P_Type); end if; if No (Expressions (N)) then J := 1; else J := UI_To_Int (Expr_Value (First (Expressions (N)))); end if; Indx := First_Index (P_Type); while J > 1 loop Next_Index (Indx); J := J - 1; end loop; return Etype (Indx); end Get_Index_Subtype; ------------------------------- -- Get_Stream_Convert_Pragma -- ------------------------------- function Get_Stream_Convert_Pragma (T : Entity_Id) return Node_Id is Typ : Entity_Id; N : Node_Id; begin -- Note: we cannot use Get_Rep_Pragma here because of the peculiarity -- that a stream convert pragma for a tagged type is not inherited from -- its parent. Probably what is wrong here is that it is basically -- incorrect to consider a stream convert pragma to be a representation -- pragma at all ??? N := First_Rep_Item (Implementation_Base_Type (T)); while Present (N) loop if Nkind (N) = N_Pragma and then Pragma_Name (N) = Name_Stream_Convert then -- For tagged types this pragma is not inherited, so we -- must verify that it is defined for the given type and -- not an ancestor. Typ := Entity (Expression (First (Pragma_Argument_Associations (N)))); if not Is_Tagged_Type (T) or else T = Typ or else (Is_Private_Type (Typ) and then T = Full_View (Typ)) then return N; end if; end if; Next_Rep_Item (N); end loop; return Empty; end Get_Stream_Convert_Pragma; --------------------------------- -- Is_Constrained_Packed_Array -- --------------------------------- function Is_Constrained_Packed_Array (Typ : Entity_Id) return Boolean is Arr : Entity_Id := Typ; begin if Is_Access_Type (Arr) then Arr := Designated_Type (Arr); end if; return Is_Array_Type (Arr) and then Is_Constrained (Arr) and then Present (Packed_Array_Type (Arr)); end Is_Constrained_Packed_Array; ---------------------------------------- -- Is_Inline_Floating_Point_Attribute -- ---------------------------------------- function Is_Inline_Floating_Point_Attribute (N : Node_Id) return Boolean is Id : constant Attribute_Id := Get_Attribute_Id (Attribute_Name (N)); begin if Nkind (Parent (N)) /= N_Type_Conversion or else not Is_Integer_Type (Etype (Parent (N))) then return False; end if; -- Should also support 'Machine_Rounding and 'Unbiased_Rounding, but -- required back end support has not been implemented yet ??? return Id = Attribute_Truncation; end Is_Inline_Floating_Point_Attribute; end Exp_Attr;
Go to most recent revision | Compare with Previous | Blame | View Log