Skip to content

R
riscv-gcc-1
Commit 25859971 by Gary Dismukes Committed by Arnaud Charlet
Options

exp_ch8.adb (Expand_N_Package_Renaming_Declaration): In the case of a… 

exp_ch8.adb (Expand_N_Package_Renaming_Declaration): In the case of a library-level package renaming...

2007-08-31  Gary Dismukes  <dismukes@adacore.com>

	* exp_ch8.adb (Expand_N_Package_Renaming_Declaration): In the case of a
	library-level package renaming, pass the declaration associated with
	the renaming's special debug variable to Qualify_Entity_Names to ensure
	that its encoded name is properly qualified.

	* exp_dbug.adb (Qualify_All_Entity_Names): Check for a variable entity
	occurring in the list of entities to qualify, and do not attempt to
	traverse an entity list in that case. Variables associated with
`	library-level package renamings can now occur in the table.

	* exp_dbug.ads: Revise documentation of the encoding for renaming
	declarations.

From-SVN: r127973
parent 55d4e6c0
Showing with 56 additions and 36 deletions
gcc/ada/exp_ch8.adb
......@@ -319,6 +319,14 @@ package body Exp_Ch8 is
end if;
Analyze (Decl);
-- Enter the debug variable in the qualification list, which
-- must be done at this point because auxiliary declarations
-- occur at the library level and aren't associated with a
-- normal scope.
Qualify_Entity_Names (Decl);
Pop_Scope;
end;
......
gcc/ada/exp_dbug.adb
......@@ -1011,17 +1011,25 @@ package body Exp_Dbug is
E := Defining_Entity (Name_Qualify_Units.Table (J));
Qualify_Entity_Name (E);
-- Normally entities in the qualification list are scopes, but in the
-- case of a library-level package renaming there is an associated
-- variable that encodes the debugger name and that variable is
-- entered in the list since it occurs in the Aux_Decls list of the
-- compilation and doesn't have a normal scope.
if Ekind (E) /= E_Variable then
Ent := First_Entity (E);
while Present (Ent) loop
Qualify_Entity_Name (Ent);
Next_Entity (Ent);
-- There are odd cases where Last_Entity (E) = E. This happens
-- in the case of renaming of packages. This test avoids getting
-- stuck in such cases.
-- in the case of renaming of packages. This test avoids
-- getting stuck in such cases.
exit when Ent = E;
end loop;
end if;
end loop;
end Qualify_All_Entity_Names;
......
gcc/ada/exp_dbug.ads
......@@ -603,8 +603,7 @@ package Exp_Dbug is
-- for most debugging formats. However, we do not ever need XD
-- encoding for enumeration base types, since here it is always
-- clear what the bounds are from the total number of enumeration
-- literals, and of course we do not need to encode the dummy XR
-- types generated for renamings.
-- literals.
-- typ___XD
-- typ___XDL_lowerbound
......@@ -969,20 +968,23 @@ package Exp_Dbug is
-- Consider a renaming declaration of the form
-- x typ renames y;
-- x : typ renames y;
-- There is one case in which no special debugging information is required,
-- namely the case of an object renaming where the backend allocates a
-- namely the case of an object renaming where the back end allocates a
-- reference for the renamed variable, and the entity x is this reference.
-- The debugger can handle this case without any special processing or
-- encoding (it won't know it was a renaming, but that does not matter).
-- All other cases of renaming generate a dummy type definition for
-- an entity whose name is:
-- All other cases of renaming generate a dummy variable for an entity
-- whose name is of the form:
-- x___XR for an object renaming
-- x___XRE for an exception renaming
-- x___XRP for a package renaming
-- x___XR_... for an object renaming
-- x___XRE_... for an exception renaming
-- x___XRP_... for a package renaming
-- and where the "..." represents a suffix that describes the structure of
-- the object name given in the renaming (see details below).
-- The name is fully qualified in the usual manner, i.e. qualified in the
-- same manner as the entity x would be. In the case of a package renaming
......@@ -992,24 +994,24 @@ package Exp_Dbug is
-- Note: subprogram renamings are not encoded at the present time
-- The type is an enumeration type with a single enumeration literal
-- that is an identifier which describes the renamed variable.
-- The suffix of the variable name describing the renamed object is
-- defined to use the following encoding:
-- For the simple entity case, where y is an entity name,
-- the enumeration is of the form:
-- For the simple entity case, where y is just an entity name, the suffix
-- is of the form:
-- (y___XE)
-- y___XE
-- i.e. the enumeration type has a single field, whose name matches
-- the name y, with the XE suffix. The entity for this enumeration
-- literal is fully qualified in the usual manner. All subprogram,
-- exception, and package renamings fall into this category, as
-- well as simple object renamings.
-- i.e. the suffix has a single field, the first part matching the
-- name y, followed by a "___" separator, ending with sequence XE.
-- The entity name portion is fully qualified in the usual manner.
-- This same naming scheme is followed for all forms of encoded
-- renamings that rename a simple entity.
-- For the object renaming case where y is a selected component or an
-- indexed component, the literal name is suffixed by additional fields
-- indexed component, the variable name is suffixed by additional fields
-- that give details of the components. The name starts as above with a
-- y___XE entity indicating the outer level variable. Then a series of
-- y___XE name indicating the outer level object entity. Then a series of
-- selections and indexing operations can be specified as follows:
-- Indexed component
......@@ -1020,20 +1022,19 @@ package Exp_Dbug is
-- XSnnn
-- Here nnn is a constant value, encoded as a decimal
-- integer (pos value for enumeration type case). Negative
-- values have a trailing 'm' as usual.
-- Here nnn is a constant value, encoded as a decimal integer
-- (pos value for enumeration type case). Negative values have
-- a trailing 'm' as usual.
-- XSe
-- Here e is the (unqualified) name of a constant entity in
-- the same scope as the renaming which contains the subscript
-- value.
-- Here e is the (unqualified) name of a constant entity in the
-- same scope as the renaming which contains the subscript value.
-- Slice
-- For the slice case, we have two entries. The first is for the
-- lower bound of the slice, and has the form
-- lower bound of the slice, and has the form:
-- XLnnn
-- XLe
......@@ -1069,10 +1070,9 @@ package Exp_Dbug is
-- z : string renames g (1,5).m(2 ..3)
-- end p;
-- The generated type definition would appear as
-- The generated variable entity would appear as
-- type p__z___XR is
-- (p__g___XEXS1XS5XRmXL2XS3);
-- p__z___XR_p__g___XEXS1XS5XRmXL2XS3 : _renaming_type;
-- p__g___XE--------------------outer entity is g
-- XS1-----------------first subscript for g
-- XS5--------------second subscript for g
......@@ -1080,10 +1080,14 @@ package Exp_Dbug is
-- XL2--------lower bound of slice
-- XS3-----upper bound of slice
-- Note that the type of the variable is a special internal type named
-- _renaming_type. This type is an arbitrary type of zero size created
-- in package Standard (see cstand.adb) and is ignored by the debugger.
function Debug_Renaming_Declaration (N : Node_Id) return Node_Id;
-- The argument N is a renaming declaration. The result is a type
-- declaration as described in the above paragraphs. If not special
-- debug declaration, than Empty is returned.
-- The argument N is a renaming declaration. The result is a variable
-- declaration as described in the above paragraphs. If N is not a special
-- debug declaration, then Empty is returned.
---------------------------
-- Packed Array Encoding --
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment