1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1996-2004 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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
25 ------------------------------------------------------------------------------
27 with Alloc
; use Alloc
;
28 with Atree
; use Atree
;
29 with Debug
; use Debug
;
30 with Einfo
; use Einfo
;
31 with Namet
; use Namet
;
32 with Nlists
; use Nlists
;
33 with Nmake
; use Nmake
;
35 with Output
; use Output
;
36 with Sem_Eval
; use Sem_Eval
;
37 with Sem_Util
; use Sem_Util
;
38 with Sinfo
; use Sinfo
;
39 with Snames
; use Snames
;
40 with Stand
; use Stand
;
41 with Stringt
; use Stringt
;
43 with Urealp
; use Urealp
;
45 package body Exp_Dbug
is
47 -- The following table is used to queue up the entities passed as
48 -- arguments to Qualify_Entity_Names for later processing when
49 -- Qualify_All_Entity_Names is called.
51 package Name_Qualify_Units
is new Table
.Table
(
52 Table_Component_Type
=> Node_Id
,
53 Table_Index_Type
=> Nat
,
55 Table_Initial
=> Alloc
.Name_Qualify_Units_Initial
,
56 Table_Increment
=> Alloc
.Name_Qualify_Units_Increment
,
57 Table_Name
=> "Name_Qualify_Units");
59 --------------------------------
60 -- Use of Qualification Flags --
61 --------------------------------
63 -- There are two flags used to keep track of qualification of entities
65 -- Has_Fully_Qualified_Name
68 -- The difference between these is as follows. Has_Qualified_Name is
69 -- set to indicate that the name has been qualified as required by the
70 -- spec of this package. As described there, this may involve the full
71 -- qualification for the name, but for some entities, notably procedure
72 -- local variables, this full qualification is not required.
74 -- The flag Has_Fully_Qualified_Name is set if indeed the name has been
75 -- fully qualified in the Ada sense. If Has_Fully_Qualified_Name is set,
76 -- then Has_Qualified_Name is also set, but the other way round is not
79 -- Consider the following example:
86 -- Here B is a procedure local variable, so it does not need fully
87 -- qualification. The flag Has_Qualified_Name will be set on the
88 -- first attempt to qualify B, to indicate that the job is done
89 -- and need not be redone.
91 -- But Y is qualified as x__y, since procedures are always fully
92 -- qualified, so the first time that an attempt is made to qualify
93 -- the name y, it will be replaced by x__y, and both flags are set.
95 -- Why the two flags? Well there are cases where we derive type names
96 -- from object names. As noted in the spec, type names are always
97 -- fully qualified. Suppose for example that the backend has to build
98 -- a padded type for variable B. then it will construct the PAD name
99 -- from B, but it requires full qualification, so the fully qualified
100 -- type name will be x__b___PAD. The two flags allow the circuit for
101 -- building this name to realize efficiently that b needs further
108 -- The string defined here (and its associated length) is used to
109 -- gather the homonym string that will be appended to Name_Buffer
110 -- when the name is complete. Strip_Suffixes appends to this string
111 -- as does Append_Homonym_Number, and Output_Homonym_Numbers_Suffix
112 -- appends the string to the end of Name_Buffer.
114 Homonym_Numbers
: String (1 .. 256);
115 Homonym_Len
: Natural := 0;
117 ----------------------
118 -- Local Procedures --
119 ----------------------
121 procedure Add_Uint_To_Buffer
(U
: Uint
);
122 -- Add image of universal integer to Name_Buffer, updating Name_Len
124 procedure Add_Real_To_Buffer
(U
: Ureal
);
125 -- Add nnn_ddd to Name_Buffer, where nnn and ddd are integer values of
126 -- the normalized numerator and denominator of the given real value.
128 procedure Append_Homonym_Number
(E
: Entity_Id
);
129 -- If the entity E has homonyms in the same scope, then make an entry
130 -- in the Homonym_Numbers array, bumping Homonym_Count accordingly.
132 function Bounds_Match_Size
(E
: Entity_Id
) return Boolean;
133 -- Determine whether the bounds of E match the size of the type. This is
134 -- used to determine whether encoding is required for a discrete type.
136 procedure Output_Homonym_Numbers_Suffix
;
137 -- If homonym numbers are stored, then output them into Name_Buffer.
139 procedure Prepend_String_To_Buffer
(S
: String);
140 -- Prepend given string to the contents of the string buffer, updating
141 -- the value in Name_Len (i.e. string is added at start of buffer).
143 procedure Prepend_Uint_To_Buffer
(U
: Uint
);
144 -- Prepend image of universal integer to Name_Buffer, updating Name_Len
146 procedure Qualify_Entity_Name
(Ent
: Entity_Id
);
147 -- If not already done, replaces the Chars field of the given entity
148 -- with the appropriate fully qualified name.
150 procedure Strip_Suffixes
(BNPE_Suffix_Found
: in out Boolean);
151 -- Given an qualified entity name in Name_Buffer, remove any plain X or
152 -- X{nb} qualification suffix. The contents of Name_Buffer is not changed
153 -- but Name_Len may be adjusted on return to remove the suffix. If a
154 -- BNPE suffix is found and stripped, then BNPE_Suffix_Found is set to
155 -- True. If no suffix is found, then BNPE_Suffix_Found is not modified.
156 -- This routine also searches for a homonym suffix, and if one is found
157 -- it is also stripped, and the entries are added to the global homonym
158 -- list (Homonym_Numbers) so that they can later be put back.
160 ------------------------
161 -- Add_Real_To_Buffer --
162 ------------------------
164 procedure Add_Real_To_Buffer
(U
: Ureal
) is
166 Add_Uint_To_Buffer
(Norm_Num
(U
));
167 Add_Str_To_Name_Buffer
("_");
168 Add_Uint_To_Buffer
(Norm_Den
(U
));
169 end Add_Real_To_Buffer
;
171 ------------------------
172 -- Add_Uint_To_Buffer --
173 ------------------------
175 procedure Add_Uint_To_Buffer
(U
: Uint
) is
178 Add_Uint_To_Buffer
(-U
);
179 Add_Char_To_Name_Buffer
('m');
181 UI_Image
(U
, Decimal
);
182 Add_Str_To_Name_Buffer
(UI_Image_Buffer
(1 .. UI_Image_Length
));
184 end Add_Uint_To_Buffer
;
186 ---------------------------
187 -- Append_Homonym_Number --
188 ---------------------------
190 procedure Append_Homonym_Number
(E
: Entity_Id
) is
192 procedure Add_Nat_To_H
(Nr
: Nat
);
193 -- Little procedure to append Nr to Homonym_Numbers
199 procedure Add_Nat_To_H
(Nr
: Nat
) is
202 Add_Nat_To_H
(Nr
/ 10);
205 Homonym_Len
:= Homonym_Len
+ 1;
206 Homonym_Numbers
(Homonym_Len
) :=
207 Character'Val (Nr
mod 10 + Character'Pos ('0'));
210 -- Start of processing for Append_Homonym_Number
213 if Has_Homonym
(E
) then
215 H
: Entity_Id
:= Homonym
(E
);
219 while Present
(H
) loop
220 if Scope
(H
) = Scope
(E
) then
227 if Homonym_Len
> 0 then
228 Homonym_Len
:= Homonym_Len
+ 1;
229 Homonym_Numbers
(Homonym_Len
) := '_';
235 end Append_Homonym_Number
;
237 -----------------------
238 -- Bounds_Match_Size --
239 -----------------------
241 function Bounds_Match_Size
(E
: Entity_Id
) return Boolean is
245 if not Is_OK_Static_Subtype
(E
) then
248 elsif Is_Integer_Type
(E
)
249 and then Subtypes_Statically_Match
(E
, Base_Type
(E
))
253 -- Here we check if the static bounds match the natural size, which
254 -- is the size passed through with the debugging information. This
255 -- is the Esize rounded up to 8, 16, 32 or 64 as appropriate.
259 Umark
: constant Uintp
.Save_Mark
:= Uintp
.Mark
;
263 if Esize
(E
) <= 8 then
265 elsif Esize
(E
) <= 16 then
267 elsif Esize
(E
) <= 32 then
273 if Is_Modular_Integer_Type
(E
) or else Is_Enumeration_Type
(E
) then
275 Expr_Rep_Value
(Type_Low_Bound
(E
)) = 0
277 2 ** Siz
- Expr_Rep_Value
(Type_High_Bound
(E
)) = 1;
281 Expr_Rep_Value
(Type_Low_Bound
(E
)) + 2 ** (Siz
- 1) = 0
283 2 ** (Siz
- 1) - Expr_Rep_Value
(Type_High_Bound
(E
)) = 1;
290 end Bounds_Match_Size
;
292 --------------------------------
293 -- Debug_Renaming_Declaration --
294 --------------------------------
296 function Debug_Renaming_Declaration
(N
: Node_Id
) return Node_Id
is
297 Loc
: constant Source_Ptr
:= Sloc
(N
);
298 Ent
: constant Node_Id
:= Defining_Entity
(N
);
299 Nam
: constant Node_Id
:= Name
(N
);
307 function Output_Subscript
(N
: Node_Id
; S
: String) return Boolean;
308 -- Outputs a single subscript value as ?nnn (subscript is compile
309 -- time known value with value nnn) or as ?e (subscript is local
310 -- constant with name e), where S supplies the proper string to
311 -- use for ?. Returns False if the subscript is not of an appropriate
312 -- type to output in one of these two forms. The result is prepended
313 -- to the name stored in Name_Buffer.
315 ----------------------
316 -- Output_Subscript --
317 ----------------------
319 function Output_Subscript
(N
: Node_Id
; S
: String) return Boolean is
321 if Compile_Time_Known_Value
(N
) then
322 Prepend_Uint_To_Buffer
(Expr_Value
(N
));
324 elsif Nkind
(N
) = N_Identifier
325 and then Scope
(Entity
(N
)) = Scope
(Ent
)
326 and then Ekind
(Entity
(N
)) = E_Constant
328 Prepend_String_To_Buffer
(Get_Name_String
(Chars
(Entity
(N
))));
334 Prepend_String_To_Buffer
(S
);
336 end Output_Subscript
;
338 -- Start of processing for Debug_Renaming_Declaration
341 if not Comes_From_Source
(N
)
342 and then not Needs_Debug_Info
(Ent
)
347 -- Prepare entity name for type declaration
349 Get_Name_String
(Chars
(Ent
));
352 when N_Object_Renaming_Declaration
=>
353 Add_Str_To_Name_Buffer
("___XR");
355 when N_Exception_Renaming_Declaration
=>
356 Add_Str_To_Name_Buffer
("___XRE");
358 when N_Package_Renaming_Declaration
=>
359 Add_Str_To_Name_Buffer
("___XRP");
361 -- If it is a child unit create a fully qualified name,
362 -- to disambiguate multiple child units with the same
363 -- name and different parents.
365 if Is_Child_Unit
(Ent
) then
366 Prepend_String_To_Buffer
("__");
367 Prepend_String_To_Buffer
368 (Get_Name_String
(Chars
(Scope
(Ent
))));
377 -- Get renamed entity and compute suffix
387 when N_Expanded_Name
=>
389 -- The entity field for an N_Expanded_Name is on the
390 -- expanded name node itself, so we are done here too.
394 when N_Selected_Component
=>
395 Prepend_String_To_Buffer
396 (Get_Name_String
(Chars
(Selector_Name
(Ren
))));
397 Prepend_String_To_Buffer
("XR");
400 when N_Indexed_Component
=>
402 X
: Node_Id
:= Last
(Expressions
(Ren
));
405 while Present
(X
) loop
406 if not Output_Subscript
(X
, "XS") then
407 Set_Materialize_Entity
(Ent
);
419 Typ
:= Etype
(First_Index
(Etype
(Nam
)));
421 if not Output_Subscript
(Type_High_Bound
(Typ
), "XS") then
422 Set_Materialize_Entity
(Ent
);
426 if not Output_Subscript
(Type_Low_Bound
(Typ
), "XL") then
427 Set_Materialize_Entity
(Ent
);
433 when N_Explicit_Dereference
=>
434 Prepend_String_To_Buffer
("XA");
437 -- For now, anything else simply results in no translation
440 Set_Materialize_Entity
(Ent
);
445 Prepend_String_To_Buffer
("___XE");
447 -- For now, the literal name contains only the suffix. The Entity_Id
448 -- value for the name is used to create a link from this literal name
449 -- to the renamed entity using the Debug_Renaming_Link field. Then the
450 -- Qualify_Entity_Name procedure uses this link to create the proper
451 -- fully qualified name.
453 -- The reason we do things this way is that we really need to copy the
454 -- qualification of the renamed entity, and it is really much easier to
455 -- do this after the renamed entity has itself been fully qualified.
457 Lit
:= Make_Defining_Identifier
(Loc
, Chars
=> Name_Enter
);
458 Set_Debug_Renaming_Link
(Lit
, Entity
(Ren
));
460 -- Return the appropriate enumeration type
462 Def
:= Make_Defining_Identifier
(Loc
, Chars
=> Rnm
);
464 Make_Full_Type_Declaration
(Loc
,
465 Defining_Identifier
=> Def
,
467 Make_Enumeration_Type_Definition
(Loc
,
468 Literals
=> New_List
(Lit
)));
470 Set_Needs_Debug_Info
(Def
);
471 Set_Needs_Debug_Info
(Lit
);
473 Set_Discard_Names
(Defining_Identifier
(Res
));
476 -- If we get an exception, just figure it is a case that we cannot
477 -- successfully handle using our current approach, since this is
478 -- only for debugging, no need to take the compilation with us!
482 return Make_Null_Statement
(Loc
);
483 end Debug_Renaming_Declaration
;
485 ----------------------
486 -- Get_Encoded_Name --
487 ----------------------
489 -- Note: see spec for details on encodings
491 procedure Get_Encoded_Name
(E
: Entity_Id
) is
492 Has_Suffix
: Boolean;
495 Get_Name_String
(Chars
(E
));
497 -- Nothing to do if we do not have a type
501 -- Or if this is an enumeration base type
503 or else (Is_Enumeration_Type
(E
)
504 and then E
= Base_Type
(E
))
506 -- Or if this is a dummy type for a renaming
508 or else (Name_Len
>= 3 and then
509 Name_Buffer
(Name_Len
- 2 .. Name_Len
) = "_XR")
511 or else (Name_Len
>= 4 and then
512 (Name_Buffer
(Name_Len
- 3 .. Name_Len
) = "_XRE"
514 Name_Buffer
(Name_Len
- 3 .. Name_Len
) = "_XRP"))
516 -- For all these cases, just return the name unchanged
519 Name_Buffer
(Name_Len
+ 1) := ASCII
.Nul
;
527 if Is_Fixed_Point_Type
(E
) then
528 Get_External_Name_With_Suffix
(E
, "XF_");
529 Add_Real_To_Buffer
(Delta_Value
(E
));
531 if Small_Value
(E
) /= Delta_Value
(E
) then
532 Add_Str_To_Name_Buffer
("_");
533 Add_Real_To_Buffer
(Small_Value
(E
));
536 -- Vax floating-point case
538 elsif Vax_Float
(E
) then
540 if Digits_Value
(Base_Type
(E
)) = 6 then
541 Get_External_Name_With_Suffix
(E
, "XFF");
543 elsif Digits_Value
(Base_Type
(E
)) = 9 then
544 Get_External_Name_With_Suffix
(E
, "XFF");
547 pragma Assert
(Digits_Value
(Base_Type
(E
)) = 15);
548 Get_External_Name_With_Suffix
(E
, "XFG");
551 -- Discrete case where bounds do not match size
553 elsif Is_Discrete_Type
(E
)
554 and then not Bounds_Match_Size
(E
)
556 if Has_Biased_Representation
(E
) then
557 Get_External_Name_With_Suffix
(E
, "XB");
559 Get_External_Name_With_Suffix
(E
, "XD");
563 Lo
: constant Node_Id
:= Type_Low_Bound
(E
);
564 Hi
: constant Node_Id
:= Type_High_Bound
(E
);
566 Lo_Con
: constant Boolean := Compile_Time_Known_Value
(Lo
);
567 Hi_Con
: constant Boolean := Compile_Time_Known_Value
(Hi
);
569 Lo_Discr
: constant Boolean :=
570 Nkind
(Lo
) = N_Identifier
572 Ekind
(Entity
(Lo
)) = E_Discriminant
;
574 Hi_Discr
: constant Boolean :=
575 Nkind
(Hi
) = N_Identifier
577 Ekind
(Entity
(Hi
)) = E_Discriminant
;
579 Lo_Encode
: constant Boolean := Lo_Con
or Lo_Discr
;
580 Hi_Encode
: constant Boolean := Hi_Con
or Hi_Discr
;
583 if Lo_Encode
or Hi_Encode
then
586 Add_Str_To_Name_Buffer
("LU_");
588 Add_Str_To_Name_Buffer
("L_");
591 Add_Str_To_Name_Buffer
("U_");
595 Add_Uint_To_Buffer
(Expr_Rep_Value
(Lo
));
597 Get_Name_String_And_Append
(Chars
(Entity
(Lo
)));
600 if Lo_Encode
and Hi_Encode
then
601 Add_Str_To_Name_Buffer
("__");
605 Add_Uint_To_Buffer
(Expr_Rep_Value
(Hi
));
607 Get_Name_String_And_Append
(Chars
(Entity
(Hi
)));
612 -- For all other cases, the encoded name is the normal type name
616 Get_External_Name
(E
, Has_Suffix
);
619 if Debug_Flag_B
and then Has_Suffix
then
620 Write_Str
("**** type ");
621 Write_Name
(Chars
(E
));
622 Write_Str
(" is encoded as ");
623 Write_Str
(Name_Buffer
(1 .. Name_Len
));
627 Name_Buffer
(Name_Len
+ 1) := ASCII
.NUL
;
628 end Get_Encoded_Name
;
630 -----------------------
631 -- Get_External_Name --
632 -----------------------
634 procedure Get_External_Name
(Entity
: Entity_Id
; Has_Suffix
: Boolean)
636 E
: Entity_Id
:= Entity
;
639 procedure Get_Qualified_Name_And_Append
(Entity
: Entity_Id
);
640 -- Appends fully qualified name of given entity to Name_Buffer
642 -----------------------------------
643 -- Get_Qualified_Name_And_Append --
644 -----------------------------------
646 procedure Get_Qualified_Name_And_Append
(Entity
: Entity_Id
) is
648 -- If the entity is a compilation unit, its scope is Standard,
649 -- there is no outer scope, and the no further qualification
652 -- If the front end has already computed a fully qualified name,
653 -- then it is also the case that no further qualification is
656 if Present
(Scope
(Scope
(Entity
)))
657 and then not Has_Fully_Qualified_Name
(Entity
)
659 Get_Qualified_Name_And_Append
(Scope
(Entity
));
660 Add_Str_To_Name_Buffer
("__");
661 Get_Name_String_And_Append
(Chars
(Entity
));
662 Append_Homonym_Number
(Entity
);
665 Get_Name_String_And_Append
(Chars
(Entity
));
668 end Get_Qualified_Name_And_Append
;
670 -- Start of processing for Get_External_Name
675 -- If this is a child unit, we want the child
677 if Nkind
(E
) = N_Defining_Program_Unit_Name
then
678 E
:= Defining_Identifier
(Entity
);
683 -- Case of interface name being used
685 if (Kind
= E_Procedure
or else
686 Kind
= E_Function
or else
687 Kind
= E_Constant
or else
688 Kind
= E_Variable
or else
690 and then Present
(Interface_Name
(E
))
691 and then No
(Address_Clause
(E
))
692 and then not Has_Suffix
694 Add_String_To_Name_Buffer
(Strval
(Interface_Name
(E
)));
696 -- All other cases besides the interface name case
699 -- If this is a library level subprogram (i.e. a subprogram that is a
700 -- compilation unit other than a subunit), then we prepend _ada_ to
701 -- ensure distinctions required as described in the spec.
702 -- Check explicitly for child units, because those are not flagged
703 -- as Compilation_Units by lib. Should they be ???
706 and then (Is_Compilation_Unit
(E
) or Is_Child_Unit
(E
))
707 and then not Has_Suffix
709 Add_Str_To_Name_Buffer
("_ada_");
712 -- If the entity is a subprogram instance that is not a compilation
713 -- unit, generate the name of the original Ada entity, which is the
716 if Is_Generic_Instance
(E
)
717 and then Is_Subprogram
(E
)
718 and then not Is_Compilation_Unit
(Scope
(E
))
719 and then (Ekind
(Scope
(E
)) = E_Package
721 Ekind
(Scope
(E
)) = E_Package_Body
)
722 and then Present
(Related_Instance
(Scope
(E
)))
724 E
:= Related_Instance
(Scope
(E
));
727 Get_Qualified_Name_And_Append
(E
);
730 Name_Buffer
(Name_Len
+ 1) := ASCII
.Nul
;
731 end Get_External_Name
;
733 -----------------------------------
734 -- Get_External_Name_With_Suffix --
735 -----------------------------------
737 procedure Get_External_Name_With_Suffix
741 Has_Suffix
: constant Boolean := (Suffix
/= "");
742 use type Opt
.Operating_Mode_Type
;
745 if Opt
.Operating_Mode
/= Opt
.Generate_Code
then
747 -- If we are not in code generation mode, we still may call this
748 -- procedure from Back_End (more specifically - from gigi for doing
749 -- type representation annotation or some representation-specific
750 -- checks). But in this mode there is no need to mess with external
751 -- names. Furthermore, the call causes difficulties in this case
752 -- because the string representing the homonym number is not
753 -- correctly reset as a part of the call to
754 -- Output_Homonym_Numbers_Suffix (which is not called in gigi)
759 Get_External_Name
(Entity
, Has_Suffix
);
762 Add_Str_To_Name_Buffer
("___");
763 Add_Str_To_Name_Buffer
(Suffix
);
765 Name_Buffer
(Name_Len
+ 1) := ASCII
.Nul
;
767 end Get_External_Name_With_Suffix
;
769 --------------------------
770 -- Get_Variant_Encoding --
771 --------------------------
773 procedure Get_Variant_Encoding
(V
: Node_Id
) is
776 procedure Choice_Val
(Typ
: Character; Choice
: Node_Id
);
777 -- Output encoded value for a single choice value. Typ is the key
778 -- character ('S', 'F', or 'T') that precedes the choice value.
784 procedure Choice_Val
(Typ
: Character; Choice
: Node_Id
) is
786 Add_Char_To_Name_Buffer
(Typ
);
788 if Nkind
(Choice
) = N_Integer_Literal
then
789 Add_Uint_To_Buffer
(Intval
(Choice
));
791 -- Character literal with no entity present (this is the case
792 -- Standard.Character or Standard.Wide_Character as root type)
794 elsif Nkind
(Choice
) = N_Character_Literal
795 and then No
(Entity
(Choice
))
798 (UI_From_Int
(Int
(Char_Literal_Value
(Choice
))));
802 Ent
: constant Entity_Id
:= Entity
(Choice
);
805 if Ekind
(Ent
) = E_Enumeration_Literal
then
806 Add_Uint_To_Buffer
(Enumeration_Rep
(Ent
));
809 pragma Assert
(Ekind
(Ent
) = E_Constant
);
810 Choice_Val
(Typ
, Constant_Value
(Ent
));
816 -- Start of processing for Get_Variant_Encoding
821 Choice
:= First
(Discrete_Choices
(V
));
822 while Present
(Choice
) loop
823 if Nkind
(Choice
) = N_Others_Choice
then
824 Add_Char_To_Name_Buffer
('O');
826 elsif Nkind
(Choice
) = N_Range
then
827 Choice_Val
('R', Low_Bound
(Choice
));
828 Choice_Val
('T', High_Bound
(Choice
));
830 elsif Is_Entity_Name
(Choice
)
831 and then Is_Type
(Entity
(Choice
))
833 Choice_Val
('R', Type_Low_Bound
(Entity
(Choice
)));
834 Choice_Val
('T', Type_High_Bound
(Entity
(Choice
)));
836 elsif Nkind
(Choice
) = N_Subtype_Indication
then
838 Rang
: constant Node_Id
:=
839 Range_Expression
(Constraint
(Choice
));
841 Choice_Val
('R', Low_Bound
(Rang
));
842 Choice_Val
('T', High_Bound
(Rang
));
846 Choice_Val
('S', Choice
);
852 Name_Buffer
(Name_Len
+ 1) := ASCII
.NUL
;
856 VP
: constant Node_Id
:= Parent
(V
); -- Variant_Part
857 CL
: constant Node_Id
:= Parent
(VP
); -- Component_List
858 RD
: constant Node_Id
:= Parent
(CL
); -- Record_Definition
859 FT
: constant Node_Id
:= Parent
(RD
); -- Full_Type_Declaration
862 Write_Str
("**** variant for type ");
863 Write_Name
(Chars
(Defining_Identifier
(FT
)));
864 Write_Str
(" is encoded as ");
865 Write_Str
(Name_Buffer
(1 .. Name_Len
));
869 end Get_Variant_Encoding
;
871 ---------------------------------
872 -- Make_Packed_Array_Type_Name --
873 ---------------------------------
875 function Make_Packed_Array_Type_Name
881 Get_Name_String
(Chars
(Typ
));
882 Add_Str_To_Name_Buffer
("___XP");
883 Add_Uint_To_Buffer
(Csize
);
885 end Make_Packed_Array_Type_Name
;
887 -----------------------------------
888 -- Output_Homonym_Numbers_Suffix --
889 -----------------------------------
891 procedure Output_Homonym_Numbers_Suffix
is
895 if Homonym_Len
> 0 then
897 -- Check for all 1's, in which case we do not output
901 exit when Homonym_Numbers
(J
) /= '1';
903 -- If we reached end of string we do not output
905 if J
= Homonym_Len
then
910 exit when Homonym_Numbers
(J
+ 1) /= '_';
914 -- If we exit the loop then suffix must be output
916 Add_Str_To_Name_Buffer
("__");
917 Add_Str_To_Name_Buffer
(Homonym_Numbers
(1 .. Homonym_Len
));
920 end Output_Homonym_Numbers_Suffix
;
922 ------------------------------
923 -- Prepend_String_To_Buffer --
924 ------------------------------
926 procedure Prepend_String_To_Buffer
(S
: String) is
927 N
: constant Integer := S
'Length;
929 Name_Buffer
(1 + N
.. Name_Len
+ N
) := Name_Buffer
(1 .. Name_Len
);
930 Name_Buffer
(1 .. N
) := S
;
931 Name_Len
:= Name_Len
+ N
;
932 end Prepend_String_To_Buffer
;
934 ----------------------------
935 -- Prepend_Uint_To_Buffer --
936 ----------------------------
938 procedure Prepend_Uint_To_Buffer
(U
: Uint
) is
941 Prepend_String_To_Buffer
("m");
942 Prepend_Uint_To_Buffer
(-U
);
944 UI_Image
(U
, Decimal
);
945 Prepend_String_To_Buffer
(UI_Image_Buffer
(1 .. UI_Image_Length
));
947 end Prepend_Uint_To_Buffer
;
949 ------------------------------
950 -- Qualify_All_Entity_Names --
951 ------------------------------
953 procedure Qualify_All_Entity_Names
is
958 for J
in Name_Qualify_Units
.First
.. Name_Qualify_Units
.Last
loop
959 E
:= Defining_Entity
(Name_Qualify_Units
.Table
(J
));
960 Qualify_Entity_Name
(E
);
962 Ent
:= First_Entity
(E
);
963 while Present
(Ent
) loop
964 Qualify_Entity_Name
(Ent
);
967 -- There are odd cases where Last_Entity (E) = E. This happens
968 -- in the case of renaming of packages. This test avoids getting
969 -- stuck in such cases.
974 end Qualify_All_Entity_Names
;
976 -------------------------
977 -- Qualify_Entity_Name --
978 -------------------------
980 procedure Qualify_Entity_Name
(Ent
: Entity_Id
) is
982 Full_Qualify_Name
: String (1 .. Name_Buffer
'Length);
983 Full_Qualify_Len
: Natural := 0;
984 -- Used to accumulate fully qualified name of subprogram
986 procedure Fully_Qualify_Name
(E
: Entity_Id
);
987 -- Used to qualify a subprogram or type name, where full
988 -- qualification up to Standard is always used. Name is set
989 -- in Full_Qualify_Name with the length in Full_Qualify_Len.
990 -- Note that this routine does not prepend the _ada_ string
991 -- required for library subprograms (this is done in the back end).
993 function Is_BNPE
(S
: Entity_Id
) return Boolean;
994 -- Determines if S is a BNPE, i.e. Body-Nested Package Entity, which
995 -- is defined to be a package which is immediately nested within a
998 function Qualify_Needed
(S
: Entity_Id
) return Boolean;
999 -- Given a scope, determines if the scope is to be included in the
1000 -- fully qualified name, True if so, False if not.
1002 procedure Set_BNPE_Suffix
(E
: Entity_Id
);
1003 -- Recursive routine to append the BNPE qualification suffix. Works
1004 -- from right to left with E being the current entity in the list.
1005 -- The result does NOT have the trailing n's and trailing b stripped.
1006 -- The caller must do this required stripping.
1008 procedure Set_Entity_Name
(E
: Entity_Id
);
1009 -- Internal recursive routine that does most of the work. This routine
1010 -- leaves the result sitting in Name_Buffer and Name_Len.
1012 BNPE_Suffix_Needed
: Boolean := False;
1013 -- Set true if a body-nested package entity suffix is required
1015 Save_Chars
: constant Name_Id
:= Chars
(Ent
);
1016 -- Save original name
1018 ------------------------
1019 -- Fully_Qualify_Name --
1020 ------------------------
1022 procedure Fully_Qualify_Name
(E
: Entity_Id
) is
1023 Discard
: Boolean := False;
1026 -- Ignore empty entry (can happen in error cases)
1031 -- If this we are qualifying entities local to a generic
1032 -- instance, use the name of the original instantiation,
1033 -- not that of the anonymous subprogram in the wrapper
1034 -- package, so that gdb doesn't have to know about these.
1036 elsif Is_Generic_Instance
(E
)
1037 and then Is_Subprogram
(E
)
1038 and then not Comes_From_Source
(E
)
1039 and then not Is_Compilation_Unit
(Scope
(E
))
1041 Fully_Qualify_Name
(Related_Instance
(Scope
(E
)));
1045 -- If we reached fully qualified name, then just copy it
1047 if Has_Fully_Qualified_Name
(E
) then
1048 Get_Name_String
(Chars
(E
));
1049 Strip_Suffixes
(Discard
);
1050 Full_Qualify_Name
(1 .. Name_Len
) := Name_Buffer
(1 .. Name_Len
);
1051 Full_Qualify_Len
:= Name_Len
;
1052 Set_Has_Fully_Qualified_Name
(Ent
);
1054 -- Case of non-fully qualified name
1057 if Scope
(E
) = Standard_Standard
then
1058 Set_Has_Fully_Qualified_Name
(Ent
);
1060 Fully_Qualify_Name
(Scope
(E
));
1061 Full_Qualify_Name
(Full_Qualify_Len
+ 1) := '_';
1062 Full_Qualify_Name
(Full_Qualify_Len
+ 2) := '_';
1063 Full_Qualify_Len
:= Full_Qualify_Len
+ 2;
1066 if Has_Qualified_Name
(E
) then
1067 Get_Unqualified_Name_String
(Chars
(E
));
1069 Get_Name_String
(Chars
(E
));
1072 -- A special check here, we never add internal block or loop
1073 -- names, since they intefere with debugging. We identify these
1074 -- by the fact that they start with an upper case B or L.
1075 -- But do add these if what we are qualifying is a __clean
1076 -- procedure since those need to be made unique.
1078 if (Name_Buffer
(1) = 'B' or else Name_Buffer
(1) = 'L')
1079 and then (not Debug_Flag_VV
)
1080 and then Full_Qualify_Len
> 2
1081 and then Chars
(Ent
) /= Name_uClean
1083 Full_Qualify_Len
:= Full_Qualify_Len
- 2;
1087 (Full_Qualify_Len
+ 1 .. Full_Qualify_Len
+ Name_Len
) :=
1088 Name_Buffer
(1 .. Name_Len
);
1089 Full_Qualify_Len
:= Full_Qualify_Len
+ Name_Len
;
1090 Append_Homonym_Number
(E
);
1095 BNPE_Suffix_Needed
:= True;
1097 end Fully_Qualify_Name
;
1103 function Is_BNPE
(S
: Entity_Id
) return Boolean is
1106 Ekind
(S
) = E_Package
1107 and then Is_Package_Body_Entity
(S
);
1110 --------------------
1111 -- Qualify_Needed --
1112 --------------------
1114 function Qualify_Needed
(S
: Entity_Id
) return Boolean is
1116 -- If we got all the way to Standard, then we have certainly
1117 -- fully qualified the name, so set the flag appropriately,
1118 -- and then return False, since we are most certainly done!
1120 if S
= Standard_Standard
then
1121 Set_Has_Fully_Qualified_Name
(Ent
, True);
1124 -- Otherwise figure out if further qualification is required
1130 Ekind
(Ent
) = E_Subprogram_Body
1132 (Ekind
(S
) /= E_Block
1133 and then not Is_Dynamic_Scope
(S
));
1137 ---------------------
1138 -- Set_BNPE_Suffix --
1139 ---------------------
1141 procedure Set_BNPE_Suffix
(E
: Entity_Id
) is
1142 S
: constant Entity_Id
:= Scope
(E
);
1145 if Qualify_Needed
(S
) then
1146 Set_BNPE_Suffix
(S
);
1149 Add_Char_To_Name_Buffer
('b');
1151 Add_Char_To_Name_Buffer
('n');
1155 Add_Char_To_Name_Buffer
('X');
1158 end Set_BNPE_Suffix
;
1160 ---------------------
1161 -- Set_Entity_Name --
1162 ---------------------
1164 procedure Set_Entity_Name
(E
: Entity_Id
) is
1165 S
: constant Entity_Id
:= Scope
(E
);
1168 -- If we reach an already qualified name, just take the encoding
1169 -- except that we strip the package body suffixes, since these
1170 -- will be separately put on later.
1172 if Has_Qualified_Name
(E
) then
1173 Get_Name_String_And_Append
(Chars
(E
));
1174 Strip_Suffixes
(BNPE_Suffix_Needed
);
1176 -- If the top level name we are adding is itself fully
1177 -- qualified, then that means that the name that we are
1178 -- preparing for the Fully_Qualify_Name call will also
1179 -- generate a fully qualified name.
1181 if Has_Fully_Qualified_Name
(E
) then
1182 Set_Has_Fully_Qualified_Name
(Ent
);
1185 -- Case where upper level name is not encoded yet
1188 -- Recurse if further qualification required
1190 if Qualify_Needed
(S
) then
1191 Set_Entity_Name
(S
);
1192 Add_Str_To_Name_Buffer
("__");
1195 -- Otherwise get name and note if it is a NPBE
1197 Get_Name_String_And_Append
(Chars
(E
));
1200 BNPE_Suffix_Needed
:= True;
1203 Append_Homonym_Number
(E
);
1205 end Set_Entity_Name
;
1207 -- Start of processing for Qualify_Entity_Name
1210 if Has_Qualified_Name
(Ent
) then
1213 -- Here is where we create the proper link for renaming
1215 elsif Ekind
(Ent
) = E_Enumeration_Literal
1216 and then Present
(Debug_Renaming_Link
(Ent
))
1219 Qualify_Entity_Name
(Debug_Renaming_Link
(Ent
));
1220 Get_Name_String
(Chars
(Ent
));
1221 Prepend_String_To_Buffer
1222 (Get_Name_String
(Chars
(Debug_Renaming_Link
(Ent
))));
1223 Set_Chars
(Ent
, Name_Enter
);
1224 Set_Has_Qualified_Name
(Ent
);
1227 elsif Is_Subprogram
(Ent
)
1228 or else Ekind
(Ent
) = E_Subprogram_Body
1229 or else Is_Type
(Ent
)
1231 Fully_Qualify_Name
(Ent
);
1232 Name_Len
:= Full_Qualify_Len
;
1233 Name_Buffer
(1 .. Name_Len
) := Full_Qualify_Name
(1 .. Name_Len
);
1235 elsif Qualify_Needed
(Scope
(Ent
)) then
1237 Set_Entity_Name
(Ent
);
1240 Set_Has_Qualified_Name
(Ent
);
1244 -- Fall through with a fully qualified name in Name_Buffer/Name_Len
1246 Output_Homonym_Numbers_Suffix
;
1248 -- Add body-nested package suffix if required
1250 if BNPE_Suffix_Needed
1251 and then Ekind
(Ent
) /= E_Enumeration_Literal
1253 Set_BNPE_Suffix
(Ent
);
1255 -- Strip trailing n's and last trailing b as required. note that
1256 -- we know there is at least one b, or no suffix would be generated.
1258 while Name_Buffer
(Name_Len
) = 'n' loop
1259 Name_Len
:= Name_Len
- 1;
1262 Name_Len
:= Name_Len
- 1;
1265 Set_Chars
(Ent
, Name_Enter
);
1266 Set_Has_Qualified_Name
(Ent
);
1268 if Debug_Flag_BB
then
1270 Write_Name
(Save_Chars
);
1271 Write_Str
(" qualified as ");
1272 Write_Name
(Chars
(Ent
));
1275 end Qualify_Entity_Name
;
1277 --------------------------
1278 -- Qualify_Entity_Names --
1279 --------------------------
1281 procedure Qualify_Entity_Names
(N
: Node_Id
) is
1283 Name_Qualify_Units
.Append
(N
);
1284 end Qualify_Entity_Names
;
1286 --------------------
1287 -- Strip_Suffixes --
1288 --------------------
1290 procedure Strip_Suffixes
(BNPE_Suffix_Found
: in out Boolean) is
1294 -- Search for and strip BNPE suffix
1296 for J
in reverse 2 .. Name_Len
loop
1297 if Name_Buffer
(J
) = 'X' then
1299 BNPE_Suffix_Found
:= True;
1303 exit when Name_Buffer
(J
) /= 'b' and then Name_Buffer
(J
) /= 'n';
1306 -- Search for and strip homonym numbers suffix
1308 for J
in reverse 2 .. Name_Len
- 2 loop
1309 if Name_Buffer
(J
) = '_'
1310 and then Name_Buffer
(J
+ 1) = '_'
1312 if Name_Buffer
(J
+ 2) in '0' .. '9' then
1313 if Homonym_Len
> 0 then
1314 Homonym_Len
:= Homonym_Len
+ 1;
1315 Homonym_Numbers
(Homonym_Len
) := '-';
1318 SL
:= Name_Len
- (J
+ 1);
1320 Homonym_Numbers
(Homonym_Len
+ 1 .. Homonym_Len
+ SL
) :=
1321 Name_Buffer
(J
+ 2 .. Name_Len
);
1323 Homonym_Len
:= Homonym_Len
+ SL
;