1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 2001-2007, 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, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, 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 Atree; use Atree;
28 with Checks; use Checks;
29 with Debug; use Debug;
30 with Einfo; use Einfo;
31 with Errout; use Errout;
32 with Exp_Ch3; use Exp_Ch3;
33 with Exp_Util; use Exp_Util;
34 with Namet; use Namet;
35 with Nlists; use Nlists;
36 with Nmake; use Nmake;
38 with Repinfo; use Repinfo;
40 with Sem_Ch13; use Sem_Ch13;
41 with Sem_Eval; use Sem_Eval;
42 with Sem_Util; use Sem_Util;
43 with Sinfo; use Sinfo;
44 with Snames; use Snames;
45 with Stand; use Stand;
46 with Targparm; use Targparm;
47 with Tbuild; use Tbuild;
48 with Ttypes; use Ttypes;
49 with Uintp; use Uintp;
51 package body Layout is
53 ------------------------
54 -- Local Declarations --
55 ------------------------
57 SSU : constant Int := Ttypes.System_Storage_Unit;
58 -- Short hand for System_Storage_Unit
60 Vname : constant Name_Id := Name_uV;
61 -- Formal parameter name used for functions generated for size offset
62 -- values that depend on the discriminant. All such functions have the
65 -- function xxx (V : vtyp) return Unsigned is
67 -- return ... expression involving V.discrim
70 -----------------------
71 -- Local Subprograms --
72 -----------------------
77 Right_Opnd : Node_Id) return Node_Id;
78 -- This is like Make_Op_Add except that it optimizes some cases knowing
79 -- that associative rearrangement is allowed for constant folding if one
80 -- of the operands is a compile time known value.
82 function Assoc_Multiply
85 Right_Opnd : Node_Id) return Node_Id;
86 -- This is like Make_Op_Multiply except that it optimizes some cases
87 -- knowing that associative rearrangement is allowed for constant
88 -- folding if one of the operands is a compile time known value
90 function Assoc_Subtract
93 Right_Opnd : Node_Id) return Node_Id;
94 -- This is like Make_Op_Subtract except that it optimizes some cases
95 -- knowing that associative rearrangement is allowed for constant
96 -- folding if one of the operands is a compile time known value
98 function Bits_To_SU (N : Node_Id) return Node_Id;
99 -- This is used when we cross the boundary from static sizes in bits to
100 -- dynamic sizes in storage units. If the argument N is anything other
101 -- than an integer literal, it is returned unchanged, but if it is an
102 -- integer literal, then it is taken as a size in bits, and is replaced
103 -- by the corresponding size in storage units.
105 function Compute_Length (Lo : Node_Id; Hi : Node_Id) return Node_Id;
106 -- Given expressions for the low bound (Lo) and the high bound (Hi),
107 -- Build an expression for the value hi-lo+1, converted to type
108 -- Standard.Unsigned. Takes care of the case where the operands
109 -- are of an enumeration type (so that the subtraction cannot be
110 -- done directly) by applying the Pos operator to Hi/Lo first.
112 function Expr_From_SO_Ref
115 Comp : Entity_Id := Empty) return Node_Id;
116 -- Given a value D from a size or offset field, return an expression
117 -- representing the value stored. If the value is known at compile time,
118 -- then an N_Integer_Literal is returned with the appropriate value. If
119 -- the value references a constant entity, then an N_Identifier node
120 -- referencing this entity is returned. If the value denotes a size
121 -- function, then returns a call node denoting the given function, with
122 -- a single actual parameter that either refers to the parameter V of
123 -- an enclosing size function (if Comp is Empty or its type doesn't match
124 -- the function's formal), or else is a selected component V.c when Comp
125 -- denotes a component c whose type matches that of the function formal.
126 -- The Loc value is used for the Sloc value of constructed notes.
128 function SO_Ref_From_Expr
130 Ins_Type : Entity_Id;
131 Vtype : Entity_Id := Empty;
132 Make_Func : Boolean := False) return Dynamic_SO_Ref;
133 -- This routine is used in the case where a size/offset value is dynamic
134 -- and is represented by the expression Expr. SO_Ref_From_Expr checks if
135 -- the Expr contains a reference to the identifier V, and if so builds
136 -- a function depending on discriminants of the formal parameter V which
137 -- is of type Vtype. Otherwise, if the parameter Make_Func is True, then
138 -- Expr will be encapsulated in a parameterless function; if Make_Func is
139 -- False, then a constant entity with the value Expr is built. The result
140 -- is a Dynamic_SO_Ref to the created entity. Note that Vtype can be
141 -- omitted if Expr does not contain any reference to V, the created entity.
142 -- The declaration created is inserted in the freeze actions of Ins_Type,
143 -- which also supplies the Sloc for created nodes. This function also takes
144 -- care of making sure that the expression is properly analyzed and
145 -- resolved (which may not be the case yet if we build the expression
148 function Get_Max_SU_Size (E : Entity_Id) return Node_Id;
149 -- E is an array type or subtype that has at least one index bound that
150 -- is the value of a record discriminant. For such an array, the function
151 -- computes an expression that yields the maximum possible size of the
152 -- array in storage units. The result is not defined for any other type,
153 -- or for arrays that do not depend on discriminants, and it is a fatal
154 -- error to call this unless Size_Depends_On_Discriminant (E) is True.
156 procedure Layout_Array_Type (E : Entity_Id);
157 -- Front-end layout of non-bit-packed array type or subtype
159 procedure Layout_Record_Type (E : Entity_Id);
160 -- Front-end layout of record type
162 procedure Rewrite_Integer (N : Node_Id; V : Uint);
163 -- Rewrite node N with an integer literal whose value is V. The Sloc
164 -- for the new node is taken from N, and the type of the literal is
165 -- set to a copy of the type of N on entry.
167 procedure Set_And_Check_Static_Size
171 -- This procedure is called to check explicit given sizes (possibly
172 -- stored in the Esize and RM_Size fields of E) against computed
173 -- Object_Size (Esiz) and Value_Size (RM_Siz) values. Appropriate
174 -- errors and warnings are posted if specified sizes are inconsistent
175 -- with specified sizes. On return, the Esize and RM_Size fields of
176 -- E are set (either from previously given values, or from the newly
177 -- computed values, as appropriate).
179 procedure Set_Composite_Alignment (E : Entity_Id);
180 -- This procedure is called for record types and subtypes, and also for
181 -- atomic array types and subtypes. If no alignment is set, and the size
182 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
185 ----------------------------
186 -- Adjust_Esize_Alignment --
187 ----------------------------
189 procedure Adjust_Esize_Alignment (E : Entity_Id) is
194 -- Nothing to do if size unknown
196 if Unknown_Esize (E) then
200 -- Determine if size is constrained by an attribute definition clause
201 -- which must be obeyed. If so, we cannot increase the size in this
204 -- For a type, the issue is whether an object size clause has been
205 -- set. A normal size clause constrains only the value size (RM_Size)
208 Esize_Set := Has_Object_Size_Clause (E);
210 -- For an object, the issue is whether a size clause is present
213 Esize_Set := Has_Size_Clause (E);
216 -- If size is known it must be a multiple of the storage unit size
218 if Esize (E) mod SSU /= 0 then
220 -- If not, and size specified, then give error
224 ("size for& not a multiple of storage unit size",
228 -- Otherwise bump up size to a storage unit boundary
231 Set_Esize (E, (Esize (E) + SSU - 1) / SSU * SSU);
235 -- Now we have the size set, it must be a multiple of the alignment
236 -- nothing more we can do here if the alignment is unknown here.
238 if Unknown_Alignment (E) then
242 -- At this point both the Esize and Alignment are known, so we need
243 -- to make sure they are consistent.
245 Abits := UI_To_Int (Alignment (E)) * SSU;
247 if Esize (E) mod Abits = 0 then
251 -- Here we have a situation where the Esize is not a multiple of
252 -- the alignment. We must either increase Esize or reduce the
253 -- alignment to correct this situation.
255 -- The case in which we can decrease the alignment is where the
256 -- alignment was not set by an alignment clause, and the type in
257 -- question is a discrete type, where it is definitely safe to
258 -- reduce the alignment. For example:
260 -- t : integer range 1 .. 2;
263 -- In this situation, the initial alignment of t is 4, copied from
264 -- the Integer base type, but it is safe to reduce it to 1 at this
265 -- stage, since we will only be loading a single storage unit.
267 if Is_Discrete_Type (Etype (E))
268 and then not Has_Alignment_Clause (E)
272 exit when Esize (E) mod Abits = 0;
275 Init_Alignment (E, Abits / SSU);
279 -- Now the only possible approach left is to increase the Esize
280 -- but we can't do that if the size was set by a specific clause.
284 ("size for& is not a multiple of alignment",
287 -- Otherwise we can indeed increase the size to a multiple of alignment
290 Set_Esize (E, ((Esize (E) + (Abits - 1)) / Abits) * Abits);
292 end Adjust_Esize_Alignment;
301 Right_Opnd : Node_Id) return Node_Id
307 -- Case of right operand is a constant
309 if Compile_Time_Known_Value (Right_Opnd) then
311 R := Expr_Value (Right_Opnd);
313 -- Case of left operand is a constant
315 elsif Compile_Time_Known_Value (Left_Opnd) then
317 R := Expr_Value (Left_Opnd);
319 -- Neither operand is a constant, do the addition with no optimization
322 return Make_Op_Add (Loc, Left_Opnd, Right_Opnd);
325 -- Case of left operand is an addition
327 if Nkind (L) = N_Op_Add then
329 -- (C1 + E) + C2 = (C1 + C2) + E
331 if Compile_Time_Known_Value (Sinfo.Left_Opnd (L)) then
333 (Sinfo.Left_Opnd (L),
334 Expr_Value (Sinfo.Left_Opnd (L)) + R);
337 -- (E + C1) + C2 = E + (C1 + C2)
339 elsif Compile_Time_Known_Value (Sinfo.Right_Opnd (L)) then
341 (Sinfo.Right_Opnd (L),
342 Expr_Value (Sinfo.Right_Opnd (L)) + R);
346 -- Case of left operand is a subtraction
348 elsif Nkind (L) = N_Op_Subtract then
350 -- (C1 - E) + C2 = (C1 + C2) + E
352 if Compile_Time_Known_Value (Sinfo.Left_Opnd (L)) then
354 (Sinfo.Left_Opnd (L),
355 Expr_Value (Sinfo.Left_Opnd (L)) + R);
358 -- (E - C1) + C2 = E - (C1 - C2)
360 elsif Compile_Time_Known_Value (Sinfo.Right_Opnd (L)) then
362 (Sinfo.Right_Opnd (L),
363 Expr_Value (Sinfo.Right_Opnd (L)) - R);
368 -- Not optimizable, do the addition
370 return Make_Op_Add (Loc, Left_Opnd, Right_Opnd);
377 function Assoc_Multiply
380 Right_Opnd : Node_Id) return Node_Id
386 -- Case of right operand is a constant
388 if Compile_Time_Known_Value (Right_Opnd) then
390 R := Expr_Value (Right_Opnd);
392 -- Case of left operand is a constant
394 elsif Compile_Time_Known_Value (Left_Opnd) then
396 R := Expr_Value (Left_Opnd);
398 -- Neither operand is a constant, do the multiply with no optimization
401 return Make_Op_Multiply (Loc, Left_Opnd, Right_Opnd);
404 -- Case of left operand is an multiplication
406 if Nkind (L) = N_Op_Multiply then
408 -- (C1 * E) * C2 = (C1 * C2) + E
410 if Compile_Time_Known_Value (Sinfo.Left_Opnd (L)) then
412 (Sinfo.Left_Opnd (L),
413 Expr_Value (Sinfo.Left_Opnd (L)) * R);
416 -- (E * C1) * C2 = E * (C1 * C2)
418 elsif Compile_Time_Known_Value (Sinfo.Right_Opnd (L)) then
420 (Sinfo.Right_Opnd (L),
421 Expr_Value (Sinfo.Right_Opnd (L)) * R);
426 -- Not optimizable, do the multiplication
428 return Make_Op_Multiply (Loc, Left_Opnd, Right_Opnd);
435 function Assoc_Subtract
438 Right_Opnd : Node_Id) return Node_Id
444 -- Case of right operand is a constant
446 if Compile_Time_Known_Value (Right_Opnd) then
448 R := Expr_Value (Right_Opnd);
450 -- Right operand is a constant, do the subtract with no optimization
453 return Make_Op_Subtract (Loc, Left_Opnd, Right_Opnd);
456 -- Case of left operand is an addition
458 if Nkind (L) = N_Op_Add then
460 -- (C1 + E) - C2 = (C1 - C2) + E
462 if Compile_Time_Known_Value (Sinfo.Left_Opnd (L)) then
464 (Sinfo.Left_Opnd (L),
465 Expr_Value (Sinfo.Left_Opnd (L)) - R);
468 -- (E + C1) - C2 = E + (C1 - C2)
470 elsif Compile_Time_Known_Value (Sinfo.Right_Opnd (L)) then
472 (Sinfo.Right_Opnd (L),
473 Expr_Value (Sinfo.Right_Opnd (L)) - R);
477 -- Case of left operand is a subtraction
479 elsif Nkind (L) = N_Op_Subtract then
481 -- (C1 - E) - C2 = (C1 - C2) + E
483 if Compile_Time_Known_Value (Sinfo.Left_Opnd (L)) then
485 (Sinfo.Left_Opnd (L),
486 Expr_Value (Sinfo.Left_Opnd (L)) + R);
489 -- (E - C1) - C2 = E - (C1 + C2)
491 elsif Compile_Time_Known_Value (Sinfo.Right_Opnd (L)) then
493 (Sinfo.Right_Opnd (L),
494 Expr_Value (Sinfo.Right_Opnd (L)) + R);
499 -- Not optimizable, do the subtraction
501 return Make_Op_Subtract (Loc, Left_Opnd, Right_Opnd);
508 function Bits_To_SU (N : Node_Id) return Node_Id is
510 if Nkind (N) = N_Integer_Literal then
511 Set_Intval (N, (Intval (N) + (SSU - 1)) / SSU);
521 function Compute_Length (Lo : Node_Id; Hi : Node_Id) return Node_Id is
522 Loc : constant Source_Ptr := Sloc (Lo);
523 Typ : constant Entity_Id := Etype (Lo);
530 -- If the bounds are First and Last attributes for the same dimension
531 -- and both have prefixes that denotes the same entity, then we create
532 -- and return a Length attribute. This may allow the back end to
533 -- generate better code in cases where it already has the length.
535 if Nkind (Lo) = N_Attribute_Reference
536 and then Attribute_Name (Lo) = Name_First
537 and then Nkind (Hi) = N_Attribute_Reference
538 and then Attribute_Name (Hi) = Name_Last
539 and then Is_Entity_Name (Prefix (Lo))
540 and then Is_Entity_Name (Prefix (Hi))
541 and then Entity (Prefix (Lo)) = Entity (Prefix (Hi))
546 if Present (First (Expressions (Lo))) then
547 Lo_Dim := Expr_Value (First (Expressions (Lo)));
550 if Present (First (Expressions (Hi))) then
551 Hi_Dim := Expr_Value (First (Expressions (Hi)));
554 if Lo_Dim = Hi_Dim then
556 Make_Attribute_Reference (Loc,
557 Prefix => New_Occurrence_Of
558 (Entity (Prefix (Lo)), Loc),
559 Attribute_Name => Name_Length,
560 Expressions => New_List
561 (Make_Integer_Literal (Loc, Lo_Dim)));
565 Lo_Op := New_Copy_Tree (Lo);
566 Hi_Op := New_Copy_Tree (Hi);
568 -- If type is enumeration type, then use Pos attribute to convert
569 -- to integer type for which subtraction is a permitted operation.
571 if Is_Enumeration_Type (Typ) then
573 Make_Attribute_Reference (Loc,
574 Prefix => New_Occurrence_Of (Typ, Loc),
575 Attribute_Name => Name_Pos,
576 Expressions => New_List (Lo_Op));
579 Make_Attribute_Reference (Loc,
580 Prefix => New_Occurrence_Of (Typ, Loc),
581 Attribute_Name => Name_Pos,
582 Expressions => New_List (Hi_Op));
590 Right_Opnd => Lo_Op),
591 Right_Opnd => Make_Integer_Literal (Loc, 1));
594 ----------------------
595 -- Expr_From_SO_Ref --
596 ----------------------
598 function Expr_From_SO_Ref
601 Comp : Entity_Id := Empty) return Node_Id
606 if Is_Dynamic_SO_Ref (D) then
607 Ent := Get_Dynamic_SO_Entity (D);
609 if Is_Discrim_SO_Function (Ent) then
610 -- If a component is passed in whose type matches the type
611 -- of the function formal, then select that component from
612 -- the "V" parameter rather than passing "V" directly.
615 and then Base_Type (Etype (Comp))
616 = Base_Type (Etype (First_Formal (Ent)))
619 Make_Function_Call (Loc,
620 Name => New_Occurrence_Of (Ent, Loc),
621 Parameter_Associations => New_List (
622 Make_Selected_Component (Loc,
623 Prefix => Make_Identifier (Loc, Chars => Vname),
624 Selector_Name => New_Occurrence_Of (Comp, Loc))));
628 Make_Function_Call (Loc,
629 Name => New_Occurrence_Of (Ent, Loc),
630 Parameter_Associations => New_List (
631 Make_Identifier (Loc, Chars => Vname)));
635 return New_Occurrence_Of (Ent, Loc);
639 return Make_Integer_Literal (Loc, D);
641 end Expr_From_SO_Ref;
643 ---------------------
644 -- Get_Max_SU_Size --
645 ---------------------
647 function Get_Max_SU_Size (E : Entity_Id) return Node_Id is
648 Loc : constant Source_Ptr := Sloc (E);
656 type Val_Status_Type is (Const, Dynamic);
658 type Val_Type (Status : Val_Status_Type := Const) is
661 when Const => Val : Uint;
662 when Dynamic => Nod : Node_Id;
665 -- Shows the status of the value so far. Const means that the value
666 -- is constant, and Val is the current constant value. Dynamic means
667 -- that the value is dynamic, and in this case Nod is the Node_Id of
668 -- the expression to compute the value.
671 -- Calculated value so far if Size.Status = Const,
672 -- or expression value so far if Size.Status = Dynamic.
674 SU_Convert_Required : Boolean := False;
675 -- This is set to True if the final result must be converted from
676 -- bits to storage units (rounding up to a storage unit boundary).
678 -----------------------
679 -- Local Subprograms --
680 -----------------------
682 procedure Max_Discrim (N : in out Node_Id);
683 -- If the node N represents a discriminant, replace it by the maximum
684 -- value of the discriminant.
686 procedure Min_Discrim (N : in out Node_Id);
687 -- If the node N represents a discriminant, replace it by the minimum
688 -- value of the discriminant.
694 procedure Max_Discrim (N : in out Node_Id) is
696 if Nkind (N) = N_Identifier
697 and then Ekind (Entity (N)) = E_Discriminant
699 N := Type_High_Bound (Etype (N));
707 procedure Min_Discrim (N : in out Node_Id) is
709 if Nkind (N) = N_Identifier
710 and then Ekind (Entity (N)) = E_Discriminant
712 N := Type_Low_Bound (Etype (N));
716 -- Start of processing for Get_Max_SU_Size
719 pragma Assert (Size_Depends_On_Discriminant (E));
721 -- Initialize status from component size
723 if Known_Static_Component_Size (E) then
724 Size := (Const, Component_Size (E));
727 Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
730 -- Loop through indices
732 Indx := First_Index (E);
733 while Present (Indx) loop
734 Ityp := Etype (Indx);
735 Lo := Type_Low_Bound (Ityp);
736 Hi := Type_High_Bound (Ityp);
741 -- Value of the current subscript range is statically known
743 if Compile_Time_Known_Value (Lo)
744 and then Compile_Time_Known_Value (Hi)
746 S := Expr_Value (Hi) - Expr_Value (Lo) + 1;
748 -- If known flat bound, entire size of array is zero!
751 return Make_Integer_Literal (Loc, 0);
754 -- Current value is constant, evolve value
756 if Size.Status = Const then
757 Size.Val := Size.Val * S;
759 -- Current value is dynamic
762 -- An interesting little optimization, if we have a pending
763 -- conversion from bits to storage units, and the current
764 -- length is a multiple of the storage unit size, then we
765 -- can take the factor out here statically, avoiding some
766 -- extra dynamic computations at the end.
768 if SU_Convert_Required and then S mod SSU = 0 then
770 SU_Convert_Required := False;
775 Left_Opnd => Size.Nod,
777 Make_Integer_Literal (Loc, Intval => S));
780 -- Value of the current subscript range is dynamic
783 -- If the current size value is constant, then here is where we
784 -- make a transition to dynamic values, which are always stored
785 -- in storage units, However, we do not want to convert to SU's
786 -- too soon, consider the case of a packed array of single bits,
787 -- we want to do the SU conversion after computing the size in
790 if Size.Status = Const then
792 -- If the current value is a multiple of the storage unit,
793 -- then most certainly we can do the conversion now, simply
794 -- by dividing the current value by the storage unit value.
795 -- If this works, we set SU_Convert_Required to False.
797 if Size.Val mod SSU = 0 then
800 (Dynamic, Make_Integer_Literal (Loc, Size.Val / SSU));
801 SU_Convert_Required := False;
803 -- Otherwise, we go ahead and convert the value in bits,
804 -- and set SU_Convert_Required to True to ensure that the
805 -- final value is indeed properly converted.
808 Size := (Dynamic, Make_Integer_Literal (Loc, Size.Val));
809 SU_Convert_Required := True;
815 Len := Compute_Length (Lo, Hi);
817 -- Check possible range of Len
826 Determine_Range (Len, OK, LLo, LHi);
828 Len := Convert_To (Standard_Unsigned, Len);
830 -- If we cannot verify that range cannot be super-flat,
831 -- we need a max with zero, since length must be non-neg.
833 if not OK or else LLo < 0 then
835 Make_Attribute_Reference (Loc,
837 New_Occurrence_Of (Standard_Unsigned, Loc),
838 Attribute_Name => Name_Max,
839 Expressions => New_List (
840 Make_Integer_Literal (Loc, 0),
849 -- Here after processing all bounds to set sizes. If the value is
850 -- a constant, then it is bits, so we convert to storage units.
852 if Size.Status = Const then
853 return Bits_To_SU (Make_Integer_Literal (Loc, Size.Val));
855 -- Case where the value is dynamic
858 -- Do convert from bits to SU's if needed
860 if SU_Convert_Required then
862 -- The expression required is (Size.Nod + SU - 1) / SU
868 Left_Opnd => Size.Nod,
869 Right_Opnd => Make_Integer_Literal (Loc, SSU - 1)),
870 Right_Opnd => Make_Integer_Literal (Loc, SSU));
877 -----------------------
878 -- Layout_Array_Type --
879 -----------------------
881 procedure Layout_Array_Type (E : Entity_Id) is
882 Loc : constant Source_Ptr := Sloc (E);
883 Ctyp : constant Entity_Id := Component_Type (E);
891 Insert_Typ : Entity_Id;
892 -- This is the type with which any generated constants or functions
893 -- will be associated (i.e. inserted into the freeze actions). This
894 -- is normally the type being laid out. The exception occurs when
895 -- we are laying out Itype's which are local to a record type, and
896 -- whose scope is this record type. Such types do not have freeze
897 -- nodes (because we have no place to put them).
899 ------------------------------------
900 -- How An Array Type is Laid Out --
901 ------------------------------------
903 -- Here is what goes on. We need to multiply the component size of
904 -- the array (which has already been set) by the length of each of
905 -- the indexes. If all these values are known at compile time, then
906 -- the resulting size of the array is the appropriate constant value.
908 -- If the component size or at least one bound is dynamic (but no
909 -- discriminants are present), then the size will be computed as an
910 -- expression that calculates the proper size.
912 -- If there is at least one discriminant bound, then the size is also
913 -- computed as an expression, but this expression contains discriminant
914 -- values which are obtained by selecting from a function parameter, and
915 -- the size is given by a function that is passed the variant record in
916 -- question, and whose body is the expression.
918 type Val_Status_Type is (Const, Dynamic, Discrim);
920 type Val_Type (Status : Val_Status_Type := Const) is
925 -- Calculated value so far if Val_Status = Const
927 when Dynamic | Discrim =>
929 -- Expression value so far if Val_Status /= Const
933 -- Records the value or expression computed so far. Const means that
934 -- the value is constant, and Val is the current constant value.
935 -- Dynamic means that the value is dynamic, and in this case Nod is
936 -- the Node_Id of the expression to compute the value, and Discrim
937 -- means that at least one bound is a discriminant, in which case Nod
938 -- is the expression so far (which will be the body of the function).
941 -- Value of size computed so far. See comments above
943 Vtyp : Entity_Id := Empty;
944 -- Variant record type for the formal parameter of the
945 -- discriminant function V if Status = Discrim.
947 SU_Convert_Required : Boolean := False;
948 -- This is set to True if the final result must be converted from
949 -- bits to storage units (rounding up to a storage unit boundary).
951 Storage_Divisor : Uint := UI_From_Int (SSU);
952 -- This is the amount that a nonstatic computed size will be divided
953 -- by to convert it from bits to storage units. This is normally
954 -- equal to SSU, but can be reduced in the case of packed components
955 -- that fit evenly into a storage unit.
957 Make_Size_Function : Boolean := False;
958 -- Indicates whether to request that SO_Ref_From_Expr should
959 -- encapsulate the array size expresion in a function.
961 procedure Discrimify (N : in out Node_Id);
962 -- If N represents a discriminant, then the Size.Status is set to
963 -- Discrim, and Vtyp is set. The parameter N is replaced with the
964 -- proper expression to extract the discriminant value from V.
970 procedure Discrimify (N : in out Node_Id) is
975 if Nkind (N) = N_Identifier
976 and then Ekind (Entity (N)) = E_Discriminant
978 Set_Size_Depends_On_Discriminant (E);
980 if Size.Status /= Discrim then
981 Decl := Parent (Parent (Entity (N)));
982 Size := (Discrim, Size.Nod);
983 Vtyp := Defining_Identifier (Decl);
989 Make_Selected_Component (Loc,
990 Prefix => Make_Identifier (Loc, Chars => Vname),
991 Selector_Name => New_Occurrence_Of (Entity (N), Loc));
993 -- Set the Etype attributes of the selected name and its prefix.
994 -- Analyze_And_Resolve can't be called here because the Vname
995 -- entity denoted by the prefix will not yet exist (it's created
996 -- by SO_Ref_From_Expr, called at the end of Layout_Array_Type).
998 Set_Etype (Prefix (N), Vtyp);
1003 -- Start of processing for Layout_Array_Type
1006 -- Default alignment is component alignment
1008 if Unknown_Alignment (E) then
1009 Set_Alignment (E, Alignment (Ctyp));
1012 -- Calculate proper type for insertions
1014 if Is_Record_Type (Underlying_Type (Scope (E))) then
1015 Insert_Typ := Underlying_Type (Scope (E));
1020 -- If the component type is a generic formal type then there's no point
1021 -- in determining a size for the array type.
1023 if Is_Generic_Type (Ctyp) then
1027 -- Deal with component size if base type
1029 if Ekind (E) = E_Array_Type then
1031 -- Cannot do anything if Esize of component type unknown
1033 if Unknown_Esize (Ctyp) then
1037 -- Set component size if not set already
1039 if Unknown_Component_Size (E) then
1040 Set_Component_Size (E, Esize (Ctyp));
1044 -- (RM 13.3 (48)) says that the size of an unconstrained array
1045 -- is implementation defined. We choose to leave it as Unknown
1046 -- here, and the actual behavior is determined by the back end.
1048 if not Is_Constrained (E) then
1052 -- Initialize status from component size
1054 if Known_Static_Component_Size (E) then
1055 Size := (Const, Component_Size (E));
1058 Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
1061 -- Loop to process array indices
1063 Indx := First_Index (E);
1064 while Present (Indx) loop
1065 Ityp := Etype (Indx);
1067 -- If an index of the array is a generic formal type then there's
1068 -- no point in determining a size for the array type.
1070 if Is_Generic_Type (Ityp) then
1074 Lo := Type_Low_Bound (Ityp);
1075 Hi := Type_High_Bound (Ityp);
1077 -- Value of the current subscript range is statically known
1079 if Compile_Time_Known_Value (Lo)
1080 and then Compile_Time_Known_Value (Hi)
1082 S := Expr_Value (Hi) - Expr_Value (Lo) + 1;
1084 -- If known flat bound, entire size of array is zero!
1087 Set_Esize (E, Uint_0);
1088 Set_RM_Size (E, Uint_0);
1092 -- If constant, evolve value
1094 if Size.Status = Const then
1095 Size.Val := Size.Val * S;
1097 -- Current value is dynamic
1100 -- An interesting little optimization, if we have a pending
1101 -- conversion from bits to storage units, and the current
1102 -- length is a multiple of the storage unit size, then we
1103 -- can take the factor out here statically, avoiding some
1104 -- extra dynamic computations at the end.
1106 if SU_Convert_Required and then S mod SSU = 0 then
1108 SU_Convert_Required := False;
1111 -- Now go ahead and evolve the expression
1114 Assoc_Multiply (Loc,
1115 Left_Opnd => Size.Nod,
1117 Make_Integer_Literal (Loc, Intval => S));
1120 -- Value of the current subscript range is dynamic
1123 -- If the current size value is constant, then here is where we
1124 -- make a transition to dynamic values, which are always stored
1125 -- in storage units, However, we do not want to convert to SU's
1126 -- too soon, consider the case of a packed array of single bits,
1127 -- we want to do the SU conversion after computing the size in
1130 if Size.Status = Const then
1132 -- If the current value is a multiple of the storage unit,
1133 -- then most certainly we can do the conversion now, simply
1134 -- by dividing the current value by the storage unit value.
1135 -- If this works, we set SU_Convert_Required to False.
1137 if Size.Val mod SSU = 0 then
1139 (Dynamic, Make_Integer_Literal (Loc, Size.Val / SSU));
1140 SU_Convert_Required := False;
1142 -- If the current value is a factor of the storage unit,
1143 -- then we can use a value of one for the size and reduce
1144 -- the strength of the later division.
1146 elsif SSU mod Size.Val = 0 then
1147 Storage_Divisor := SSU / Size.Val;
1148 Size := (Dynamic, Make_Integer_Literal (Loc, Uint_1));
1149 SU_Convert_Required := True;
1151 -- Otherwise, we go ahead and convert the value in bits,
1152 -- and set SU_Convert_Required to True to ensure that the
1153 -- final value is indeed properly converted.
1156 Size := (Dynamic, Make_Integer_Literal (Loc, Size.Val));
1157 SU_Convert_Required := True;
1164 -- Length is hi-lo+1
1166 Len := Compute_Length (Lo, Hi);
1168 -- If Len isn't a Length attribute, then its range needs to
1169 -- be checked a possible Max with zero needs to be computed.
1171 if Nkind (Len) /= N_Attribute_Reference
1172 or else Attribute_Name (Len) /= Name_Length
1180 -- Check possible range of Len
1182 Set_Parent (Len, E);
1183 Determine_Range (Len, OK, LLo, LHi);
1185 Len := Convert_To (Standard_Unsigned, Len);
1187 -- If range definitely flat or superflat,
1188 -- result size is zero
1190 if OK and then LHi <= 0 then
1191 Set_Esize (E, Uint_0);
1192 Set_RM_Size (E, Uint_0);
1196 -- If we cannot verify that range cannot be super-flat,
1197 -- we need a maximum with zero, since length cannot be
1200 if not OK or else LLo < 0 then
1202 Make_Attribute_Reference (Loc,
1204 New_Occurrence_Of (Standard_Unsigned, Loc),
1205 Attribute_Name => Name_Max,
1206 Expressions => New_List (
1207 Make_Integer_Literal (Loc, 0),
1213 -- At this stage, Len has the expression for the length
1216 Assoc_Multiply (Loc,
1217 Left_Opnd => Size.Nod,
1224 -- Here after processing all bounds to set sizes. If the value is
1225 -- a constant, then it is bits, and the only thing we need to do
1226 -- is to check against explicit given size and do alignment adjust.
1228 if Size.Status = Const then
1229 Set_And_Check_Static_Size (E, Size.Val, Size.Val);
1230 Adjust_Esize_Alignment (E);
1232 -- Case where the value is dynamic
1235 -- Do convert from bits to SU's if needed
1237 if SU_Convert_Required then
1239 -- The expression required is:
1240 -- (Size.Nod + Storage_Divisor - 1) / Storage_Divisor
1243 Make_Op_Divide (Loc,
1246 Left_Opnd => Size.Nod,
1247 Right_Opnd => Make_Integer_Literal
1248 (Loc, Storage_Divisor - 1)),
1249 Right_Opnd => Make_Integer_Literal (Loc, Storage_Divisor));
1252 -- If the array entity is not declared at the library level and its
1253 -- not nested within a subprogram that is marked for inlining, then
1254 -- we request that the size expression be encapsulated in a function.
1255 -- Since this expression is not needed in most cases, we prefer not
1256 -- to incur the overhead of the computation on calls to the enclosing
1257 -- subprogram except for subprograms that require the size.
1259 if not Is_Library_Level_Entity (E) then
1260 Make_Size_Function := True;
1263 Parent_Subp : Entity_Id := Enclosing_Subprogram (E);
1266 while Present (Parent_Subp) loop
1267 if Is_Inlined (Parent_Subp) then
1268 Make_Size_Function := False;
1272 Parent_Subp := Enclosing_Subprogram (Parent_Subp);
1277 -- Now set the dynamic size (the Value_Size is always the same
1278 -- as the Object_Size for arrays whose length is dynamic).
1280 -- ??? If Size.Status = Dynamic, Vtyp will not have been set.
1281 -- The added initialization sets it to Empty now, but is this
1287 (Size.Nod, Insert_Typ, Vtyp, Make_Func => Make_Size_Function));
1288 Set_RM_Size (E, Esize (E));
1290 end Layout_Array_Type;
1296 procedure Layout_Object (E : Entity_Id) is
1297 T : constant Entity_Id := Etype (E);
1300 -- Nothing to do if backend does layout
1302 if not Frontend_Layout_On_Target then
1306 -- Set size if not set for object and known for type. Use the
1307 -- RM_Size if that is known for the type and Esize is not.
1309 if Unknown_Esize (E) then
1310 if Known_Esize (T) then
1311 Set_Esize (E, Esize (T));
1313 elsif Known_RM_Size (T) then
1314 Set_Esize (E, RM_Size (T));
1318 -- Set alignment from type if unknown and type alignment known
1320 if Unknown_Alignment (E) and then Known_Alignment (T) then
1321 Set_Alignment (E, Alignment (T));
1324 -- Make sure size and alignment are consistent
1326 Adjust_Esize_Alignment (E);
1328 -- Final adjustment, if we don't know the alignment, and the Esize
1329 -- was not set by an explicit Object_Size attribute clause, then
1330 -- we reset the Esize to unknown, since we really don't know it.
1332 if Unknown_Alignment (E)
1333 and then not Has_Size_Clause (E)
1335 Set_Esize (E, Uint_0);
1339 ------------------------
1340 -- Layout_Record_Type --
1341 ------------------------
1343 procedure Layout_Record_Type (E : Entity_Id) is
1344 Loc : constant Source_Ptr := Sloc (E);
1348 -- Current component being laid out
1350 Prev_Comp : Entity_Id;
1351 -- Previous laid out component
1353 procedure Get_Next_Component_Location
1354 (Prev_Comp : Entity_Id;
1356 New_Npos : out SO_Ref;
1357 New_Fbit : out SO_Ref;
1358 New_NPMax : out SO_Ref;
1359 Force_SU : Boolean);
1360 -- Given the previous component in Prev_Comp, which is already laid
1361 -- out, and the alignment of the following component, lays out the
1362 -- following component, and returns its starting position in New_Npos
1363 -- (Normalized_Position value), New_Fbit (Normalized_First_Bit value),
1364 -- and New_NPMax (Normalized_Position_Max value). If Prev_Comp is empty
1365 -- (no previous component is present), then New_Npos, New_Fbit and
1366 -- New_NPMax are all set to zero on return. This procedure is also
1367 -- used to compute the size of a record or variant by giving it the
1368 -- last component, and the record alignment. Force_SU is used to force
1369 -- the new component location to be aligned on a storage unit boundary,
1370 -- even in a packed record, False means that the new position does not
1371 -- need to be bumped to a storage unit boundary, True means a storage
1372 -- unit boundary is always required.
1374 procedure Layout_Component (Comp : Entity_Id; Prev_Comp : Entity_Id);
1375 -- Lays out component Comp, given Prev_Comp, the previously laid-out
1376 -- component (Prev_Comp = Empty if no components laid out yet). The
1377 -- alignment of the record itself is also updated if needed. Both
1378 -- Comp and Prev_Comp can be either components or discriminants.
1380 procedure Layout_Components
1384 RM_Siz : out SO_Ref);
1385 -- This procedure lays out the components of the given component list
1386 -- which contains the components starting with From and ending with To.
1387 -- The Next_Entity chain is used to traverse the components. On entry,
1388 -- Prev_Comp is set to the component preceding the list, so that the
1389 -- list is laid out after this component. Prev_Comp is set to Empty if
1390 -- the component list is to be laid out starting at the start of the
1391 -- record. On return, the components are all laid out, and Prev_Comp is
1392 -- set to the last laid out component. On return, Esiz is set to the
1393 -- resulting Object_Size value, which is the length of the record up
1394 -- to and including the last laid out entity. For Esiz, the value is
1395 -- adjusted to match the alignment of the record. RM_Siz is similarly
1396 -- set to the resulting Value_Size value, which is the same length, but
1397 -- not adjusted to meet the alignment. Note that in the case of variant
1398 -- records, Esiz represents the maximum size.
1400 procedure Layout_Non_Variant_Record;
1401 -- Procedure called to lay out a non-variant record type or subtype
1403 procedure Layout_Variant_Record;
1404 -- Procedure called to lay out a variant record type. Decl is set to the
1405 -- full type declaration for the variant record.
1407 ---------------------------------
1408 -- Get_Next_Component_Location --
1409 ---------------------------------
1411 procedure Get_Next_Component_Location
1412 (Prev_Comp : Entity_Id;
1414 New_Npos : out SO_Ref;
1415 New_Fbit : out SO_Ref;
1416 New_NPMax : out SO_Ref;
1420 -- No previous component, return zero position
1422 if No (Prev_Comp) then
1425 New_NPMax := Uint_0;
1429 -- Here we have a previous component
1432 Loc : constant Source_Ptr := Sloc (Prev_Comp);
1434 Old_Npos : constant SO_Ref := Normalized_Position (Prev_Comp);
1435 Old_Fbit : constant SO_Ref := Normalized_First_Bit (Prev_Comp);
1436 Old_NPMax : constant SO_Ref := Normalized_Position_Max (Prev_Comp);
1437 Old_Esiz : constant SO_Ref := Esize (Prev_Comp);
1439 Old_Maxsz : Node_Id;
1440 -- Expression representing maximum size of previous component
1443 -- Case where previous field had a dynamic size
1445 if Is_Dynamic_SO_Ref (Esize (Prev_Comp)) then
1447 -- If the previous field had a dynamic length, then it is
1448 -- required to occupy an integral number of storage units,
1449 -- and start on a storage unit boundary. This means that
1450 -- the Normalized_First_Bit value is zero in the previous
1451 -- component, and the new value is also set to zero.
1455 -- In this case, the new position is given by an expression
1456 -- that is the sum of old normalized position and old size.
1462 Expr_From_SO_Ref (Loc, Old_Npos),
1464 Expr_From_SO_Ref (Loc, Old_Esiz, Prev_Comp)),
1468 -- Get maximum size of previous component
1470 if Size_Depends_On_Discriminant (Etype (Prev_Comp)) then
1471 Old_Maxsz := Get_Max_SU_Size (Etype (Prev_Comp));
1473 Old_Maxsz := Expr_From_SO_Ref (Loc, Old_Esiz, Prev_Comp);
1476 -- Now we can compute the new max position. If the max size
1477 -- is static and the old position is static, then we can
1478 -- compute the new position statically.
1480 if Nkind (Old_Maxsz) = N_Integer_Literal
1481 and then Known_Static_Normalized_Position_Max (Prev_Comp)
1483 New_NPMax := Old_NPMax + Intval (Old_Maxsz);
1485 -- Otherwise new max position is dynamic
1491 Left_Opnd => Expr_From_SO_Ref (Loc, Old_NPMax),
1492 Right_Opnd => Old_Maxsz),
1497 -- Previous field has known static Esize
1500 New_Fbit := Old_Fbit + Old_Esiz;
1502 -- Bump New_Fbit to storage unit boundary if required
1504 if New_Fbit /= 0 and then Force_SU then
1505 New_Fbit := (New_Fbit + SSU - 1) / SSU * SSU;
1508 -- If old normalized position is static, we can go ahead
1509 -- and compute the new normalized position directly.
1511 if Known_Static_Normalized_Position (Prev_Comp) then
1512 New_Npos := Old_Npos;
1514 if New_Fbit >= SSU then
1515 New_Npos := New_Npos + New_Fbit / SSU;
1516 New_Fbit := New_Fbit mod SSU;
1519 -- Bump alignment if stricter than prev
1521 if Align > Alignment (Etype (Prev_Comp)) then
1522 New_Npos := (New_Npos + Align - 1) / Align * Align;
1525 -- The max position is always equal to the position if
1526 -- the latter is static, since arrays depending on the
1527 -- values of discriminants never have static sizes.
1529 New_NPMax := New_Npos;
1532 -- Case of old normalized position is dynamic
1535 -- If new bit position is within the current storage unit,
1536 -- we can just copy the old position as the result position
1537 -- (we have already set the new first bit value).
1539 if New_Fbit < SSU then
1540 New_Npos := Old_Npos;
1541 New_NPMax := Old_NPMax;
1543 -- If new bit position is past the current storage unit, we
1544 -- need to generate a new dynamic value for the position
1545 -- ??? need to deal with alignment
1551 Left_Opnd => Expr_From_SO_Ref (Loc, Old_Npos),
1553 Make_Integer_Literal (Loc,
1554 Intval => New_Fbit / SSU)),
1561 Left_Opnd => Expr_From_SO_Ref (Loc, Old_NPMax),
1563 Make_Integer_Literal (Loc,
1564 Intval => New_Fbit / SSU)),
1567 New_Fbit := New_Fbit mod SSU;
1572 end Get_Next_Component_Location;
1574 ----------------------
1575 -- Layout_Component --
1576 ----------------------
1578 procedure Layout_Component (Comp : Entity_Id; Prev_Comp : Entity_Id) is
1579 Ctyp : constant Entity_Id := Etype (Comp);
1580 ORC : constant Entity_Id := Original_Record_Component (Comp);
1587 -- Increase alignment of record if necessary. Note that we do not
1588 -- do this for packed records, which have an alignment of one by
1589 -- default, or for records for which an explicit alignment was
1590 -- specified with an alignment clause.
1592 if not Is_Packed (E)
1593 and then not Has_Alignment_Clause (E)
1594 and then Alignment (Ctyp) > Alignment (E)
1596 Set_Alignment (E, Alignment (Ctyp));
1599 -- If original component set, then use same layout
1601 if Present (ORC) and then ORC /= Comp then
1602 Set_Normalized_Position (Comp, Normalized_Position (ORC));
1603 Set_Normalized_First_Bit (Comp, Normalized_First_Bit (ORC));
1604 Set_Normalized_Position_Max (Comp, Normalized_Position_Max (ORC));
1605 Set_Component_Bit_Offset (Comp, Component_Bit_Offset (ORC));
1606 Set_Esize (Comp, Esize (ORC));
1610 -- Parent field is always at start of record, this will overlap
1611 -- the actual fields that are part of the parent, and that's fine
1613 if Chars (Comp) = Name_uParent then
1614 Set_Normalized_Position (Comp, Uint_0);
1615 Set_Normalized_First_Bit (Comp, Uint_0);
1616 Set_Normalized_Position_Max (Comp, Uint_0);
1617 Set_Component_Bit_Offset (Comp, Uint_0);
1618 Set_Esize (Comp, Esize (Ctyp));
1622 -- Check case of type of component has a scope of the record we
1623 -- are laying out. When this happens, the type in question is an
1624 -- Itype that has not yet been laid out (that's because such
1625 -- types do not get frozen in the normal manner, because there
1626 -- is no place for the freeze nodes).
1628 if Scope (Ctyp) = E then
1632 -- If component already laid out, then we are done
1634 if Known_Normalized_Position (Comp) then
1638 -- Set size of component from type. We use the Esize except in a
1639 -- packed record, where we use the RM_Size (since that is exactly
1640 -- what the RM_Size value, as distinct from the Object_Size is
1643 if Is_Packed (E) then
1644 Set_Esize (Comp, RM_Size (Ctyp));
1646 Set_Esize (Comp, Esize (Ctyp));
1649 -- Compute the component position from the previous one. See if
1650 -- current component requires being on a storage unit boundary.
1652 -- If record is not packed, we always go to a storage unit boundary
1654 if not Is_Packed (E) then
1660 -- Elementary types do not need SU boundary in packed record
1662 if Is_Elementary_Type (Ctyp) then
1665 -- Packed array types with a modular packed array type do not
1666 -- force a storage unit boundary (since the code generation
1667 -- treats these as equivalent to the underlying modular type),
1669 elsif Is_Array_Type (Ctyp)
1670 and then Is_Bit_Packed_Array (Ctyp)
1671 and then Is_Modular_Integer_Type (Packed_Array_Type (Ctyp))
1675 -- Record types with known length less than or equal to the length
1676 -- of long long integer can also be unaligned, since they can be
1677 -- treated as scalars.
1679 elsif Is_Record_Type (Ctyp)
1680 and then not Is_Dynamic_SO_Ref (Esize (Ctyp))
1681 and then Esize (Ctyp) <= Esize (Standard_Long_Long_Integer)
1685 -- All other cases force a storage unit boundary, even when packed
1692 -- Now get the next component location
1694 Get_Next_Component_Location
1695 (Prev_Comp, Alignment (Ctyp), Npos, Fbit, NPMax, Forc);
1696 Set_Normalized_Position (Comp, Npos);
1697 Set_Normalized_First_Bit (Comp, Fbit);
1698 Set_Normalized_Position_Max (Comp, NPMax);
1700 -- Set Component_Bit_Offset in the static case
1702 if Known_Static_Normalized_Position (Comp)
1703 and then Known_Normalized_First_Bit (Comp)
1705 Set_Component_Bit_Offset (Comp, SSU * Npos + Fbit);
1707 end Layout_Component;
1709 -----------------------
1710 -- Layout_Components --
1711 -----------------------
1713 procedure Layout_Components
1717 RM_Siz : out SO_Ref)
1724 -- Only lay out components if there are some to lay out!
1726 if Present (From) then
1728 -- Lay out components with no component clauses
1732 if Ekind (Comp) = E_Component
1733 or else Ekind (Comp) = E_Discriminant
1735 -- The compatibility of component clauses with composite
1736 -- types isn't checked in Sem_Ch13, so we check it here.
1738 if Present (Component_Clause (Comp)) then
1739 if Is_Composite_Type (Etype (Comp))
1740 and then Esize (Comp) < RM_Size (Etype (Comp))
1742 Error_Msg_Uint_1 := RM_Size (Etype (Comp));
1744 ("size for & too small, minimum allowed is ^",
1745 Component_Clause (Comp),
1750 Layout_Component (Comp, Prev_Comp);
1755 exit when Comp = To;
1760 -- Set size fields, both are zero if no components
1762 if No (Prev_Comp) then
1766 -- If record subtype with non-static discriminants, then we don't
1767 -- know which variant will be the one which gets chosen. We don't
1768 -- just want to set the maximum size from the base, because the
1769 -- size should depend on the particular variant.
1771 -- What we do is to use the RM_Size of the base type, which has
1772 -- the necessary conditional computation of the size, using the
1773 -- size information for the particular variant chosen. Records
1774 -- with default discriminants for example have an Esize that is
1775 -- set to the maximum of all variants, but that's not what we
1776 -- want for a constrained subtype.
1778 elsif Ekind (E) = E_Record_Subtype
1779 and then not Has_Static_Discriminants (E)
1782 BT : constant Node_Id := Base_Type (E);
1784 Esiz := RM_Size (BT);
1785 RM_Siz := RM_Size (BT);
1786 Set_Alignment (E, Alignment (BT));
1790 -- First the object size, for which we align past the last field
1791 -- to the alignment of the record (the object size is required to
1792 -- be a multiple of the alignment).
1794 Get_Next_Component_Location
1802 -- If the resulting normalized position is a dynamic reference,
1803 -- then the size is dynamic, and is stored in storage units. In
1804 -- this case, we set the RM_Size to the same value, it is simply
1805 -- not worth distinguishing Esize and RM_Size values in the
1806 -- dynamic case, since the RM has nothing to say about them.
1808 -- Note that a size cannot have been given in this case, since
1809 -- size specifications cannot be given for variable length types.
1812 Align : constant Uint := Alignment (E);
1815 if Is_Dynamic_SO_Ref (End_Npos) then
1818 -- Set the Object_Size allowing for the alignment. In the
1819 -- dynamic case, we must do the actual runtime computation.
1820 -- We can skip this in the non-packed record case if the
1821 -- last component has a smaller alignment than the overall
1822 -- record alignment.
1824 if Is_Dynamic_SO_Ref (End_NPMax) then
1828 or else Alignment (Etype (Prev_Comp)) < Align
1830 -- The expression we build is:
1831 -- (expr + align - 1) / align * align
1836 Make_Op_Multiply (Loc,
1838 Make_Op_Divide (Loc,
1842 Expr_From_SO_Ref (Loc, Esiz),
1844 Make_Integer_Literal (Loc,
1845 Intval => Align - 1)),
1847 Make_Integer_Literal (Loc, Align)),
1849 Make_Integer_Literal (Loc, Align)),
1854 -- Here Esiz is static, so we can adjust the alignment
1855 -- directly go give the required aligned value.
1858 Esiz := (End_NPMax + Align - 1) / Align * Align * SSU;
1861 -- Case where computed size is static
1864 -- The ending size was computed in Npos in storage units,
1865 -- but the actual size is stored in bits, so adjust
1866 -- accordingly. We also adjust the size to match the
1869 Esiz := (End_NPMax + Align - 1) / Align * Align * SSU;
1871 -- Compute the resulting Value_Size (RM_Size). For this
1872 -- purpose we do not force alignment of the record or
1873 -- storage size alignment of the result.
1875 Get_Next_Component_Location
1883 RM_Siz := End_Npos * SSU + End_Fbit;
1884 Set_And_Check_Static_Size (E, Esiz, RM_Siz);
1888 end Layout_Components;
1890 -------------------------------
1891 -- Layout_Non_Variant_Record --
1892 -------------------------------
1894 procedure Layout_Non_Variant_Record is
1898 Layout_Components (First_Entity (E), Last_Entity (E), Esiz, RM_Siz);
1899 Set_Esize (E, Esiz);
1900 Set_RM_Size (E, RM_Siz);
1901 end Layout_Non_Variant_Record;
1903 ---------------------------
1904 -- Layout_Variant_Record --
1905 ---------------------------
1907 procedure Layout_Variant_Record is
1908 Tdef : constant Node_Id := Type_Definition (Decl);
1909 First_Discr : Entity_Id;
1910 Last_Discr : Entity_Id;
1914 RM_Siz_Expr : Node_Id := Empty;
1915 -- Expression for the evolving RM_Siz value. This is typically a
1916 -- conditional expression which involves tests of discriminant
1917 -- values that are formed as references to the entity V. At
1918 -- the end of scanning all the components, a suitable function
1919 -- is constructed in which V is the parameter.
1921 -----------------------
1922 -- Local Subprograms --
1923 -----------------------
1925 procedure Layout_Component_List
1928 RM_Siz_Expr : out Node_Id);
1929 -- Recursive procedure, called to lay out one component list
1930 -- Esiz and RM_Siz_Expr are set to the Object_Size and Value_Size
1931 -- values respectively representing the record size up to and
1932 -- including the last component in the component list (including
1933 -- any variants in this component list). RM_Siz_Expr is returned
1934 -- as an expression which may in the general case involve some
1935 -- references to the discriminants of the current record value,
1936 -- referenced by selecting from the entity V.
1938 ---------------------------
1939 -- Layout_Component_List --
1940 ---------------------------
1942 procedure Layout_Component_List
1945 RM_Siz_Expr : out Node_Id)
1947 Citems : constant List_Id := Component_Items (Clist);
1948 Vpart : constant Node_Id := Variant_Part (Clist);
1952 RMS_Ent : Entity_Id;
1955 if Is_Non_Empty_List (Citems) then
1957 (From => Defining_Identifier (First (Citems)),
1958 To => Defining_Identifier (Last (Citems)),
1962 Layout_Components (Empty, Empty, Esiz, RM_Siz);
1965 -- Case where no variants are present in the component list
1969 -- The Esiz value has been correctly set by the call to
1970 -- Layout_Components, so there is nothing more to be done.
1972 -- For RM_Siz, we have an SO_Ref value, which we must convert
1973 -- to an appropriate expression.
1975 if Is_Static_SO_Ref (RM_Siz) then
1977 Make_Integer_Literal (Loc,
1981 RMS_Ent := Get_Dynamic_SO_Entity (RM_Siz);
1983 -- If the size is represented by a function, then we
1984 -- create an appropriate function call using V as
1985 -- the parameter to the call.
1987 if Is_Discrim_SO_Function (RMS_Ent) then
1989 Make_Function_Call (Loc,
1990 Name => New_Occurrence_Of (RMS_Ent, Loc),
1991 Parameter_Associations => New_List (
1992 Make_Identifier (Loc, Chars => Vname)));
1994 -- If the size is represented by a constant, then the
1995 -- expression we want is a reference to this constant
1998 RM_Siz_Expr := New_Occurrence_Of (RMS_Ent, Loc);
2002 -- Case where variants are present in this component list
2012 D_Entity : Entity_Id;
2015 RM_Siz_Expr := Empty;
2018 Var := Last (Variants (Vpart));
2019 while Present (Var) loop
2021 Layout_Component_List
2022 (Component_List (Var), EsizV, RM_SizV);
2024 -- Set the Object_Size. If this is the first variant,
2025 -- we just set the size of this first variant.
2027 if Var = Last (Variants (Vpart)) then
2030 -- Otherwise the Object_Size is formed as a maximum
2031 -- of Esiz so far from previous variants, and the new
2032 -- Esiz value from the variant we just processed.
2034 -- If both values are static, we can just compute the
2035 -- maximum directly to save building junk nodes.
2037 elsif not Is_Dynamic_SO_Ref (Esiz)
2038 and then not Is_Dynamic_SO_Ref (EsizV)
2040 Esiz := UI_Max (Esiz, EsizV);
2042 -- If either value is dynamic, then we have to generate
2043 -- an appropriate Standard_Unsigned'Max attribute call.
2044 -- If one of the values is static then it needs to be
2045 -- converted from bits to storage units to be compatible
2046 -- with the dynamic value.
2049 if Is_Static_SO_Ref (Esiz) then
2050 Esiz := (Esiz + SSU - 1) / SSU;
2053 if Is_Static_SO_Ref (EsizV) then
2054 EsizV := (EsizV + SSU - 1) / SSU;
2059 (Make_Attribute_Reference (Loc,
2060 Attribute_Name => Name_Max,
2062 New_Occurrence_Of (Standard_Unsigned, Loc),
2063 Expressions => New_List (
2064 Expr_From_SO_Ref (Loc, Esiz),
2065 Expr_From_SO_Ref (Loc, EsizV))),
2070 -- Now deal with Value_Size (RM_Siz). We are aiming at
2071 -- an expression that looks like:
2073 -- if xxDx (V.disc) then rmsiz1
2074 -- else if xxDx (V.disc) then rmsiz2
2077 -- Where rmsiz1, rmsiz2... are the RM_Siz values for the
2078 -- individual variants, and xxDx are the discriminant
2079 -- checking functions generated for the variant type.
2081 -- If this is the first variant, we simply set the
2082 -- result as the expression. Note that this takes
2083 -- care of the others case.
2085 if No (RM_Siz_Expr) then
2086 RM_Siz_Expr := Bits_To_SU (RM_SizV);
2088 -- Otherwise construct the appropriate test
2091 -- The test to be used in general is a call to the
2092 -- discriminant checking function. However, it is
2093 -- definitely worth special casing the very common
2094 -- case where a single value is involved.
2096 Dchoice := First (Discrete_Choices (Var));
2098 if No (Next (Dchoice))
2099 and then Nkind (Dchoice) /= N_Range
2101 -- Discriminant to be tested
2104 Make_Selected_Component (Loc,
2106 Make_Identifier (Loc, Chars => Vname),
2109 (Entity (Name (Vpart)), Loc));
2113 Left_Opnd => Discrim,
2114 Right_Opnd => New_Copy (Dchoice));
2116 -- Generate a call to the discriminant-checking
2117 -- function for the variant. Note that the result
2118 -- has to be complemented since the function returns
2119 -- False when the passed discriminant value matches.
2122 -- The checking function takes all of the type's
2123 -- discriminants as parameters, so a list of all
2124 -- the selected discriminants must be constructed.
2127 D_Entity := First_Discriminant (E);
2128 while Present (D_Entity) loop
2130 Make_Selected_Component (Loc,
2132 Make_Identifier (Loc, Chars => Vname),
2138 D_Entity := Next_Discriminant (D_Entity);
2144 Make_Function_Call (Loc,
2147 (Dcheck_Function (Var), Loc),
2148 Parameter_Associations =>
2153 Make_Conditional_Expression (Loc,
2156 (Dtest, Bits_To_SU (RM_SizV), RM_Siz_Expr));
2163 end Layout_Component_List;
2165 -- Start of processing for Layout_Variant_Record
2168 -- We need the discriminant checking functions, since we generate
2169 -- calls to these functions for the RM_Size expression, so make
2170 -- sure that these functions have been constructed in time.
2172 Build_Discr_Checking_Funcs (Decl);
2174 -- Lay out the discriminants
2176 First_Discr := First_Discriminant (E);
2177 Last_Discr := First_Discr;
2178 while Present (Next_Discriminant (Last_Discr)) loop
2179 Next_Discriminant (Last_Discr);
2183 (From => First_Discr,
2188 -- Lay out the main component list (this will make recursive calls
2189 -- to lay out all component lists nested within variants).
2191 Layout_Component_List (Component_List (Tdef), Esiz, RM_Siz_Expr);
2192 Set_Esize (E, Esiz);
2194 -- If the RM_Size is a literal, set its value
2196 if Nkind (RM_Siz_Expr) = N_Integer_Literal then
2197 Set_RM_Size (E, Intval (RM_Siz_Expr));
2199 -- Otherwise we construct a dynamic SO_Ref
2208 end Layout_Variant_Record;
2210 -- Start of processing for Layout_Record_Type
2213 -- If this is a cloned subtype, just copy the size fields from the
2214 -- original, nothing else needs to be done in this case, since the
2215 -- components themselves are all shared.
2217 if (Ekind (E) = E_Record_Subtype
2219 Ekind (E) = E_Class_Wide_Subtype)
2220 and then Present (Cloned_Subtype (E))
2222 Set_Esize (E, Esize (Cloned_Subtype (E)));
2223 Set_RM_Size (E, RM_Size (Cloned_Subtype (E)));
2224 Set_Alignment (E, Alignment (Cloned_Subtype (E)));
2226 -- Another special case, class-wide types. The RM says that the size
2227 -- of such types is implementation defined (RM 13.3(48)). What we do
2228 -- here is to leave the fields set as unknown values, and the backend
2229 -- determines the actual behavior.
2231 elsif Ekind (E) = E_Class_Wide_Type then
2237 -- Initialize alignment conservatively to 1. This value will
2238 -- be increased as necessary during processing of the record.
2240 if Unknown_Alignment (E) then
2241 Set_Alignment (E, Uint_1);
2244 -- Initialize previous component. This is Empty unless there
2245 -- are components which have already been laid out by component
2246 -- clauses. If there are such components, we start our lay out of
2247 -- the remaining components following the last such component.
2251 Comp := First_Component_Or_Discriminant (E);
2252 while Present (Comp) loop
2253 if Present (Component_Clause (Comp)) then
2256 Component_Bit_Offset (Comp) >
2257 Component_Bit_Offset (Prev_Comp)
2263 Next_Component_Or_Discriminant (Comp);
2266 -- We have two separate circuits, one for non-variant records and
2267 -- one for variant records. For non-variant records, we simply go
2268 -- through the list of components. This handles all the non-variant
2269 -- cases including those cases of subtypes where there is no full
2270 -- type declaration, so the tree cannot be used to drive the layout.
2271 -- For variant records, we have to drive the layout from the tree
2272 -- since we need to understand the variant structure in this case.
2274 if Present (Full_View (E)) then
2275 Decl := Declaration_Node (Full_View (E));
2277 Decl := Declaration_Node (E);
2280 -- Scan all the components
2282 if Nkind (Decl) = N_Full_Type_Declaration
2283 and then Has_Discriminants (E)
2284 and then Nkind (Type_Definition (Decl)) = N_Record_Definition
2285 and then Present (Component_List (Type_Definition (Decl)))
2287 Present (Variant_Part (Component_List (Type_Definition (Decl))))
2289 Layout_Variant_Record;
2291 Layout_Non_Variant_Record;
2294 end Layout_Record_Type;
2300 procedure Layout_Type (E : Entity_Id) is
2302 -- For string literal types, for now, kill the size always, this
2303 -- is because gigi does not like or need the size to be set ???
2305 if Ekind (E) = E_String_Literal_Subtype then
2306 Set_Esize (E, Uint_0);
2307 Set_RM_Size (E, Uint_0);
2311 -- For access types, set size/alignment. This is system address
2312 -- size, except for fat pointers (unconstrained array access types),
2313 -- where the size is two times the address size, to accommodate the
2314 -- two pointers that are required for a fat pointer (data and
2315 -- template). Note that E_Access_Protected_Subprogram_Type is not
2316 -- an access type for this purpose since it is not a pointer but is
2317 -- equivalent to a record. For access subtypes, copy the size from
2318 -- the base type since Gigi represents them the same way.
2320 if Is_Access_Type (E) then
2322 -- If Esize already set (e.g. by a size clause), then nothing
2323 -- further to be done here.
2325 if Known_Esize (E) then
2328 -- Access to subprogram is a strange beast, and we let the
2329 -- backend figure out what is needed (it may be some kind
2330 -- of fat pointer, including the static link for example.
2332 elsif Is_Access_Protected_Subprogram_Type (E) then
2335 -- For access subtypes, copy the size information from base type
2337 elsif Ekind (E) = E_Access_Subtype then
2338 Set_Size_Info (E, Base_Type (E));
2339 Set_RM_Size (E, RM_Size (Base_Type (E)));
2341 -- For other access types, we use either address size, or, if
2342 -- a fat pointer is used (pointer-to-unconstrained array case),
2343 -- twice the address size to accommodate a fat pointer.
2347 Desig : Entity_Id := Designated_Type (E);
2350 if Is_Private_Type (Desig)
2351 and then Present (Full_View (Desig))
2353 Desig := Full_View (Desig);
2356 if Is_Array_Type (Desig)
2357 and then not Is_Constrained (Desig)
2358 and then not Has_Completion_In_Body (Desig)
2359 and then not Debug_Flag_6
2361 Init_Size (E, 2 * System_Address_Size);
2363 -- Check for bad convention set
2365 if Warn_On_Export_Import
2367 (Convention (E) = Convention_C
2369 Convention (E) = Convention_CPP)
2372 ("?this access type does not " &
2373 "correspond to C pointer", E);
2376 -- When the target is AAMP, access-to-subprogram types are fat
2377 -- pointers consisting of the subprogram address and a static
2378 -- link (with the exception of library-level access types,
2379 -- where a simple subprogram address is used).
2381 elsif AAMP_On_Target
2383 (Ekind (E) = E_Anonymous_Access_Subprogram_Type
2384 or else (Ekind (E) = E_Access_Subprogram_Type
2385 and then Present (Enclosing_Subprogram (E))))
2387 Init_Size (E, 2 * System_Address_Size);
2390 Init_Size (E, System_Address_Size);
2395 -- On VMS, reset size to 32 for convention C access type if no
2396 -- explicit size clause is given and the default size is 64. Really
2397 -- we do not know the size, since depending on options for the VMS
2398 -- compiler, the size of a pointer type can be 32 or 64, but choosing
2399 -- 32 as the default improves compatibility with legacy VMS code.
2401 -- Note: we do not use Has_Size_Clause in the test below, because we
2402 -- want to catch the case of a derived type inheriting a size clause.
2403 -- We want to consider this to be an explicit size clause for this
2404 -- purpose, since it would be weird not to inherit the size in this
2407 if OpenVMS_On_Target
2408 and then (Convention (E) = Convention_C
2410 Convention (E) = Convention_CPP)
2411 and then No (Get_Attribute_Definition_Clause (E, Attribute_Size))
2412 and then Esize (E) = 64
2417 Set_Elem_Alignment (E);
2419 -- Scalar types: set size and alignment
2421 elsif Is_Scalar_Type (E) then
2423 -- For discrete types, the RM_Size and Esize must be set
2424 -- already, since this is part of the earlier processing
2425 -- and the front end is always required to lay out the
2426 -- sizes of such types (since they are available as static
2427 -- attributes). All we do is to check that this rule is
2430 if Is_Discrete_Type (E) then
2432 -- If the RM_Size is not set, then here is where we set it
2434 -- Note: an RM_Size of zero looks like not set here, but this
2435 -- is a rare case, and we can simply reset it without any harm.
2437 if not Known_RM_Size (E) then
2438 Set_Discrete_RM_Size (E);
2441 -- If Esize for a discrete type is not set then set it
2443 if not Known_Esize (E) then
2449 -- If size is big enough, set it and exit
2451 if S >= RM_Size (E) then
2455 -- If the RM_Size is greater than 64 (happens only
2456 -- when strange values are specified by the user,
2457 -- then Esize is simply a copy of RM_Size, it will
2458 -- be further refined later on)
2461 Set_Esize (E, RM_Size (E));
2464 -- Otherwise double possible size and keep trying
2473 -- For non-discrete sclar types, if the RM_Size is not set,
2474 -- then set it now to a copy of the Esize if the Esize is set.
2477 if Known_Esize (E) and then Unknown_RM_Size (E) then
2478 Set_RM_Size (E, Esize (E));
2482 Set_Elem_Alignment (E);
2484 -- Non-elementary (composite) types
2487 -- If RM_Size is known, set Esize if not known
2489 if Known_RM_Size (E) and then Unknown_Esize (E) then
2491 -- If the alignment is known, we bump the Esize up to the
2492 -- next alignment boundary if it is not already on one.
2494 if Known_Alignment (E) then
2496 A : constant Uint := Alignment_In_Bits (E);
2497 S : constant SO_Ref := RM_Size (E);
2499 Set_Esize (E, (S + A - 1) / A * A);
2503 -- If Esize is set, and RM_Size is not, RM_Size is copied from
2504 -- Esize at least for now this seems reasonable, and is in any
2505 -- case needed for compatibility with old versions of gigi.
2506 -- look to be unknown.
2508 elsif Known_Esize (E) and then Unknown_RM_Size (E) then
2509 Set_RM_Size (E, Esize (E));
2512 -- For array base types, set component size if object size of
2513 -- the component type is known and is a small power of 2 (8,
2514 -- 16, 32, 64), since this is what will always be used.
2516 if Ekind (E) = E_Array_Type
2517 and then Unknown_Component_Size (E)
2520 CT : constant Entity_Id := Component_Type (E);
2523 -- For some reasons, access types can cause trouble,
2524 -- So let's just do this for discrete types ???
2527 and then Is_Discrete_Type (CT)
2528 and then Known_Static_Esize (CT)
2531 S : constant Uint := Esize (CT);
2539 Set_Component_Size (E, Esize (CT));
2547 -- Lay out array and record types if front end layout set
2549 if Frontend_Layout_On_Target then
2550 if Is_Array_Type (E) and then not Is_Bit_Packed_Array (E) then
2551 Layout_Array_Type (E);
2552 elsif Is_Record_Type (E) then
2553 Layout_Record_Type (E);
2556 -- Case of backend layout, we still do a little in the front end
2559 -- Processing for record types
2561 if Is_Record_Type (E) then
2563 -- Special remaining processing for record types with a known
2564 -- size of 16, 32, or 64 bits whose alignment is not yet set.
2565 -- For these types, we set a corresponding alignment matching
2566 -- the size if possible, or as large as possible if not.
2568 if Convention (E) = Convention_Ada
2569 and then not Debug_Flag_Q
2571 Set_Composite_Alignment (E);
2574 -- Procressing for array types
2576 elsif Is_Array_Type (E) then
2578 -- For arrays that are required to be atomic, we do the same
2579 -- processing as described above for short records, since we
2580 -- really need to have the alignment set for the whole array.
2582 if Is_Atomic (E) and then not Debug_Flag_Q then
2583 Set_Composite_Alignment (E);
2586 -- For unpacked array types, set an alignment of 1 if we know
2587 -- that the component alignment is not greater than 1. The reason
2588 -- we do this is to avoid unnecessary copying of slices of such
2589 -- arrays when passed to subprogram parameters (see special test
2590 -- in Exp_Ch6.Expand_Actuals).
2592 if not Is_Packed (E)
2593 and then Unknown_Alignment (E)
2595 if Known_Static_Component_Size (E)
2596 and then Component_Size (E) = 1
2598 Set_Alignment (E, Uint_1);
2604 -- Final step is to check that Esize and RM_Size are compatible
2606 if Known_Static_Esize (E) and then Known_Static_RM_Size (E) then
2607 if Esize (E) < RM_Size (E) then
2609 -- Esize is less than RM_Size. That's not good. First we test
2610 -- whether this was set deliberately with an Object_Size clause
2611 -- and if so, object to the clause.
2613 if Has_Object_Size_Clause (E) then
2614 Error_Msg_Uint_1 := RM_Size (E);
2616 ("object size is too small, minimum allowed is ^",
2617 Expression (Get_Attribute_Definition_Clause
2618 (E, Attribute_Object_Size)));
2621 -- Adjust Esize up to RM_Size value
2624 Size : constant Uint := RM_Size (E);
2627 Set_Esize (E, RM_Size (E));
2629 -- For scalar types, increase Object_Size to power of 2,
2630 -- but not less than a storage unit in any case (i.e.,
2631 -- normally this means it will be storage-unit addressable).
2633 if Is_Scalar_Type (E) then
2634 if Size <= System_Storage_Unit then
2635 Init_Esize (E, System_Storage_Unit);
2636 elsif Size <= 16 then
2638 elsif Size <= 32 then
2641 Set_Esize (E, (Size + 63) / 64 * 64);
2644 -- Finally, make sure that alignment is consistent with
2645 -- the newly assigned size.
2647 while Alignment (E) * System_Storage_Unit < Esize (E)
2648 and then Alignment (E) < Maximum_Alignment
2650 Set_Alignment (E, 2 * Alignment (E));
2658 ---------------------
2659 -- Rewrite_Integer --
2660 ---------------------
2662 procedure Rewrite_Integer (N : Node_Id; V : Uint) is
2663 Loc : constant Source_Ptr := Sloc (N);
2664 Typ : constant Entity_Id := Etype (N);
2667 Rewrite (N, Make_Integer_Literal (Loc, Intval => V));
2669 end Rewrite_Integer;
2671 -------------------------------
2672 -- Set_And_Check_Static_Size --
2673 -------------------------------
2675 procedure Set_And_Check_Static_Size
2682 procedure Check_Size_Too_Small (Spec : Uint; Min : Uint);
2683 -- Spec is the number of bit specified in the size clause, and
2684 -- Min is the minimum computed size. An error is given that the
2685 -- specified size is too small if Spec < Min, and in this case
2686 -- both Esize and RM_Size are set to unknown in E. The error
2687 -- message is posted on node SC.
2689 procedure Check_Unused_Bits (Spec : Uint; Max : Uint);
2690 -- Spec is the number of bits specified in the size clause, and
2691 -- Max is the maximum computed size. A warning is given about
2692 -- unused bits if Spec > Max. This warning is posted on node SC.
2694 --------------------------
2695 -- Check_Size_Too_Small --
2696 --------------------------
2698 procedure Check_Size_Too_Small (Spec : Uint; Min : Uint) is
2701 Error_Msg_Uint_1 := Min;
2703 ("size for & too small, minimum allowed is ^", SC, E);
2707 end Check_Size_Too_Small;
2709 -----------------------
2710 -- Check_Unused_Bits --
2711 -----------------------
2713 procedure Check_Unused_Bits (Spec : Uint; Max : Uint) is
2716 Error_Msg_Uint_1 := Spec - Max;
2717 Error_Msg_NE ("?^ bits of & unused", SC, E);
2719 end Check_Unused_Bits;
2721 -- Start of processing for Set_And_Check_Static_Size
2724 -- Case where Object_Size (Esize) is already set by a size clause
2726 if Known_Static_Esize (E) then
2727 SC := Size_Clause (E);
2730 SC := Get_Attribute_Definition_Clause (E, Attribute_Object_Size);
2733 -- Perform checks on specified size against computed sizes
2735 if Present (SC) then
2736 Check_Unused_Bits (Esize (E), Esiz);
2737 Check_Size_Too_Small (Esize (E), RM_Siz);
2741 -- Case where Value_Size (RM_Size) is set by specific Value_Size
2742 -- clause (we do not need to worry about Value_Size being set by
2743 -- a Size clause, since that will have set Esize as well, and we
2744 -- already took care of that case).
2746 if Known_Static_RM_Size (E) then
2747 SC := Get_Attribute_Definition_Clause (E, Attribute_Value_Size);
2749 -- Perform checks on specified size against computed sizes
2751 if Present (SC) then
2752 Check_Unused_Bits (RM_Size (E), Esiz);
2753 Check_Size_Too_Small (RM_Size (E), RM_Siz);
2757 -- Set sizes if unknown
2759 if Unknown_Esize (E) then
2760 Set_Esize (E, Esiz);
2763 if Unknown_RM_Size (E) then
2764 Set_RM_Size (E, RM_Siz);
2766 end Set_And_Check_Static_Size;
2768 -----------------------------
2769 -- Set_Composite_Alignment --
2770 -----------------------------
2772 procedure Set_Composite_Alignment (E : Entity_Id) is
2777 if Unknown_Alignment (E) then
2778 if Known_Static_Esize (E) then
2781 elsif Unknown_Esize (E)
2782 and then Known_Static_RM_Size (E)
2790 -- Size is known, alignment is not set
2792 -- Reset alignment to match size if size is exactly 2, 4, or 8
2795 if Siz = 2 * System_Storage_Unit then
2797 elsif Siz = 4 * System_Storage_Unit then
2799 elsif Siz = 8 * System_Storage_Unit then
2802 -- On VMS, also reset for odd "in between" sizes, e.g. a 17-bit
2803 -- record is given an alignment of 4. This is more consistent with
2804 -- what DEC Ada does.
2806 elsif OpenVMS_On_Target and then Siz > System_Storage_Unit then
2808 if Siz <= 2 * System_Storage_Unit then
2810 elsif Siz <= 4 * System_Storage_Unit then
2812 elsif Siz <= 8 * System_Storage_Unit then
2818 -- No special alignment fiddling needed
2824 -- Here Align is set to the proposed improved alignment
2826 if Align > Maximum_Alignment then
2827 Align := Maximum_Alignment;
2830 -- Further processing for record types only to reduce the alignment
2831 -- set by the above processing in some specific cases. We do not
2832 -- do this for atomic records, since we need max alignment there.
2834 if Is_Record_Type (E) then
2836 -- For records, there is generally no point in setting alignment
2837 -- higher than word size since we cannot do better than move by
2838 -- words in any case
2840 if Align > System_Word_Size / System_Storage_Unit then
2841 Align := System_Word_Size / System_Storage_Unit;
2844 -- Check components. If any component requires a higher
2845 -- alignment, then we set that higher alignment in any case.
2851 Comp := First_Component (E);
2852 while Present (Comp) loop
2853 if Known_Alignment (Etype (Comp)) then
2855 Calign : constant Uint := Alignment (Etype (Comp));
2858 -- The cases to worry about are when the alignment
2859 -- of the component type is larger than the alignment
2860 -- we have so far, and either there is no component
2861 -- clause for the alignment, or the length set by
2862 -- the component clause matches the alignment set.
2866 (Unknown_Esize (Comp)
2867 or else (Known_Static_Esize (Comp)
2870 Calign * System_Storage_Unit))
2872 Align := UI_To_Int (Calign);
2877 Next_Component (Comp);
2882 -- Set chosen alignment
2884 Set_Alignment (E, UI_From_Int (Align));
2886 if Known_Static_Esize (E)
2887 and then Esize (E) < Align * System_Storage_Unit
2889 Set_Esize (E, UI_From_Int (Align * System_Storage_Unit));
2892 end Set_Composite_Alignment;
2894 --------------------------
2895 -- Set_Discrete_RM_Size --
2896 --------------------------
2898 procedure Set_Discrete_RM_Size (Def_Id : Entity_Id) is
2899 FST : constant Entity_Id := First_Subtype (Def_Id);
2902 -- All discrete types except for the base types in standard
2903 -- are constrained, so indicate this by setting Is_Constrained.
2905 Set_Is_Constrained (Def_Id);
2907 -- We set generic types to have an unknown size, since the
2908 -- representation of a generic type is irrelevant, in view
2909 -- of the fact that they have nothing to do with code.
2911 if Is_Generic_Type (Root_Type (FST)) then
2912 Set_RM_Size (Def_Id, Uint_0);
2914 -- If the subtype statically matches the first subtype, then
2915 -- it is required to have exactly the same layout. This is
2916 -- required by aliasing considerations.
2918 elsif Def_Id /= FST and then
2919 Subtypes_Statically_Match (Def_Id, FST)
2921 Set_RM_Size (Def_Id, RM_Size (FST));
2922 Set_Size_Info (Def_Id, FST);
2924 -- In all other cases the RM_Size is set to the minimum size.
2925 -- Note that this routine is never called for subtypes for which
2926 -- the RM_Size is set explicitly by an attribute clause.
2929 Set_RM_Size (Def_Id, UI_From_Int (Minimum_Size (Def_Id)));
2931 end Set_Discrete_RM_Size;
2933 ------------------------
2934 -- Set_Elem_Alignment --
2935 ------------------------
2937 procedure Set_Elem_Alignment (E : Entity_Id) is
2939 -- Do not set alignment for packed array types, unless we are doing
2940 -- front end layout, because otherwise this is always handled in the
2943 if Is_Packed_Array_Type (E) and then not Frontend_Layout_On_Target then
2946 -- If there is an alignment clause, then we respect it
2948 elsif Has_Alignment_Clause (E) then
2951 -- If the size is not set, then don't attempt to set the alignment. This
2952 -- happens in the backend layout case for access-to-subprogram types.
2954 elsif not Known_Static_Esize (E) then
2957 -- For access types, do not set the alignment if the size is less than
2958 -- the allowed minimum size. This avoids cascaded error messages.
2960 elsif Is_Access_Type (E)
2961 and then Esize (E) < System_Address_Size
2966 -- Here we calculate the alignment as the largest power of two
2967 -- multiple of System.Storage_Unit that does not exceed either
2968 -- the actual size of the type, or the maximum allowed alignment.
2972 UI_To_Int (Esize (E)) / SSU;
2977 while 2 * A <= Ttypes.Maximum_Alignment
2983 -- Now we think we should set the alignment to A, but we
2984 -- skip this if an alignment is already set to a value
2985 -- greater than A (happens for derived types).
2987 -- However, if the alignment is known and too small it
2988 -- must be increased, this happens in a case like:
2990 -- type R is new Character;
2991 -- for R'Size use 16;
2993 -- Here the alignment inherited from Character is 1, but
2994 -- it must be increased to 2 to reflect the increased size.
2996 if Unknown_Alignment (E) or else Alignment (E) < A then
2997 Init_Alignment (E, A);
3000 end Set_Elem_Alignment;
3002 ----------------------
3003 -- SO_Ref_From_Expr --
3004 ----------------------
3006 function SO_Ref_From_Expr
3008 Ins_Type : Entity_Id;
3009 Vtype : Entity_Id := Empty;
3010 Make_Func : Boolean := False) return Dynamic_SO_Ref
3012 Loc : constant Source_Ptr := Sloc (Ins_Type);
3014 K : constant Entity_Id :=
3015 Make_Defining_Identifier (Loc,
3016 Chars => New_Internal_Name ('K'));
3020 Vtype_Primary_View : Entity_Id;
3022 function Check_Node_V_Ref (N : Node_Id) return Traverse_Result;
3023 -- Function used to check one node for reference to V
3025 function Has_V_Ref is new Traverse_Func (Check_Node_V_Ref);
3026 -- Function used to traverse tree to check for reference to V
3028 ----------------------
3029 -- Check_Node_V_Ref --
3030 ----------------------
3032 function Check_Node_V_Ref (N : Node_Id) return Traverse_Result is
3034 if Nkind (N) = N_Identifier then
3035 if Chars (N) = Vname then
3044 end Check_Node_V_Ref;
3046 -- Start of processing for SO_Ref_From_Expr
3049 -- Case of expression is an integer literal, in this case we just
3050 -- return the value (which must always be non-negative, since size
3051 -- and offset values can never be negative).
3053 if Nkind (Expr) = N_Integer_Literal then
3054 pragma Assert (Intval (Expr) >= 0);
3055 return Intval (Expr);
3058 -- Case where there is a reference to V, create function
3060 if Has_V_Ref (Expr) = Abandon then
3062 pragma Assert (Present (Vtype));
3064 -- Check whether Vtype is a view of a private type and ensure that
3065 -- we use the primary view of the type (which is denoted by its
3066 -- Etype, whether it's the type's partial or full view entity).
3067 -- This is needed to make sure that we use the same (primary) view
3068 -- of the type for all V formals, whether the current view of the
3069 -- type is the partial or full view, so that types will always
3070 -- match on calls from one size function to another.
3072 if Has_Private_Declaration (Vtype) then
3073 Vtype_Primary_View := Etype (Vtype);
3075 Vtype_Primary_View := Vtype;
3078 Set_Is_Discrim_SO_Function (K);
3081 Make_Subprogram_Body (Loc,
3084 Make_Function_Specification (Loc,
3085 Defining_Unit_Name => K,
3086 Parameter_Specifications => New_List (
3087 Make_Parameter_Specification (Loc,
3088 Defining_Identifier =>
3089 Make_Defining_Identifier (Loc, Chars => Vname),
3091 New_Occurrence_Of (Vtype_Primary_View, Loc))),
3092 Result_Definition =>
3093 New_Occurrence_Of (Standard_Unsigned, Loc)),
3095 Declarations => Empty_List,
3097 Handled_Statement_Sequence =>
3098 Make_Handled_Sequence_Of_Statements (Loc,
3099 Statements => New_List (
3100 Make_Simple_Return_Statement (Loc,
3101 Expression => Expr))));
3103 -- The caller requests that the expression be encapsulated in
3104 -- a parameterless function.
3106 elsif Make_Func then
3108 Make_Subprogram_Body (Loc,
3111 Make_Function_Specification (Loc,
3112 Defining_Unit_Name => K,
3113 Parameter_Specifications => Empty_List,
3114 Result_Definition =>
3115 New_Occurrence_Of (Standard_Unsigned, Loc)),
3117 Declarations => Empty_List,
3119 Handled_Statement_Sequence =>
3120 Make_Handled_Sequence_Of_Statements (Loc,
3121 Statements => New_List (
3122 Make_Simple_Return_Statement (Loc, Expression => Expr))));
3124 -- No reference to V and function not requested, so create a constant
3128 Make_Object_Declaration (Loc,
3129 Defining_Identifier => K,
3130 Object_Definition =>
3131 New_Occurrence_Of (Standard_Unsigned, Loc),
3132 Constant_Present => True,
3133 Expression => Expr);
3136 Append_Freeze_Action (Ins_Type, Decl);
3138 return Create_Dynamic_SO_Ref (K);
3139 end SO_Ref_From_Expr;