gcc/ada/exp_ch8.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                              E X P _ C H 8                               --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2001 Free Software Foundation, Inc.          --
  10 --                                                                          --
  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.                                                      --
  21 --                                                                          --
  22 -- GNAT was originally developed  by the GNAT team at  New York University. --
  23 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  24 --                                                                          --
  25 ------------------------------------------------------------------------------
  26
  27 with Atree;    use Atree;
  28 with Einfo;    use Einfo;
  29 with Exp_Dbug; use Exp_Dbug;
  30 with Exp_Util; use Exp_Util;
  31 with Nlists;   use Nlists;
  32 with Sem;      use Sem;
  33 with Sem_Ch8;  use Sem_Ch8;
  34 with Sinfo;    use Sinfo;
  35 with Stand;    use Stand;
  36
  37 package body Exp_Ch8 is
  38
  39    ---------------------------------------------
  40    -- Expand_N_Exception_Renaming_Declaration --
  41    ---------------------------------------------
  42
  43    procedure Expand_N_Exception_Renaming_Declaration (N : Node_Id) is
  44       Decl : constant Node_Id := Debug_Renaming_Declaration (N);
  45
  46    begin
  47       if Present (Decl) then
  48          Insert_Action (N, Decl);
  49       end if;
  50    end Expand_N_Exception_Renaming_Declaration;
  51
  52    ------------------------------------------
  53    -- Expand_N_Object_Renaming_Declaration --
  54    ------------------------------------------
  55
  56    --  Most object renaming cases can be done by just capturing the address
  57    --  of the renamed object. The cases in which this is not true are when
  58    --  this address is not computable, since it involves extraction of a
  59    --  packed array element, or of a record component to which a component
  60    --  clause applies (that can specify an arbitrary bit boundary), or where
  61    --  the enclosing record itself has a non-standard representation.
  62
  63    --  In these two cases, we pre-evaluate the renaming expression, by
  64    --  extracting and freezing the values of any subscripts, and then we
  65    --  set the flag Is_Renaming_Of_Object which means that any reference
  66    --  to the object will be handled by macro substitution in the front
  67    --  end, and the back end will know to ignore the renaming declaration.
  68
  69    --  An additional odd case that requires processing by expansion is
  70    --  the renaming of a discriminant of a mutable record type. The object
  71    --  is a constant because it renames something that cannot be assigned to,
  72    --  but in fact the underlying value can change and must be reevaluated
  73    --  at each reference. Gigi does have a notion of a "constant view" of
  74    --  an object, and therefore the front-end must perform the expansion.
  75    --  For simplicity, and to bypass some obscure code-generation problem,
  76    --  we use macro substitution for all renamed discriminants, whether the
  77    --  enclosing type is constrained or not.
  78
  79    --  The other special processing required is for the case of renaming
  80    --  of an object of a class wide type, where it is necessary to build
  81    --  the appropriate subtype for the renamed object.
  82    --  More comments needed for this para ???
  83
  84    procedure Expand_N_Object_Renaming_Declaration (N : Node_Id) is
  85       Nam  : Node_Id := Name (N);
  86       T    : Entity_Id;
  87       Decl : Node_Id;
  88
  89       procedure Evaluate_Name (Fname : Node_Id);
  90       --  A recursive procedure used to freeze a name in the sense described
  91       --  above, i.e. any variable references or function calls are removed.
  92       --  Of course the outer level variable reference must not be removed.
  93       --  For example in A(J,F(K)), A is left as is, but J and F(K) are
  94       --  evaluated and removed.
  95
  96       function Evaluation_Required (Nam : Node_Id) return Boolean;
  97       --  Determines whether it is necessary to do static name evaluation
  98       --  for renaming of Nam. It is considered necessary if evaluating the
  99       --  name involves indexing a packed array, or extracting a component
 100       --  of a record to which a component clause applies. Note that we are
 101       --  only interested in these operations if they occur as part of the
 102       --  name itself, subscripts are just values that are computed as part
 103       --  of the evaluation, so their form is unimportant.
 104
 105       -------------------
 106       -- Evaluate_Name --
 107       -------------------
 108
 109       procedure Evaluate_Name (Fname : Node_Id) is
 110          K : constant Node_Kind := Nkind (Fname);
 111          E : Node_Id;
 112
 113       begin
 114          --  For an explicit dereference, we simply force the evaluation
 115          --  of the name expression. The dereference provides a value that
 116          --  is the address for the renamed object, and it is precisely
 117          --  this value that we want to preserve.
 118
 119          if K = N_Explicit_Dereference then
 120             Force_Evaluation (Prefix (Fname));
 121
 122          --  For a selected component, we simply evaluate the prefix
 123
 124          elsif K = N_Selected_Component then
 125             Evaluate_Name (Prefix (Fname));
 126
 127          --  For an indexed component, or an attribute reference, we evaluate
 128          --  the prefix, which is itself a name, recursively, and then force
 129          --  the evaluation of all the subscripts (or attribute expressions).
 130
 131          elsif K = N_Indexed_Component
 132            or else K = N_Attribute_Reference
 133          then
 134             Evaluate_Name (Prefix (Fname));
 135
 136             E := First (Expressions (Fname));
 137             while Present (E) loop
 138                Force_Evaluation (E);
 139
 140                if Original_Node (E) /= E then
 141                   Set_Do_Range_Check (E, Do_Range_Check (Original_Node (E)));
 142                end if;
 143
 144                Next (E);
 145             end loop;
 146
 147          --  For a slice, we evaluate the prefix, as for the indexed component
 148          --  case and then, if there is a range present, either directly or
 149          --  as the constraint of a discrete subtype indication, we evaluate
 150          --  the two bounds of this range.
 151
 152          elsif K = N_Slice then
 153             Evaluate_Name (Prefix (Fname));
 154
 155             declare
 156                DR     : constant Node_Id := Discrete_Range (Fname);
 157                Constr : Node_Id;
 158                Rexpr  : Node_Id;
 159
 160             begin
 161                if Nkind (DR) = N_Range then
 162                   Force_Evaluation (Low_Bound (DR));
 163                   Force_Evaluation (High_Bound (DR));
 164
 165                elsif Nkind (DR) = N_Subtype_Indication then
 166                   Constr := Constraint (DR);
 167
 168                   if Nkind (Constr) = N_Range_Constraint then
 169                      Rexpr := Range_Expression (Constr);
 170
 171                      Force_Evaluation (Low_Bound (Rexpr));
 172                      Force_Evaluation (High_Bound (Rexpr));
 173                   end if;
 174                end if;
 175             end;
 176
 177          --  For a type conversion, the expression of the conversion must be
 178          --  the name of an object, and we simply need to evaluate this name.
 179
 180          elsif K = N_Type_Conversion then
 181             Evaluate_Name (Expression (Fname));
 182
 183          --  For a function call, we evaluate the call.
 184
 185          elsif K = N_Function_Call then
 186             Force_Evaluation (Fname);
 187
 188          --  The remaining cases are direct name, operator symbol and
 189          --  character literal. In all these cases, we do nothing, since
 190          --  we want to reevaluate each time the renamed object is used.
 191
 192          else
 193             return;
 194          end if;
 195       end Evaluate_Name;
 196
 197       -------------------------
 198       -- Evaluation_Required --
 199       -------------------------
 200
 201       function Evaluation_Required (Nam : Node_Id) return Boolean is
 202       begin
 203          if Nkind (Nam) = N_Indexed_Component
 204            or else Nkind (Nam) = N_Slice
 205          then
 206             if Is_Packed (Etype (Prefix (Nam))) then
 207                return True;
 208             else
 209                return Evaluation_Required (Prefix (Nam));
 210             end if;
 211
 212          elsif Nkind (Nam) = N_Selected_Component then
 213             declare
 214                Rec_Type : Entity_Id := Etype (Prefix (Nam));
 215
 216             begin
 217                if Present (Component_Clause (Entity (Selector_Name (Nam))))
 218                  or else Has_Non_Standard_Rep (Rec_Type)
 219                then
 220                   return True;
 221
 222                elsif Ekind (Entity (Selector_Name (Nam))) = E_Discriminant
 223                  and then Is_Record_Type (Rec_Type)
 224                  and then not Is_Concurrent_Record_Type (Rec_Type)
 225                then
 226                   return True;
 227
 228                else
 229                   return Evaluation_Required (Prefix (Nam));
 230                end if;
 231             end;
 232
 233          else
 234             return False;
 235          end if;
 236       end Evaluation_Required;
 237
 238    --  Start of processing for Expand_N_Object_Renaming_Declaration
 239
 240    begin
 241       --  Perform name evaluation if required
 242
 243       if Evaluation_Required (Nam) then
 244          Evaluate_Name (Nam);
 245          Set_Is_Renaming_Of_Object (Defining_Identifier (N));
 246       end if;
 247
 248       --  Deal with construction of subtype in class-wide case
 249
 250       T := Etype (Defining_Identifier (N));
 251
 252       if Is_Class_Wide_Type (T) then
 253          Expand_Subtype_From_Expr (N, T, Subtype_Mark (N), Name (N));
 254          Find_Type (Subtype_Mark (N));
 255          Set_Etype (Defining_Identifier (N), Entity (Subtype_Mark (N)));
 256       end if;
 257
 258       --  Create renaming entry for debug information
 259
 260       Decl := Debug_Renaming_Declaration (N);
 261
 262       if Present (Decl) then
 263          Insert_Action (N, Decl);
 264       end if;
 265    end Expand_N_Object_Renaming_Declaration;
 266
 267    -------------------------------------------
 268    -- Expand_N_Package_Renaming_Declaration --
 269    -------------------------------------------
 270
 271    procedure Expand_N_Package_Renaming_Declaration (N : Node_Id) is
 272       Decl : constant Node_Id := Debug_Renaming_Declaration (N);
 273
 274    begin
 275       if Present (Decl) then
 276
 277          --  If we are in a compilation unit, then this is an outer
 278          --  level declaration, and must have a scope of Standard
 279
 280          if Nkind (Parent (N)) = N_Compilation_Unit then
 281             declare
 282                Aux : constant Node_Id := Aux_Decls_Node (Parent (N));
 283
 284             begin
 285                New_Scope (Standard_Standard);
 286
 287                if No (Actions (Aux)) then
 288                   Set_Actions (Aux, New_List (Decl));
 289                else
 290                   Append (Decl, Actions (Aux));
 291                end if;
 292
 293                Analyze (Decl);
 294                Pop_Scope;
 295             end;
 296
 297          --  Otherwise, just insert after the package declaration
 298
 299          else
 300             Insert_Action (N, Decl);
 301          end if;
 302       end if;
 303    end Expand_N_Package_Renaming_Declaration;
 304
 305 end Exp_Ch8;