Subversion Repositories openrisc_me

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                             S E M _ C H 1 3                              --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2009, 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 Errout;   use Errout;

with Exp_Tss;  use Exp_Tss;

with Exp_Util; use Exp_Util;

with Lib;      use Lib;

with Lib.Xref; use Lib.Xref;

with Namet;    use Namet;

with Nlists;   use Nlists;

with Nmake;    use Nmake;

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_Ch3;  use Sem_Ch3;

with Sem_Ch8;  use Sem_Ch8;

with Sem_Eval; use Sem_Eval;

with Sem_Res;  use Sem_Res;

with Sem_Type; use Sem_Type;

with Sem_Util; use Sem_Util;

with Sem_Warn; use Sem_Warn;

with Snames;   use Snames;

with Stand;    use Stand;

with Sinfo;    use Sinfo;

with Table;

with Targparm; use Targparm;

with Ttypes;   use Ttypes;

with Tbuild;   use Tbuild;

with Urealp;   use Urealp;

with GNAT.Heap_Sort_G;

package body Sem_Ch13 is

   SSU : constant Pos := System_Storage_Unit;

   --  Convenient short hand for commonly used constant

   -----------------------

   -- Local Subprograms --

   -----------------------

   procedure Alignment_Check_For_Esize_Change (Typ : Entity_Id);

   --  This routine is called after setting the Esize of type entity Typ.

   --  The purpose is to deal with the situation where an alignment has been

   --  inherited from a derived type that is no longer appropriate for the

   --  new Esize value. In this case, we reset the Alignment to unknown.

   procedure Check_Component_Overlap (C1_Ent, C2_Ent : Entity_Id);

   --  Given two entities for record components or discriminants, checks

   --  if they have overlapping component clauses and issues errors if so.

   function Get_Alignment_Value (Expr : Node_Id) return Uint;

   --  Given the expression for an alignment value, returns the corresponding

   --  Uint value. If the value is inappropriate, then error messages are

   --  posted as required, and a value of No_Uint is returned.

   function Is_Operational_Item (N : Node_Id) return Boolean;

   --  A specification for a stream attribute is allowed before the full

   --  type is declared, as explained in AI-00137 and the corrigendum.

   --  Attributes that do not specify a representation characteristic are

   --  operational attributes.

   procedure New_Stream_Subprogram

     (N    : Node_Id;

      Ent  : Entity_Id;

      Subp : Entity_Id;

      Nam  : TSS_Name_Type);

   --  Create a subprogram renaming of a given stream attribute to the

   --  designated subprogram and then in the tagged case, provide this as a

   --  primitive operation, or in the non-tagged case make an appropriate TSS

   --  entry. This is more properly an expansion activity than just semantics,

   --  but the presence of user-defined stream functions for limited types is a

   --  legality check, which is why this takes place here rather than in

   --  exp_ch13, where it was previously. Nam indicates the name of the TSS

   --  function to be generated.

   --

   --  To avoid elaboration anomalies with freeze nodes, for untagged types

   --  we generate both a subprogram declaration and a subprogram renaming

   --  declaration, so that the attribute specification is handled as a

   --  renaming_as_body. For tagged types, the specification is one of the

   --  primitive specs.

   ----------------------------------------------

   -- Table for Validate_Unchecked_Conversions --

   ----------------------------------------------

   --  The following table collects unchecked conversions for validation.

   --  Entries are made by Validate_Unchecked_Conversion and then the

   --  call to Validate_Unchecked_Conversions does the actual error

   --  checking and posting of warnings. The reason for this delayed

   --  processing is to take advantage of back-annotations of size and

   --  alignment values performed by the back end.

   --  Note: the reason we store a Source_Ptr value instead of a Node_Id

   --  is that by the time Validate_Unchecked_Conversions is called, Sprint

   --  will already have modified all Sloc values if the -gnatD option is set.

   type UC_Entry is record

      Eloc   : Source_Ptr; -- node used for posting warnings

      Source : Entity_Id;  -- source type for unchecked conversion

      Target : Entity_Id;  -- target type for unchecked conversion

   end record;

   package Unchecked_Conversions is new Table.Table (

     Table_Component_Type => UC_Entry,

     Table_Index_Type     => Int,

     Table_Low_Bound      => 1,

     Table_Initial        => 50,

     Table_Increment      => 200,

     Table_Name           => "Unchecked_Conversions");

   ----------------------------------------

   -- Table for Validate_Address_Clauses --

   ----------------------------------------

   --  If an address clause has the form

   --    for X'Address use Expr

   --  where Expr is of the form Y'Address or recursively is a reference

   --  to a constant of either of these forms, and X and Y are entities of

   --  objects, then if Y has a smaller alignment than X, that merits a

   --  warning about possible bad alignment. The following table collects

   --  address clauses of this kind. We put these in a table so that they

   --  can be checked after the back end has completed annotation of the

   --  alignments of objects, since we can catch more cases that way.

   type Address_Clause_Check_Record is record

      N : Node_Id;

      --  The address clause

      X : Entity_Id;

      --  The entity of the object overlaying Y

      Y : Entity_Id;

      --  The entity of the object being overlaid

      Off : Boolean;

      --  Whether the address is offseted within Y

   end record;

   package Address_Clause_Checks is new Table.Table (

     Table_Component_Type => Address_Clause_Check_Record,

     Table_Index_Type     => Int,

     Table_Low_Bound      => 1,

     Table_Initial        => 20,

     Table_Increment      => 200,

     Table_Name           => "Address_Clause_Checks");

   -----------------------------------------

   -- Adjust_Record_For_Reverse_Bit_Order --

   -----------------------------------------

   procedure Adjust_Record_For_Reverse_Bit_Order (R : Entity_Id) is

      Max_Machine_Scalar_Size : constant Uint :=

                                  UI_From_Int

                                    (Standard_Long_Long_Integer_Size);

      --  We use this as the maximum machine scalar size in the sense of AI-133

      Num_CC : Natural;

      Comp   : Entity_Id;

      SSU    : constant Uint := UI_From_Int (System_Storage_Unit);

   begin

      --  This first loop through components does two things. First it deals

      --  with the case of components with component clauses whose length is

      --  greater than the maximum machine scalar size (either accepting them

      --  or rejecting as needed). Second, it counts the number of components

      --  with component clauses whose length does not exceed this maximum for

      --  later processing.

      Num_CC := 0;

      Comp   := First_Component_Or_Discriminant (R);

      while Present (Comp) loop

         declare

            CC : constant Node_Id := Component_Clause (Comp);

         begin

            if Present (CC) then

               declare

                  Fbit : constant Uint := Static_Integer (First_Bit (CC));

               begin

                  --  Case of component with size > max machine scalar

                  if Esize (Comp) > Max_Machine_Scalar_Size then

                     --  Must begin on byte boundary

                     if Fbit mod SSU /= 0 then

                        Error_Msg_N

                          ("illegal first bit value for reverse bit order",

                           First_Bit (CC));

                        Error_Msg_Uint_1 := SSU;

                        Error_Msg_Uint_2 := Max_Machine_Scalar_Size;

                        Error_Msg_N

                          ("\must be a multiple of ^ if size greater than ^",

                           First_Bit (CC));

                     --  Must end on byte boundary

                     elsif Esize (Comp) mod SSU /= 0 then

                        Error_Msg_N

                          ("illegal last bit value for reverse bit order",

                           Last_Bit (CC));

                        Error_Msg_Uint_1 := SSU;

                        Error_Msg_Uint_2 := Max_Machine_Scalar_Size;

                        Error_Msg_N

                          ("\must be a multiple of ^ if size greater than ^",

                           Last_Bit (CC));

                     --  OK, give warning if enabled

                     elsif Warn_On_Reverse_Bit_Order then

                        Error_Msg_N

                          ("multi-byte field specified with non-standard"

                           & " Bit_Order?", CC);

                        if Bytes_Big_Endian then

                           Error_Msg_N

                             ("\bytes are not reversed "

                              & "(component is big-endian)?", CC);

                        else

                           Error_Msg_N

                             ("\bytes are not reversed "

                              & "(component is little-endian)?", CC);

                        end if;

                     end if;

                     --  Case where size is not greater than max machine

                     --  scalar. For now, we just count these.

                  else

                     Num_CC := Num_CC + 1;

                  end if;

               end;

            end if;

         end;

         Next_Component_Or_Discriminant (Comp);

      end loop;

      --  We need to sort the component clauses on the basis of the Position

      --  values in the clause, so we can group clauses with the same Position.

      --  together to determine the relevant machine scalar size.

      declare

         Comps : array (0 .. Num_CC) of Entity_Id;

         --  Array to collect component and discriminant entities. The data

         --  starts at index 1, the 0'th entry is for the sort routine.

         function CP_Lt (Op1, Op2 : Natural) return Boolean;

         --  Compare routine for Sort

         procedure CP_Move (From : Natural; To : Natural);

         --  Move routine for Sort

         package Sorting is new GNAT.Heap_Sort_G (CP_Move, CP_Lt);

         Start : Natural;

         Stop  : Natural;

         --  Start and stop positions in component list of set of components

         --  with the same starting position (that constitute components in

         --  a single machine scalar).

         MaxL : Uint;

         --  Maximum last bit value of any component in this set

         MSS : Uint;

         --  Corresponding machine scalar size

         -----------

         -- CP_Lt --

         -----------

         function CP_Lt (Op1, Op2 : Natural) return Boolean is

         begin

            return Position (Component_Clause (Comps (Op1))) <

                   Position (Component_Clause (Comps (Op2)));

         end CP_Lt;

         -------------

         -- CP_Move --

         -------------

         procedure CP_Move (From : Natural; To : Natural) is

         begin

            Comps (To) := Comps (From);

         end CP_Move;

      begin

         --  Collect the component clauses

         Num_CC := 0;

         Comp   := First_Component_Or_Discriminant (R);

         while Present (Comp) loop

            if Present (Component_Clause (Comp))

              and then Esize (Comp) <= Max_Machine_Scalar_Size

            then

               Num_CC := Num_CC + 1;

               Comps (Num_CC) := Comp;

            end if;

            Next_Component_Or_Discriminant (Comp);

         end loop;

         --  Sort by ascending position number

         Sorting.Sort (Num_CC);

         --  We now have all the components whose size does not exceed the max

         --  machine scalar value, sorted by starting position. In this loop

         --  we gather groups of clauses starting at the same position, to

         --  process them in accordance with Ada 2005 AI-133.

         Stop := 0;

         while Stop < Num_CC loop

            Start := Stop + 1;

            Stop  := Start;

            MaxL  :=

              Static_Integer (Last_Bit (Component_Clause (Comps (Start))));

            while Stop < Num_CC loop

               if Static_Integer

                    (Position (Component_Clause (Comps (Stop + 1)))) =

                  Static_Integer

                    (Position (Component_Clause (Comps (Stop))))

               then

                  Stop := Stop + 1;

                  MaxL :=

                    UI_Max

                      (MaxL,

                       Static_Integer

                         (Last_Bit (Component_Clause (Comps (Stop)))));

               else

                  exit;

               end if;

            end loop;

            --  Now we have a group of component clauses from Start to Stop

            --  whose positions are identical, and MaxL is the maximum last bit

            --  value of any of these components.

            --  We need to determine the corresponding machine scalar size.

            --  This loop assumes that machine scalar sizes are even, and that

            --  each possible machine scalar has twice as many bits as the

            --  next smaller one.

            MSS := Max_Machine_Scalar_Size;

            while MSS mod 2 = 0

              and then (MSS / 2) >= SSU

              and then (MSS / 2) > MaxL

            loop

               MSS := MSS / 2;

            end loop;

            --  Here is where we fix up the Component_Bit_Offset value to

            --  account for the reverse bit order. Some examples of what needs

            --  to be done for the case of a machine scalar size of 8 are:

            --    First_Bit .. Last_Bit     Component_Bit_Offset

            --      old          new          old       new

            --     0 .. 0       7 .. 7         0         7

            --     0 .. 1       6 .. 7         0         6

            --     0 .. 2       5 .. 7         0         5

            --     0 .. 7       0 .. 7         0         4

            --     1 .. 1       6 .. 6         1         6

            --     1 .. 4       3 .. 6         1         3

            --     4 .. 7       0 .. 3         4         0

            --  The general rule is that the first bit is obtained by

            --  subtracting the old ending bit from machine scalar size - 1.

            for C in Start .. Stop loop

               declare

                  Comp : constant Entity_Id := Comps (C);

                  CC   : constant Node_Id   := Component_Clause (Comp);

                  LB   : constant Uint := Static_Integer (Last_Bit (CC));

                  NFB  : constant Uint := MSS - Uint_1 - LB;

                  NLB  : constant Uint := NFB + Esize (Comp) - 1;

                  Pos  : constant Uint := Static_Integer (Position (CC));

               begin

                  if Warn_On_Reverse_Bit_Order then

                     Error_Msg_Uint_1 := MSS;

                     Error_Msg_N

                       ("info: reverse bit order in machine " &

                       "scalar of length^?", First_Bit (CC));

                     Error_Msg_Uint_1 := NFB;

                     Error_Msg_Uint_2 := NLB;

                     if Bytes_Big_Endian then

                        Error_Msg_NE

                          ("?\info: big-endian range for "

                           & "component & is ^ .. ^",

                           First_Bit (CC), Comp);

                     else

                        Error_Msg_NE

                          ("?\info: little-endian range "

                           & "for component & is ^ .. ^",

                           First_Bit (CC), Comp);

                     end if;

                  end if;

                  Set_Component_Bit_Offset (Comp, Pos * SSU + NFB);

                  Set_Normalized_First_Bit (Comp, NFB mod SSU);

               end;

            end loop;

         end loop;

      end;

   end Adjust_Record_For_Reverse_Bit_Order;

   --------------------------------------

   -- Alignment_Check_For_Esize_Change --

   --------------------------------------

   procedure Alignment_Check_For_Esize_Change (Typ : Entity_Id) is

   begin

      --  If the alignment is known, and not set by a rep clause, and is

      --  inconsistent with the size being set, then reset it to unknown,

      --  we assume in this case that the size overrides the inherited

      --  alignment, and that the alignment must be recomputed.

      if Known_Alignment (Typ)

        and then not Has_Alignment_Clause (Typ)

        and then Esize (Typ) mod (Alignment (Typ) * SSU) /= 0

      then

         Init_Alignment (Typ);

      end if;

   end Alignment_Check_For_Esize_Change;

   -----------------------

   -- Analyze_At_Clause --

   -----------------------

   --  An at clause is replaced by the corresponding Address attribute

   --  definition clause that is the preferred approach in Ada 95.

   procedure Analyze_At_Clause (N : Node_Id) is

      CS : constant Boolean := Comes_From_Source (N);

   begin

      --  This is an obsolescent feature

      Check_Restriction (No_Obsolescent_Features, N);

      if Warn_On_Obsolescent_Feature then

         Error_Msg_N

           ("at clause is an obsolescent feature (RM J.7(2))?", N);

         Error_Msg_N

           ("\use address attribute definition clause instead?", N);

      end if;

      --  Rewrite as address clause

      Rewrite (N,

        Make_Attribute_Definition_Clause (Sloc (N),

          Name  => Identifier (N),

          Chars => Name_Address,

          Expression => Expression (N)));

      --  We preserve Comes_From_Source, since logically the clause still

      --  comes from the source program even though it is changed in form.

      Set_Comes_From_Source (N, CS);

      --  Analyze rewritten clause

      Analyze_Attribute_Definition_Clause (N);

   end Analyze_At_Clause;

   -----------------------------------------

   -- Analyze_Attribute_Definition_Clause --

   -----------------------------------------

   procedure Analyze_Attribute_Definition_Clause (N : Node_Id) is

      Loc   : constant Source_Ptr   := Sloc (N);

      Nam   : constant Node_Id      := Name (N);

      Attr  : constant Name_Id      := Chars (N);

      Expr  : constant Node_Id      := Expression (N);

      Id    : constant Attribute_Id := Get_Attribute_Id (Attr);

      Ent   : Entity_Id;

      U_Ent : Entity_Id;

      FOnly : Boolean := False;

      --  Reset to True for subtype specific attribute (Alignment, Size)

      --  and for stream attributes, i.e. those cases where in the call

      --  to Rep_Item_Too_Late, FOnly is set True so that only the freezing

      --  rules are checked. Note that the case of stream attributes is not

      --  clear from the RM, but see AI95-00137. Also, the RM seems to

      --  disallow Storage_Size for derived task types, but that is also

      --  clearly unintentional.

      procedure Analyze_Stream_TSS_Definition (TSS_Nam : TSS_Name_Type);

      --  Common processing for 'Read, 'Write, 'Input and 'Output attribute

      --  definition clauses.

      -----------------------------------

      -- Analyze_Stream_TSS_Definition --

      -----------------------------------

      procedure Analyze_Stream_TSS_Definition (TSS_Nam : TSS_Name_Type) is

         Subp : Entity_Id := Empty;

         I    : Interp_Index;

         It   : Interp;

         Pnam : Entity_Id;

         Is_Read : constant Boolean := (TSS_Nam = TSS_Stream_Read);

         function Has_Good_Profile (Subp : Entity_Id) return Boolean;

         --  Return true if the entity is a subprogram with an appropriate

         --  profile for the attribute being defined.

         ----------------------

         -- Has_Good_Profile --

         ----------------------

         function Has_Good_Profile (Subp : Entity_Id) return Boolean is

            F              : Entity_Id;

            Is_Function    : constant Boolean := (TSS_Nam = TSS_Stream_Input);

            Expected_Ekind : constant array (Boolean) of Entity_Kind :=

                               (False => E_Procedure, True => E_Function);

            Typ            : Entity_Id;

         begin

            if Ekind (Subp) /= Expected_Ekind (Is_Function) then

               return False;

            end if;

            F := First_Formal (Subp);

            if No (F)

              or else Ekind (Etype (F)) /= E_Anonymous_Access_Type

              or else Designated_Type (Etype (F)) /=

                               Class_Wide_Type (RTE (RE_Root_Stream_Type))

            then

               return False;

            end if;

            if not Is_Function then

               Next_Formal (F);

               declare

                  Expected_Mode : constant array (Boolean) of Entity_Kind :=

                                    (False => E_In_Parameter,

                                     True  => E_Out_Parameter);

               begin

                  if Parameter_Mode (F) /= Expected_Mode (Is_Read) then

                     return False;

                  end if;

               end;

               Typ := Etype (F);

            else

               Typ := Etype (Subp);

            end if;

            return Base_Type (Typ) = Base_Type (Ent)

              and then No (Next_Formal (F));

         end Has_Good_Profile;

      --  Start of processing for Analyze_Stream_TSS_Definition

      begin

         FOnly := True;

         if not Is_Type (U_Ent) then

            Error_Msg_N ("local name must be a subtype", Nam);

            return;

         end if;

         Pnam := TSS (Base_Type (U_Ent), TSS_Nam);

         --  If Pnam is present, it can be either inherited from an ancestor

         --  type (in which case it is legal to redefine it for this type), or

         --  be a previous definition of the attribute for the same type (in

         --  which case it is illegal).

         --  In the first case, it will have been analyzed already, and we

         --  can check that its profile does not match the expected profile

         --  for a stream attribute of U_Ent. In the second case, either Pnam

         --  has been analyzed (and has the expected profile), or it has not

         --  been analyzed yet (case of a type that has not been frozen yet

         --  and for which the stream attribute has been set using Set_TSS).

         if Present (Pnam)

           and then (No (First_Entity (Pnam)) or else Has_Good_Profile (Pnam))

         then

            Error_Msg_Sloc := Sloc (Pnam);

            Error_Msg_Name_1 := Attr;

            Error_Msg_N ("% attribute already defined #", Nam);

            return;

         end if;

         Analyze (Expr);

         if Is_Entity_Name (Expr) then

            if not Is_Overloaded (Expr) then

               if Has_Good_Profile (Entity (Expr)) then

                  Subp := Entity (Expr);

               end if;

            else

               Get_First_Interp (Expr, I, It);

               while Present (It.Nam) loop

                  if Has_Good_Profile (It.Nam) then

                     Subp := It.Nam;

                     exit;

                  end if;

                  Get_Next_Interp (I, It);

               end loop;

            end if;

         end if;

         if Present (Subp) then

            if Is_Abstract_Subprogram (Subp) then

               Error_Msg_N ("stream subprogram must not be abstract", Expr);

               return;

            end if;

            Set_Entity (Expr, Subp);

            Set_Etype (Expr, Etype (Subp));

            New_Stream_Subprogram (N, U_Ent, Subp, TSS_Nam);

         else

            Error_Msg_Name_1 := Attr;

            Error_Msg_N ("incorrect expression for% attribute", Expr);

         end if;

      end Analyze_Stream_TSS_Definition;

   --  Start of processing for Analyze_Attribute_Definition_Clause

   begin

      --  Process Ignore_Rep_Clauses option

      if Ignore_Rep_Clauses then

         case Id is

            --  The following should be ignored. They do not affect legality

            --  and may be target dependent. The basic idea of -gnatI is to

            --  ignore any rep clauses that may be target dependent but do not

            --  affect legality (except possibly to be rejected because they

            --  are incompatible with the compilation target).

            when Attribute_Alignment      |

                 Attribute_Bit_Order      |

                 Attribute_Component_Size |

                 Attribute_Machine_Radix  |

                 Attribute_Object_Size    |

                 Attribute_Size           |

                 Attribute_Small          |

                 Attribute_Stream_Size    |

                 Attribute_Value_Size     =>

               Rewrite (N, Make_Null_Statement (Sloc (N)));

               return;

            --  The following should not be ignored, because in the first place

            --  they are reasonably portable, and should not cause problems in

            --  compiling code from another target, and also they do affect

            --  legality, e.g. failing to provide a stream attribute for a

            --  type may make a program illegal.

            when Attribute_External_Tag   |

                 Attribute_Input          |

                 Attribute_Output         |

                 Attribute_Read           |

                 Attribute_Storage_Pool   |

                 Attribute_Storage_Size   |

                 Attribute_Write          =>

               null;

            --  Other cases are errors, which will be caught below

            when others =>

               null;

         end case;

      end if;

      Analyze (Nam);

      Ent := Entity (Nam);

      if Rep_Item_Too_Early (Ent, N) then

         return;

      end if;

      --  Rep clause applies to full view of incomplete type or private type if

      --  we have one (if not, this is a premature use of the type). However,

      --  certain semantic checks need to be done on the specified entity (i.e.

      --  the private view), so we save it in Ent.

      if Is_Private_Type (Ent)

        and then Is_Derived_Type (Ent)

        and then not Is_Tagged_Type (Ent)

        and then No (Full_View (Ent))

      then

         --  If this is a private type whose completion is a derivation from

         --  another private type, there is no full view, and the attribute

         --  belongs to the type itself, not its underlying parent.

         U_Ent := Ent;

      elsif Ekind (Ent) = E_Incomplete_Type then

         --  The attribute applies to the full view, set the entity of the

         --  attribute definition accordingly.

         Ent := Underlying_Type (Ent);

         U_Ent := Ent;

         Set_Entity (Nam, Ent);

      else

         U_Ent := Underlying_Type (Ent);

      end if;

      --  Complete other routine error checks

      if Etype (Nam) = Any_Type then

         return;

      elsif Scope (Ent) /= Current_Scope then

         Error_Msg_N ("entity must be declared in this scope", Nam);

         return;

      elsif No (U_Ent) then

         U_Ent := Ent;

      elsif Is_Type (U_Ent)

        and then not Is_First_Subtype (U_Ent)

        and then Id /= Attribute_Object_Size

        and then Id /= Attribute_Value_Size

        and then not From_At_Mod (N)

      then

         Error_Msg_N ("cannot specify attribute for subtype", Nam);

         return;

      end if;

      --  Switch on particular attribute

      case Id is

         -------------

         -- Address --

         -------------

         --  Address attribute definition clause

         when Attribute_Address => Address : begin

            --  A little error check, catch for X'Address use X'Address;