1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Atree; use Atree;
27 with Checks; use Checks;
28 with Einfo; use Einfo;
29 with Elists; use Elists;
30 with Errout; use Errout;
31 with Exp_Atag; use Exp_Atag;
32 with Exp_Ch4; use Exp_Ch4;
33 with Exp_Ch7; use Exp_Ch7;
34 with Exp_Ch11; use Exp_Ch11;
35 with Exp_Code; use Exp_Code;
36 with Exp_Fixd; use Exp_Fixd;
37 with Exp_Util; use Exp_Util;
38 with Freeze; use Freeze;
39 with Namet; use Namet;
40 with Nmake; use Nmake;
41 with Nlists; use Nlists;
43 with Restrict; use Restrict;
44 with Rident; use Rident;
45 with Rtsfind; use Rtsfind;
47 with Sem_Eval; use Sem_Eval;
48 with Sem_Res; use Sem_Res;
49 with Sem_Type; use Sem_Type;
50 with Sem_Util; use Sem_Util;
51 with Sinfo; use Sinfo;
52 with Sinput; use Sinput;
53 with Snames; use Snames;
54 with Stand; use Stand;
55 with Stringt; use Stringt;
56 with Targparm; use Targparm;
57 with Tbuild; use Tbuild;
58 with Uintp; use Uintp;
59 with Urealp; use Urealp;
61 package body Exp_Intr is
63 -----------------------
64 -- Local Subprograms --
65 -----------------------
67 procedure Expand_Binary_Operator_Call (N : Node_Id);
68 -- Expand a call to an intrinsic arithmetic operator when the operand
69 -- types or sizes are not identical.
71 procedure Expand_Is_Negative (N : Node_Id);
72 -- Expand a call to the intrinsic Is_Negative function
74 procedure Expand_Dispatching_Constructor_Call (N : Node_Id);
75 -- Expand a call to an instantiation of Generic_Dispatching_Constructor
76 -- into a dispatching call to the actual subprogram associated with the
77 -- Constructor formal subprogram, passing it the Parameters actual of
78 -- the call to the instantiation and dispatching based on call's Tag
81 procedure Expand_Exception_Call (N : Node_Id; Ent : RE_Id);
82 -- Expand a call to Exception_Information/Message/Name. The first
83 -- parameter, N, is the node for the function call, and Ent is the
84 -- entity for the corresponding routine in the Ada.Exceptions package.
86 procedure Expand_Import_Call (N : Node_Id);
87 -- Expand a call to Import_Address/Longest_Integer/Value. The parameter
88 -- N is the node for the function call.
90 procedure Expand_Shift (N : Node_Id; E : Entity_Id; K : Node_Kind);
91 -- Expand an intrinsic shift operation, N and E are from the call to
92 -- Expand_Intrinsic_Call (call node and subprogram spec entity) and
93 -- K is the kind for the shift node
95 procedure Expand_Unc_Conversion (N : Node_Id; E : Entity_Id);
96 -- Expand a call to an instantiation of Unchecked_Conversion into a node
97 -- N_Unchecked_Type_Conversion.
99 procedure Expand_Unc_Deallocation (N : Node_Id);
100 -- Expand a call to an instantiation of Unchecked_Deallocation into a node
101 -- N_Free_Statement and appropriate context.
103 procedure Expand_To_Address (N : Node_Id);
104 procedure Expand_To_Pointer (N : Node_Id);
105 -- Expand a call to corresponding function, declared in an instance of
106 -- System.Address_To_Access_Conversions.
108 procedure Expand_Source_Info (N : Node_Id; Nam : Name_Id);
109 -- Rewrite the node by the appropriate string or positive constant.
110 -- Nam can be one of the following:
111 -- Name_File - expand string that is the name of source file
112 -- Name_Line - expand integer line number
113 -- Name_Source_Location - expand string of form file:line
114 -- Name_Enclosing_Entity - expand string with name of enclosing entity
116 ---------------------------------
117 -- Expand_Binary_Operator_Call --
118 ---------------------------------
120 procedure Expand_Binary_Operator_Call (N : Node_Id) is
121 T1 : constant Entity_Id := Underlying_Type (Etype (Left_Opnd (N)));
122 T2 : constant Entity_Id := Underlying_Type (Etype (Right_Opnd (N)));
123 TR : constant Entity_Id := Etype (N);
127 Siz : constant Uint := UI_Max (Esize (T1), Esize (T2));
128 -- Maximum of operand sizes
131 -- Nothing to do if the operands have the same modular type
133 if Base_Type (T1) = Base_Type (T2)
134 and then Is_Modular_Integer_Type (T1)
139 -- Use Unsigned_32 for sizes of 32 or below, else Unsigned_64
142 T3 := RTE (RE_Unsigned_64);
144 T3 := RTE (RE_Unsigned_32);
147 -- Copy operator node, and reset type and entity fields, for
148 -- subsequent reanalysis.
155 Set_Entity (Res, Standard_Op_And);
157 Set_Entity (Res, Standard_Op_Or);
159 Set_Entity (Res, Standard_Op_Xor);
164 -- Convert operands to large enough intermediate type
167 Unchecked_Convert_To (T3, Relocate_Node (Left_Opnd (N))));
169 Unchecked_Convert_To (T3, Relocate_Node (Right_Opnd (N))));
171 -- Analyze and resolve result formed by conversion to target type
173 Rewrite (N, Unchecked_Convert_To (TR, Res));
174 Analyze_And_Resolve (N, TR);
175 end Expand_Binary_Operator_Call;
177 -----------------------------------------
178 -- Expand_Dispatching_Constructor_Call --
179 -----------------------------------------
181 -- Transform a call to an instantiation of Generic_Dispatching_Constructor
184 -- GDC_Instance (The_Tag, Parameters'Access)
186 -- to a class-wide conversion of a dispatching call to the actual
187 -- associated with the formal subprogram Construct, designating The_Tag
188 -- as the controlling tag of the call:
190 -- T'Class (Construct'Actual (Params)) -- Controlling tag is The_Tag
192 -- which will eventually be expanded to the following:
194 -- T'Class (The_Tag.all (Construct'Actual'Index).all (Params))
196 -- A class-wide membership test is also generated, preceding the call, to
197 -- ensure that the controlling tag denotes a type in T'Class.
199 procedure Expand_Dispatching_Constructor_Call (N : Node_Id) is
200 Loc : constant Source_Ptr := Sloc (N);
201 Tag_Arg : constant Node_Id := First_Actual (N);
202 Param_Arg : constant Node_Id := Next_Actual (Tag_Arg);
203 Subp_Decl : constant Node_Id := Parent (Parent (Entity (Name (N))));
204 Inst_Pkg : constant Node_Id := Parent (Subp_Decl);
205 Act_Rename : Node_Id;
206 Act_Constr : Entity_Id;
207 Iface_Tag : Node_Id := Empty;
208 Cnstr_Call : Node_Id;
209 Result_Typ : Entity_Id;
212 -- The subprogram is the third actual in the instantiation, and is
213 -- retrieved from the corresponding renaming declaration. However,
214 -- freeze nodes may appear before, so we retrieve the declaration
215 -- with an explicit loop.
217 Act_Rename := First (Visible_Declarations (Inst_Pkg));
218 while Nkind (Act_Rename) /= N_Subprogram_Renaming_Declaration loop
222 Act_Constr := Entity (Name (Act_Rename));
223 Result_Typ := Class_Wide_Type (Etype (Act_Constr));
225 -- Ada 2005 (AI-251): If the result is an interface type, the function
226 -- returns a class-wide interface type (otherwise the resulting object
227 -- would be abstract!)
229 if Is_Interface (Etype (Act_Constr)) then
230 Set_Etype (Act_Constr, Result_Typ);
232 -- If the result type is not parent of Tag_Arg then we need to
233 -- locate the tag of the secondary dispatch table.
235 if not Is_Ancestor (Etype (Result_Typ), Etype (Tag_Arg),
236 Use_Full_View => True)
237 and then Tagged_Type_Expansion
239 -- Obtain the reference to the Ada.Tags service before generating
240 -- the Object_Declaration node to ensure that if this service is
241 -- not available in the runtime then we generate a clear error.
244 Fname : constant Node_Id :=
245 New_Reference_To (RTE (RE_Secondary_Tag), Loc);
248 pragma Assert (not Is_Interface (Etype (Tag_Arg)));
251 Make_Object_Declaration (Loc,
252 Defining_Identifier => Make_Temporary (Loc, 'V'),
254 New_Reference_To (RTE (RE_Tag), Loc),
256 Make_Function_Call (Loc,
258 Parameter_Associations => New_List (
259 Relocate_Node (Tag_Arg),
261 (Node (First_Elmt (Access_Disp_Table
262 (Etype (Etype (Act_Constr))))),
264 Insert_Action (N, Iface_Tag);
269 -- Create the call to the actual Constructor function
272 Make_Function_Call (Loc,
273 Name => New_Occurrence_Of (Act_Constr, Loc),
274 Parameter_Associations => New_List (Relocate_Node (Param_Arg)));
276 -- Establish its controlling tag from the tag passed to the instance
277 -- The tag may be given by a function call, in which case a temporary
278 -- should be generated now, to prevent out-of-order insertions during
279 -- the expansion of that call when stack-checking is enabled.
281 if Present (Iface_Tag) then
282 Set_Controlling_Argument (Cnstr_Call,
283 New_Occurrence_Of (Defining_Identifier (Iface_Tag), Loc));
285 Remove_Side_Effects (Tag_Arg);
286 Set_Controlling_Argument (Cnstr_Call,
287 Relocate_Node (Tag_Arg));
290 -- Rewrite and analyze the call to the instance as a class-wide
291 -- conversion of the call to the actual constructor.
293 Rewrite (N, Convert_To (Result_Typ, Cnstr_Call));
294 Analyze_And_Resolve (N, Etype (Act_Constr));
296 -- Do not generate a run-time check on the built object if tag
297 -- checks are suppressed for the result type or VM_Target /= No_VM
299 if Tag_Checks_Suppressed (Etype (Result_Typ))
300 or else not Tagged_Type_Expansion
304 -- Generate a class-wide membership test to ensure that the call's tag
305 -- argument denotes a type within the class. We must keep separate the
306 -- case in which the Result_Type of the constructor function is a tagged
307 -- type from the case in which it is an abstract interface because the
308 -- run-time subprogram required to check these cases differ (and have
309 -- one difference in their parameters profile).
311 -- Call CW_Membership if the Result_Type is a tagged type to look for
312 -- the tag in the table of ancestor tags.
314 elsif not Is_Interface (Result_Typ) then
316 Obj_Tag_Node : Node_Id := Duplicate_Subexpr (Tag_Arg);
317 CW_Test_Node : Node_Id;
320 Build_CW_Membership (Loc,
321 Obj_Tag_Node => Obj_Tag_Node,
324 Node (First_Elmt (Access_Disp_Table (
325 Root_Type (Result_Typ)))), Loc),
327 New_Node => CW_Test_Node);
330 Make_Implicit_If_Statement (N,
332 Make_Op_Not (Loc, CW_Test_Node),
334 New_List (Make_Raise_Statement (Loc,
335 New_Occurrence_Of (RTE (RE_Tag_Error), Loc)))));
338 -- Call IW_Membership test if the Result_Type is an abstract interface
339 -- to look for the tag in the table of interface tags.
343 Make_Implicit_If_Statement (N,
346 Make_Function_Call (Loc,
347 Name => New_Occurrence_Of (RTE (RE_IW_Membership), Loc),
348 Parameter_Associations => New_List (
349 Make_Attribute_Reference (Loc,
350 Prefix => Duplicate_Subexpr (Tag_Arg),
351 Attribute_Name => Name_Address),
354 Node (First_Elmt (Access_Disp_Table (
355 Root_Type (Result_Typ)))), Loc)))),
358 Make_Raise_Statement (Loc,
359 Name => New_Occurrence_Of (RTE (RE_Tag_Error), Loc)))));
361 end Expand_Dispatching_Constructor_Call;
363 ---------------------------
364 -- Expand_Exception_Call --
365 ---------------------------
367 -- If the function call is not within an exception handler, then the call
368 -- is replaced by a null string. Otherwise the appropriate routine in
369 -- Ada.Exceptions is called passing the choice parameter specification
370 -- from the enclosing handler. If the enclosing handler lacks a choice
371 -- parameter, then one is supplied.
373 procedure Expand_Exception_Call (N : Node_Id; Ent : RE_Id) is
374 Loc : constant Source_Ptr := Sloc (N);
379 -- Climb up parents to see if we are in exception handler
383 -- Case of not in exception handler, replace by null string
387 Make_String_Literal (Loc,
391 -- Case of in exception handler
393 elsif Nkind (P) = N_Exception_Handler then
395 -- Handler cannot be used for a local raise, and furthermore, this
396 -- is a violation of the No_Exception_Propagation restriction.
398 Set_Local_Raise_Not_OK (P);
399 Check_Restriction (No_Exception_Propagation, N);
401 -- If no choice parameter present, then put one there. Note that
402 -- we do not need to put it on the entity chain, since no one will
403 -- be referencing it by normal visibility methods.
405 if No (Choice_Parameter (P)) then
406 E := Make_Temporary (Loc, 'E');
407 Set_Choice_Parameter (P, E);
408 Set_Ekind (E, E_Variable);
409 Set_Etype (E, RTE (RE_Exception_Occurrence));
410 Set_Scope (E, Current_Scope);
414 Make_Function_Call (Loc,
415 Name => New_Occurrence_Of (RTE (Ent), Loc),
416 Parameter_Associations => New_List (
417 New_Occurrence_Of (Choice_Parameter (P), Loc))));
427 Analyze_And_Resolve (N, Standard_String);
428 end Expand_Exception_Call;
430 ------------------------
431 -- Expand_Import_Call --
432 ------------------------
434 -- The function call must have a static string as its argument. We create
435 -- a dummy variable which uses this string as the external name in an
436 -- Import pragma. The result is then obtained as the address of this
437 -- dummy variable, converted to the appropriate target type.
439 procedure Expand_Import_Call (N : Node_Id) is
440 Loc : constant Source_Ptr := Sloc (N);
441 Ent : constant Entity_Id := Entity (Name (N));
442 Str : constant Node_Id := First_Actual (N);
443 Dum : constant Entity_Id := Make_Temporary (Loc, 'D');
446 Insert_Actions (N, New_List (
447 Make_Object_Declaration (Loc,
448 Defining_Identifier => Dum,
450 New_Occurrence_Of (Standard_Character, Loc)),
453 Chars => Name_Import,
454 Pragma_Argument_Associations => New_List (
455 Make_Pragma_Argument_Association (Loc,
456 Expression => Make_Identifier (Loc, Name_Ada)),
458 Make_Pragma_Argument_Association (Loc,
459 Expression => Make_Identifier (Loc, Chars (Dum))),
461 Make_Pragma_Argument_Association (Loc,
462 Chars => Name_Link_Name,
463 Expression => Relocate_Node (Str))))));
466 Unchecked_Convert_To (Etype (Ent),
467 Make_Attribute_Reference (Loc,
468 Prefix => Make_Identifier (Loc, Chars (Dum)),
469 Attribute_Name => Name_Address)));
471 Analyze_And_Resolve (N, Etype (Ent));
472 end Expand_Import_Call;
474 ---------------------------
475 -- Expand_Intrinsic_Call --
476 ---------------------------
478 procedure Expand_Intrinsic_Call (N : Node_Id; E : Entity_Id) is
482 -- If an external name is specified for the intrinsic, it is handled
483 -- by the back-end: leave the call node unchanged for now.
485 if Present (Interface_Name (E)) then
489 -- If the intrinsic subprogram is generic, gets its original name
491 if Present (Parent (E))
492 and then Present (Generic_Parent (Parent (E)))
494 Nam := Chars (Generic_Parent (Parent (E)));
499 if Nam = Name_Asm then
502 elsif Nam = Name_Divide then
503 Expand_Decimal_Divide_Call (N);
505 elsif Nam = Name_Exception_Information then
506 Expand_Exception_Call (N, RE_Exception_Information);
508 elsif Nam = Name_Exception_Message then
509 Expand_Exception_Call (N, RE_Exception_Message);
511 elsif Nam = Name_Exception_Name then
512 Expand_Exception_Call (N, RE_Exception_Name_Simple);
514 elsif Nam = Name_Generic_Dispatching_Constructor then
515 Expand_Dispatching_Constructor_Call (N);
517 elsif Nam = Name_Import_Address
519 Nam = Name_Import_Largest_Value
521 Nam = Name_Import_Value
523 Expand_Import_Call (N);
525 elsif Nam = Name_Is_Negative then
526 Expand_Is_Negative (N);
528 elsif Nam = Name_Rotate_Left then
529 Expand_Shift (N, E, N_Op_Rotate_Left);
531 elsif Nam = Name_Rotate_Right then
532 Expand_Shift (N, E, N_Op_Rotate_Right);
534 elsif Nam = Name_Shift_Left then
535 Expand_Shift (N, E, N_Op_Shift_Left);
537 elsif Nam = Name_Shift_Right then
538 Expand_Shift (N, E, N_Op_Shift_Right);
540 elsif Nam = Name_Shift_Right_Arithmetic then
541 Expand_Shift (N, E, N_Op_Shift_Right_Arithmetic);
543 elsif Nam = Name_Unchecked_Conversion then
544 Expand_Unc_Conversion (N, E);
546 elsif Nam = Name_Unchecked_Deallocation then
547 Expand_Unc_Deallocation (N);
549 elsif Nam = Name_To_Address then
550 Expand_To_Address (N);
552 elsif Nam = Name_To_Pointer then
553 Expand_To_Pointer (N);
555 elsif Nam = Name_File
556 or else Nam = Name_Line
557 or else Nam = Name_Source_Location
558 or else Nam = Name_Enclosing_Entity
560 Expand_Source_Info (N, Nam);
562 -- If we have a renaming, expand the call to the original operation,
563 -- which must itself be intrinsic, since renaming requires matching
564 -- conventions and this has already been checked.
566 elsif Present (Alias (E)) then
567 Expand_Intrinsic_Call (N, Alias (E));
569 elsif Nkind (N) in N_Binary_Op then
570 Expand_Binary_Operator_Call (N);
572 -- The only other case is where an external name was specified,
573 -- since this is the only way that an otherwise unrecognized
574 -- name could escape the checking in Sem_Prag. Nothing needs
575 -- to be done in such a case, since we pass such a call to the
576 -- back end unchanged.
581 end Expand_Intrinsic_Call;
583 ------------------------
584 -- Expand_Is_Negative --
585 ------------------------
587 procedure Expand_Is_Negative (N : Node_Id) is
588 Loc : constant Source_Ptr := Sloc (N);
589 Opnd : constant Node_Id := Relocate_Node (First_Actual (N));
593 -- We replace the function call by the following expression
595 -- if Opnd < 0.0 then
598 -- if Opnd > 0.0 then
601 -- Float_Unsigned!(Float (Opnd)) /= 0
606 Make_Conditional_Expression (Loc,
607 Expressions => New_List (
609 Left_Opnd => Duplicate_Subexpr (Opnd),
610 Right_Opnd => Make_Real_Literal (Loc, Ureal_0)),
612 New_Occurrence_Of (Standard_True, Loc),
614 Make_Conditional_Expression (Loc,
615 Expressions => New_List (
617 Left_Opnd => Duplicate_Subexpr_No_Checks (Opnd),
618 Right_Opnd => Make_Real_Literal (Loc, Ureal_0)),
620 New_Occurrence_Of (Standard_False, Loc),
625 (RTE (RE_Float_Unsigned),
628 Duplicate_Subexpr_No_Checks (Opnd))),
630 Make_Integer_Literal (Loc, 0)))))));
632 Analyze_And_Resolve (N, Standard_Boolean);
633 end Expand_Is_Negative;
639 -- This procedure is used to convert a call to a shift function to the
640 -- corresponding operator node. This conversion is not done by the usual
641 -- circuit for converting calls to operator functions (e.g. "+"(1,2)) to
642 -- operator nodes, because shifts are not predefined operators.
644 -- As a result, whenever a shift is used in the source program, it will
645 -- remain as a call until converted by this routine to the operator node
646 -- form which Gigi is expecting to see.
648 -- Note: it is possible for the expander to generate shift operator nodes
649 -- directly, which will be analyzed in the normal manner by calling Analyze
650 -- and Resolve. Such shift operator nodes will not be seen by Expand_Shift.
652 procedure Expand_Shift (N : Node_Id; E : Entity_Id; K : Node_Kind) is
653 Loc : constant Source_Ptr := Sloc (N);
654 Typ : constant Entity_Id := Etype (N);
655 Left : constant Node_Id := First_Actual (N);
656 Right : constant Node_Id := Next_Actual (Left);
657 Ltyp : constant Node_Id := Etype (Left);
658 Rtyp : constant Node_Id := Etype (Right);
662 Snode := New_Node (K, Loc);
663 Set_Left_Opnd (Snode, Relocate_Node (Left));
664 Set_Right_Opnd (Snode, Relocate_Node (Right));
665 Set_Chars (Snode, Chars (E));
666 Set_Etype (Snode, Base_Type (Typ));
667 Set_Entity (Snode, E);
669 if Compile_Time_Known_Value (Type_High_Bound (Rtyp))
670 and then Expr_Value (Type_High_Bound (Rtyp)) < Esize (Ltyp)
672 Set_Shift_Count_OK (Snode, True);
675 -- Do the rewrite. Note that we don't call Analyze and Resolve on
676 -- this node, because it already got analyzed and resolved when
677 -- it was a function call!
683 ------------------------
684 -- Expand_Source_Info --
685 ------------------------
687 procedure Expand_Source_Info (N : Node_Id; Nam : Name_Id) is
688 Loc : constant Source_Ptr := Sloc (N);
691 procedure Write_Entity_Name (E : Entity_Id);
692 -- Recursive procedure to construct string for qualified name of
693 -- enclosing program unit. The qualification stops at an enclosing
694 -- scope has no source name (block or loop). If entity is a subprogram
695 -- instance, skip enclosing wrapper package.
697 -----------------------
698 -- Write_Entity_Name --
699 -----------------------
701 procedure Write_Entity_Name (E : Entity_Id) is
703 TDef : constant Source_Buffer_Ptr :=
704 Source_Text (Get_Source_File_Index (Sloc (E)));
707 -- Nothing to do if at outer level
709 if Scope (E) = Standard_Standard then
712 -- If scope comes from source, write its name
714 elsif Comes_From_Source (Scope (E)) then
715 Write_Entity_Name (Scope (E));
716 Add_Char_To_Name_Buffer ('.');
718 -- If in wrapper package skip past it
720 elsif Is_Wrapper_Package (Scope (E)) then
721 Write_Entity_Name (Scope (Scope (E)));
722 Add_Char_To_Name_Buffer ('.');
724 -- Otherwise nothing to output (happens in unnamed block statements)
730 -- Loop to output the name
732 -- is this right wrt wide char encodings ??? (no!)
735 while TDef (SDef) in '0' .. '9'
736 or else TDef (SDef) >= 'A'
737 or else TDef (SDef) = ASCII.ESC
739 Add_Char_To_Name_Buffer (TDef (SDef));
742 end Write_Entity_Name;
744 -- Start of processing for Expand_Source_Info
749 if Nam = Name_Line then
751 Make_Integer_Literal (Loc,
752 Intval => UI_From_Int (Int (Get_Logical_Line_Number (Loc)))));
753 Analyze_And_Resolve (N, Standard_Positive);
762 Get_Decoded_Name_String
763 (Reference_Name (Get_Source_File_Index (Loc)));
765 when Name_Source_Location =>
766 Build_Location_String (Loc);
768 when Name_Enclosing_Entity =>
770 -- Skip enclosing blocks to reach enclosing unit
772 Ent := Current_Scope;
773 while Present (Ent) loop
774 exit when Ekind (Ent) /= E_Block
775 and then Ekind (Ent) /= E_Loop;
779 -- Ent now points to the relevant defining entity
781 Write_Entity_Name (Ent);
788 Make_String_Literal (Loc,
789 Strval => String_From_Name_Buffer));
790 Analyze_And_Resolve (N, Standard_String);
793 Set_Is_Static_Expression (N);
794 end Expand_Source_Info;
796 ---------------------------
797 -- Expand_Unc_Conversion --
798 ---------------------------
800 procedure Expand_Unc_Conversion (N : Node_Id; E : Entity_Id) is
801 Func : constant Entity_Id := Entity (Name (N));
807 -- Rewrite as unchecked conversion node. Note that we must convert
808 -- the operand to the formal type of the input parameter of the
809 -- function, so that the resulting N_Unchecked_Type_Conversion
810 -- call indicates the correct types for Gigi.
812 -- Right now, we only do this if a scalar type is involved. It is
813 -- not clear if it is needed in other cases. If we do attempt to
814 -- do the conversion unconditionally, it crashes 3411-018. To be
815 -- investigated further ???
817 Conv := Relocate_Node (First_Actual (N));
818 Ftyp := Etype (First_Formal (Func));
820 if Is_Scalar_Type (Ftyp) then
821 Conv := Convert_To (Ftyp, Conv);
822 Set_Parent (Conv, N);
823 Analyze_And_Resolve (Conv);
826 -- The instantiation of Unchecked_Conversion creates a wrapper package,
827 -- and the target type is declared as a subtype of the actual. Recover
828 -- the actual, which is the subtype indic. in the subtype declaration
829 -- for the target type. This is semantically correct, and avoids
830 -- anomalies with access subtypes. For entities, leave type as is.
832 -- We do the analysis here, because we do not want the compiler
833 -- to try to optimize or otherwise reorganize the unchecked
838 if Is_Entity_Name (Conv) then
841 elsif Nkind (Parent (Ttyp)) = N_Subtype_Declaration then
842 Ttyp := Entity (Subtype_Indication (Parent (Etype (E))));
844 elsif Is_Itype (Ttyp) then
846 Entity (Subtype_Indication (Associated_Node_For_Itype (Ttyp)));
851 Rewrite (N, Unchecked_Convert_To (Ttyp, Conv));
855 if Nkind (N) = N_Unchecked_Type_Conversion then
856 Expand_N_Unchecked_Type_Conversion (N);
858 end Expand_Unc_Conversion;
860 -----------------------------
861 -- Expand_Unc_Deallocation --
862 -----------------------------
864 -- Generate the following Code :
866 -- if Arg /= null then
867 -- <Finalize_Call> (.., T'Class(Arg.all), ..); -- for controlled types
872 -- For a task, we also generate a call to Free_Task to ensure that the
873 -- task itself is freed if it is terminated, ditto for a simple protected
874 -- object, with a call to Finalize_Protection. For composite types that
875 -- have tasks or simple protected objects as components, we traverse the
876 -- structures to find and terminate those components.
878 procedure Expand_Unc_Deallocation (N : Node_Id) is
879 Arg : constant Node_Id := First_Actual (N);
880 Loc : constant Source_Ptr := Sloc (N);
881 Typ : constant Entity_Id := Etype (Arg);
882 Desig_T : constant Entity_Id := Designated_Type (Typ);
883 Rtyp : constant Entity_Id := Underlying_Type (Root_Type (Typ));
884 Pool : constant Entity_Id := Associated_Storage_Pool (Rtyp);
885 Stmts : constant List_Id := New_List;
889 Exc_Occ_Decl : Node_Id;
890 Exc_Occ_Id : Entity_Id := Empty;
891 Final_Code : List_Id;
895 Raised_Decl : Node_Id;
896 Raised_Id : Entity_Id := Empty;
898 Arg_Known_Non_Null : constant Boolean := Known_Non_Null (N);
899 -- This captures whether we know the argument to be non-null so that
900 -- we can avoid the test. The reason that we need to capture this is
901 -- that we analyze some generated statements before properly attaching
902 -- them to the tree, and that can disturb current value settings.
905 -- Nothing to do if we know the argument is null
907 if Known_Null (N) then
911 -- Processing for pointer to controlled type
913 if Needs_Finalization (Desig_T) then
915 Make_Explicit_Dereference (Loc,
916 Prefix => Duplicate_Subexpr_No_Checks (Arg));
918 -- If the type is tagged, then we must force dispatching on the
919 -- finalization call because the designated type may not be the
920 -- actual type of the object.
922 if Is_Tagged_Type (Desig_T)
923 and then not Is_Class_Wide_Type (Desig_T)
925 Deref := Unchecked_Convert_To (Class_Wide_Type (Desig_T), Deref);
927 elsif not Is_Tagged_Type (Desig_T) then
929 -- Set type of result, to force a conversion when needed (see
930 -- exp_ch7, Convert_View), given that Deep_Finalize may be
931 -- inherited from the parent type, and we need the type of the
932 -- expression to see whether the conversion is in fact needed.
934 Set_Etype (Deref, Desig_T);
937 -- The finalization call is expanded wrapped in a block to catch any
938 -- possible exception. If an exception does occur, then Program_Error
939 -- must be raised following the freeing of the object and its removal
940 -- from the finalization collection's list. We set a flag to record
941 -- that an exception was raised, and save its occurrence for use in
945 -- Raised : Boolean := False;
946 -- Exc_Occ : Exception_Occurrence;
949 -- [Deep_]Finalize (Obj);
953 -- Save_Occurrence (Exc_Occ, Get_Current_Excep.all.all);
956 Exc_Occ_Id := Make_Temporary (Loc, 'E');
957 Raised_Id := Make_Temporary (Loc, 'R');
960 Make_Object_Declaration (Loc,
961 Defining_Identifier => Raised_Id,
963 New_Reference_To (Standard_Boolean, Loc),
965 New_Reference_To (Standard_False, Loc));
967 Append_To (Stmts, Raised_Decl);
968 Analyze (Raised_Decl);
971 Make_Object_Declaration (Loc,
972 Defining_Identifier => Exc_Occ_Id,
974 New_Reference_To (RTE (RE_Exception_Occurrence), Loc));
975 Set_No_Initialization (Exc_Occ_Decl);
977 Append_To (Stmts, Exc_Occ_Decl);
978 Analyze (Exc_Occ_Decl);
980 Final_Code := New_List (
981 Make_Block_Statement (Loc,
982 Handled_Statement_Sequence =>
983 Make_Handled_Sequence_Of_Statements (Loc,
984 Statements => New_List (
988 Exception_Handlers => New_List (
989 Make_Exception_Handler (Loc,
990 Exception_Choices => New_List (
991 Make_Others_Choice (Loc)),
992 Statements => New_List (
993 Make_Assignment_Statement (Loc,
995 New_Reference_To (Raised_Id, Loc),
997 New_Reference_To (Standard_True, Loc)),
998 Make_Procedure_Call_Statement (Loc,
1000 New_Reference_To (RTE (RE_Save_Occurrence), Loc),
1001 Parameter_Associations => New_List (
1002 New_Reference_To (Exc_Occ_Id, Loc),
1003 Make_Explicit_Dereference (Loc,
1005 Make_Function_Call (Loc,
1007 Make_Explicit_Dereference (Loc,
1010 (RTE (RE_Get_Current_Excep),
1013 -- For .NET/JVM, detach the object from the containing finalization
1014 -- collection before finalizing it.
1016 if VM_Target /= No_VM
1017 and then Is_Controlled (Desig_T)
1019 Prepend_To (Final_Code,
1020 Make_Detach_Call (New_Copy_Tree (Arg)));
1023 -- If aborts are allowed, then the finalization code must be
1024 -- protected by an abort defer/undefer pair.
1026 if Abort_Allowed then
1027 Prepend_To (Final_Code,
1028 Build_Runtime_Call (Loc, RE_Abort_Defer));
1031 Make_Block_Statement (Loc, Handled_Statement_Sequence =>
1032 Make_Handled_Sequence_Of_Statements (Loc,
1033 Statements => Final_Code,
1035 New_Occurrence_Of (RTE (RE_Abort_Undefer_Direct), Loc)));
1037 -- We now expand the exception (at end) handler. We set a
1038 -- temporary parent pointer since we have not attached Blk
1041 Set_Parent (Blk, N);
1043 Expand_At_End_Handler
1044 (Handled_Statement_Sequence (Blk), Entity (Identifier (Blk)));
1045 Append (Blk, Stmts);
1047 -- We kill saved current values, since analyzing statements not
1048 -- properly attached to the tree can set wrong current values.
1050 Kill_Current_Values;
1053 Append_List_To (Stmts, Final_Code);
1057 -- For a task type, call Free_Task before freeing the ATCB
1059 if Is_Task_Type (Desig_T) then
1061 Stat : Node_Id := Prev (N);
1066 -- An Abort followed by a Free will not do what the user
1067 -- expects, because the abort is not immediate. This is
1068 -- worth a friendly warning.
1070 while Present (Stat)
1071 and then not Comes_From_Source (Original_Node (Stat))
1077 and then Nkind (Original_Node (Stat)) = N_Abort_Statement
1079 Stat := Original_Node (Stat);
1080 Nam1 := First (Names (Stat));
1081 Nam2 := Original_Node (First (Parameter_Associations (N)));
1083 if Nkind (Nam1) = N_Explicit_Dereference
1084 and then Is_Entity_Name (Prefix (Nam1))
1085 and then Is_Entity_Name (Nam2)
1086 and then Entity (Prefix (Nam1)) = Entity (Nam2)
1088 Error_Msg_N ("abort may take time to complete?", N);
1089 Error_Msg_N ("\deallocation might have no effect?", N);
1090 Error_Msg_N ("\safer to wait for termination.?", N);
1096 (Stmts, Cleanup_Task (N, Duplicate_Subexpr_No_Checks (Arg)));
1098 -- For composite types that contain tasks, recurse over the structure
1099 -- to build the selectors for the task subcomponents.
1101 elsif Has_Task (Desig_T) then
1102 if Is_Record_Type (Desig_T) then
1103 Append_List_To (Stmts, Cleanup_Record (N, Arg, Desig_T));
1105 elsif Is_Array_Type (Desig_T) then
1106 Append_List_To (Stmts, Cleanup_Array (N, Arg, Desig_T));
1110 -- Same for simple protected types. Eventually call Finalize_Protection
1111 -- before freeing the PO for each protected component.
1113 if Is_Simple_Protected_Type (Desig_T) then
1115 Cleanup_Protected_Object (N, Duplicate_Subexpr_No_Checks (Arg)));
1117 elsif Has_Simple_Protected_Object (Desig_T) then
1118 if Is_Record_Type (Desig_T) then
1119 Append_List_To (Stmts, Cleanup_Record (N, Arg, Desig_T));
1120 elsif Is_Array_Type (Desig_T) then
1121 Append_List_To (Stmts, Cleanup_Array (N, Arg, Desig_T));
1125 -- Normal processing for non-controlled types
1127 Free_Arg := Duplicate_Subexpr_No_Checks (Arg);
1128 Free_Node := Make_Free_Statement (Loc, Empty);
1129 Append_To (Stmts, Free_Node);
1130 Set_Storage_Pool (Free_Node, Pool);
1132 -- Attach to tree before analysis of generated subtypes below.
1134 Set_Parent (Stmts, Parent (N));
1136 -- Deal with storage pool
1138 if Present (Pool) then
1140 -- Freeing the secondary stack is meaningless
1142 if Is_RTE (Pool, RE_SS_Pool) then
1145 elsif Is_Class_Wide_Type (Etype (Pool)) then
1147 -- Case of a class-wide pool type: make a dispatching call
1148 -- to Deallocate through the class-wide Deallocate_Any.
1150 Set_Procedure_To_Call (Free_Node,
1151 RTE (RE_Deallocate_Any));
1154 -- Case of a specific pool type: make a statically bound call
1156 Set_Procedure_To_Call (Free_Node,
1157 Find_Prim_Op (Etype (Pool), Name_Deallocate));
1161 if Present (Procedure_To_Call (Free_Node)) then
1163 -- For all cases of a Deallocate call, the back-end needs to be
1164 -- able to compute the size of the object being freed. This may
1165 -- require some adjustments for objects of dynamic size.
1167 -- If the type is class wide, we generate an implicit type with the
1168 -- right dynamic size, so that the deallocate call gets the right
1169 -- size parameter computed by GIGI. Same for an access to
1170 -- unconstrained packed array.
1172 if Is_Class_Wide_Type (Desig_T)
1174 (Is_Array_Type (Desig_T)
1175 and then not Is_Constrained (Desig_T)
1176 and then Is_Packed (Desig_T))
1179 Deref : constant Node_Id :=
1180 Make_Explicit_Dereference (Loc,
1181 Duplicate_Subexpr_No_Checks (Arg));
1186 Set_Etype (Deref, Typ);
1187 Set_Parent (Deref, Free_Node);
1188 D_Subtyp := Make_Subtype_From_Expr (Deref, Desig_T);
1190 if Nkind (D_Subtyp) in N_Has_Entity then
1191 D_Type := Entity (D_Subtyp);
1194 D_Type := Make_Temporary (Loc, 'A');
1195 Insert_Action (Deref,
1196 Make_Subtype_Declaration (Loc,
1197 Defining_Identifier => D_Type,
1198 Subtype_Indication => D_Subtyp));
1201 -- Force freezing at the point of the dereference. For the
1202 -- class wide case, this avoids having the subtype frozen
1203 -- before the equivalent type.
1205 Freeze_Itype (D_Type, Deref);
1207 Set_Actual_Designated_Subtype (Free_Node, D_Type);
1213 -- Ada 2005 (AI-251): In case of abstract interface type we must
1214 -- displace the pointer to reference the base of the object to
1215 -- deallocate its memory, unless we're targetting a VM, in which case
1216 -- no special processing is required.
1219 -- free (Base_Address (Obj_Ptr))
1221 if Is_Interface (Directly_Designated_Type (Typ))
1222 and then Tagged_Type_Expansion
1224 Set_Expression (Free_Node,
1225 Unchecked_Convert_To (Typ,
1226 Make_Function_Call (Loc,
1227 Name => New_Reference_To (RTE (RE_Base_Address), Loc),
1228 Parameter_Associations => New_List (
1229 Unchecked_Convert_To (RTE (RE_Address), Free_Arg)))));
1235 Set_Expression (Free_Node, Free_Arg);
1238 -- Only remaining step is to set result to null, or generate a
1239 -- raise of constraint error if the target object is "not null".
1241 if Can_Never_Be_Null (Etype (Arg)) then
1243 Make_Raise_Constraint_Error (Loc,
1244 Reason => CE_Access_Check_Failed));
1248 Lhs : constant Node_Id := Duplicate_Subexpr_No_Checks (Arg);
1250 Set_Assignment_OK (Lhs);
1252 Make_Assignment_Statement (Loc,
1254 Expression => Make_Null (Loc)));
1258 -- Generate a test of whether any earlier finalization raised an
1259 -- exception, and in that case raise Program_Error with the previous
1260 -- exception occurrence.
1264 -- Reraise_Occurrence (Exc_Occ); -- for .NET
1266 -- Raise_From_Controlled_Operation (Exc_Occ); -- all other cases
1269 if Present (Raised_Id) then
1270 Append_To (Stmts, Build_Raise_Statement (Loc, Exc_Occ_Id, Raised_Id));
1273 -- If we know the argument is non-null, then make a block statement
1274 -- that contains the required statements, no need for a test.
1276 if Arg_Known_Non_Null then
1278 Make_Block_Statement (Loc,
1279 Handled_Statement_Sequence =>
1280 Make_Handled_Sequence_Of_Statements (Loc,
1281 Statements => Stmts));
1283 -- If the argument may be null, wrap the statements inside an IF that
1284 -- does an explicit test to exclude the null case.
1288 Make_Implicit_If_Statement (N,
1291 Left_Opnd => Duplicate_Subexpr (Arg),
1292 Right_Opnd => Make_Null (Loc)),
1293 Then_Statements => Stmts);
1298 Rewrite (N, Gen_Code);
1300 end Expand_Unc_Deallocation;
1302 -----------------------
1303 -- Expand_To_Address --
1304 -----------------------
1306 procedure Expand_To_Address (N : Node_Id) is
1307 Loc : constant Source_Ptr := Sloc (N);
1308 Arg : constant Node_Id := First_Actual (N);
1312 Remove_Side_Effects (Arg);
1314 Obj := Make_Explicit_Dereference (Loc, Relocate_Node (Arg));
1317 Make_Conditional_Expression (Loc,
1318 Expressions => New_List (
1320 Left_Opnd => New_Copy_Tree (Arg),
1321 Right_Opnd => Make_Null (Loc)),
1322 New_Occurrence_Of (RTE (RE_Null_Address), Loc),
1323 Make_Attribute_Reference (Loc,
1325 Attribute_Name => Name_Address))));
1327 Analyze_And_Resolve (N, RTE (RE_Address));
1328 end Expand_To_Address;
1330 -----------------------
1331 -- Expand_To_Pointer --
1332 -----------------------
1334 procedure Expand_To_Pointer (N : Node_Id) is
1335 Arg : constant Node_Id := First_Actual (N);
1338 Rewrite (N, Unchecked_Convert_To (Etype (N), Arg));
1340 end Expand_To_Pointer;