| blob | be2bd802317cab2585b78798804804137c36d1ec |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- L A Y O U T --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 2001-2010, Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, 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 COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
20 -- --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
23 -- --
24 ------------------------------------------------------------------------------
53 ------------------------
54 -- Local Declarations --
55 ------------------------
58 -- Short hand for System_Storage_Unit
61 -- Formal parameter name used for functions generated for size offset
62 -- values that depend on the discriminant. All such functions have the
63 -- following form:
64 --
65 -- function xxx (V : vtyp) return Unsigned is
66 -- begin
67 -- return ... expression involving V.discrim
68 -- end xxx;
70 -----------------------
71 -- Local Subprograms --
72 -----------------------
74 function Assoc_Add
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
86 -- This is like Make_Op_Multiply except that it optimizes some cases
87 -- knowing that associative rearrangement is allowed for constant folding
88 -- if one of the operands is a compile time known value
90 function Assoc_Subtract
94 -- This is like Make_Op_Subtract except that it optimizes some cases
95 -- knowing that associative rearrangement is allowed for constant folding
96 -- if one of the operands is a compile time known value
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.
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
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
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
146 -- in this unit).
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.
157 -- Front-end layout of non-bit-packed array type or subtype
160 -- Front-end layout of record type
163 -- Rewrite node N with an integer literal whose value is V. The Sloc for
164 -- the new node is taken from N, and the type of the literal is set to a
165 -- 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 stored
172 -- in the Esize and RM_Size fields of E) against computed Object_Size
173 -- (Esiz) and Value_Size (RM_Siz) values. Appropriate errors and warnings
174 -- are posted if specified sizes are inconsistent with specified sizes. On
175 -- return, Esize and RM_Size fields of E are set (either from previously
176 -- given values, or from the newly computed values, as appropriate).
179 -- This procedure is called for record types and subtypes, and also for
180 -- atomic array types and subtypes. If no alignment is set, and the size
181 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
182 -- match the size.
184 ----------------------------
185 -- Adjust_Esize_Alignment --
186 ----------------------------
192 begin
193 -- Nothing to do if size unknown
199 -- Determine if size is constrained by an attribute definition clause
200 -- which must be obeyed. If so, we cannot increase the size in this
201 -- routine.
203 -- For a type, the issue is whether an object size clause has been set.
204 -- A normal size clause constrains only the value size (RM_Size)
209 -- For an object, the issue is whether a size clause is present
211 else
215 -- If size is known it must be a multiple of the storage unit size
219 -- If not, and size specified, then give error
222 Error_Msg_NE
227 -- Otherwise bump up size to a storage unit boundary
229 else
234 -- Now we have the size set, it must be a multiple of the alignment
235 -- nothing more we can do here if the alignment is unknown here.
241 -- At this point both the Esize and Alignment are known, so we need
242 -- to make sure they are consistent.
250 -- Here we have a situation where the Esize is not a multiple of the
251 -- alignment. We must either increase Esize or reduce the alignment to
252 -- correct this situation.
254 -- The case in which we can decrease the alignment is where the
255 -- alignment was not set by an alignment clause, and the type in
256 -- question is a discrete type, where it is definitely safe to reduce
257 -- the alignment. For example:
259 -- t : integer range 1 .. 2;
260 -- for t'size use 8;
262 -- In this situation, the initial alignment of t is 4, copied from
263 -- the Integer base type, but it is safe to reduce it to 1 at this
264 -- stage, since we will only be loading a single storage unit.
268 then
269 loop
278 -- Now the only possible approach left is to increase the Esize but we
279 -- can't do that if the size was set by a specific clause.
282 Error_Msg_NE
286 -- Otherwise we can indeed increase the size to a multiple of alignment
288 else
293 ---------------
294 -- Assoc_Add --
295 ---------------
297 function Assoc_Add
301 is
305 begin
306 -- Case of right operand is a constant
312 -- Case of left operand is a constant
318 -- Neither operand is a constant, do the addition with no optimization
320 else
324 -- Case of left operand is an addition
328 -- (C1 + E) + C2 = (C1 + C2) + E
331 Rewrite_Integer
336 -- (E + C1) + C2 = E + (C1 + C2)
339 Rewrite_Integer
345 -- Case of left operand is a subtraction
349 -- (C1 - E) + C2 = (C1 + C2) + E
352 Rewrite_Integer
357 -- (E - C1) + C2 = E - (C1 - C2)
360 Rewrite_Integer
367 -- Not optimizable, do the addition
372 --------------------
373 -- Assoc_Multiply --
374 --------------------
376 function Assoc_Multiply
380 is
384 begin
385 -- Case of right operand is a constant
391 -- Case of left operand is a constant
397 -- Neither operand is a constant, do the multiply with no optimization
399 else
403 -- Case of left operand is an multiplication
407 -- (C1 * E) * C2 = (C1 * C2) + E
410 Rewrite_Integer
415 -- (E * C1) * C2 = E * (C1 * C2)
418 Rewrite_Integer
425 -- Not optimizable, do the multiplication
430 --------------------
431 -- Assoc_Subtract --
432 --------------------
434 function Assoc_Subtract
438 is
442 begin
443 -- Case of right operand is a constant
449 -- Right operand is a constant, do the subtract with no optimization
451 else
455 -- Case of left operand is an addition
459 -- (C1 + E) - C2 = (C1 - C2) + E
462 Rewrite_Integer
467 -- (E + C1) - C2 = E + (C1 - C2)
470 Rewrite_Integer
476 -- Case of left operand is a subtraction
480 -- (C1 - E) - C2 = (C1 - C2) + E
483 Rewrite_Integer
488 -- (E - C1) - C2 = E - (C1 + C2)
491 Rewrite_Integer
498 -- Not optimizable, do the subtraction
503 ----------------
504 -- Bits_To_SU --
505 ----------------
508 begin
516 --------------------
517 -- Compute_Length --
518 --------------------
528 begin
529 -- If the bounds are First and Last attributes for the same dimension
530 -- and both have prefixes that denotes the same entity, then we create
531 -- and return a Length attribute. This may allow the back end to
532 -- generate better code in cases where it already has the length.
541 then
554 return
556 Prefix => New_Occurrence_Of
559 Expressions => New_List
567 -- If type is enumeration type, then use Pos attribute to convert
568 -- to integer type for which subtraction is a permitted operation.
571 Lo_Op :=
577 Hi_Op :=
584 return
586 Left_Opnd =>
593 ----------------------
594 -- Expr_From_SO_Ref --
595 ----------------------
597 function Expr_From_SO_Ref
601 is
604 begin
610 -- If a component is passed in whose type matches the type of
611 -- the function formal, then select that component from the "V"
612 -- parameter rather than passing "V" directly.
617 then
618 return
626 else
627 return
634 else
638 else
643 ---------------------
644 -- Get_Max_SU_Size --
645 ---------------------
659 record
665 -- Shows the status of the value so far. Const means that the value is
666 -- constant, and Val is the current constant value. Dynamic means that
667 -- the value is dynamic, and in this case Nod is the Node_Id of the
668 -- expression to compute the value.
671 -- Calculated value so far if Size.Status = Const,
672 -- or expression value so far if Size.Status = Dynamic.
675 -- This is set to True if the final result must be converted from bits
676 -- to storage units (rounding up to a storage unit boundary).
678 -----------------------
679 -- Local Subprograms --
680 -----------------------
683 -- If the node N represents a discriminant, replace it by the maximum
684 -- value of the discriminant.
687 -- If the node N represents a discriminant, replace it by the minimum
688 -- value of the discriminant.
690 -----------------
691 -- Max_Discrim --
692 -----------------
695 begin
698 then
703 -----------------
704 -- Min_Discrim --
705 -----------------
708 begin
711 then
716 -- Start of processing for Get_Max_SU_Size
718 begin
721 -- Initialize status from component size
726 else
730 -- Loop through indices
741 -- Value of the current subscript range is statically known
745 then
748 -- If known flat bound, entire size of array is zero!
754 -- Current value is constant, evolve value
759 -- Current value is dynamic
761 else
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.
776 Right_Opnd =>
780 -- Value of the current subscript range is dynamic
782 else
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
788 -- this case.
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.
799 Size :=
803 -- Otherwise, we go ahead and convert the value in bits, and
804 -- set SU_Convert_Required to True to ensure that the final
805 -- value is indeed properly converted.
807 else
813 -- Length is hi-lo+1
817 -- Check possible range of Len
819 declare
825 begin
831 -- If we cannot verify that range cannot be super-flat, we need
832 -- a max with zero, since length must be non-negative.
835 Len :=
837 Prefix =>
842 Len));
850 -- Here after processing all bounds to set sizes. If the value is a
851 -- constant, then it is bits, so we convert to storage units.
856 -- Case where the value is dynamic
858 else
859 -- Do convert from bits to SU's if needed
863 -- The expression required is (Size.Nod + SU - 1) / SU
867 Left_Opnd =>
878 -----------------------
879 -- Layout_Array_Type --
880 -----------------------
893 -- This is the type with which any generated constants or functions
894 -- will be associated (i.e. inserted into the freeze actions). This
895 -- is normally the type being laid out. The exception occurs when
896 -- we are laying out Itype's which are local to a record type, and
897 -- whose scope is this record type. Such types do not have freeze
898 -- nodes (because we have no place to put them).
900 ------------------------------------
901 -- How An Array Type is Laid Out --
902 ------------------------------------
904 -- Here is what goes on. We need to multiply the component size of the
905 -- array (which has already been set) by the length of each of the
906 -- indexes. If all these values are known at compile time, then the
907 -- resulting size of the array is the appropriate constant value.
909 -- If the component size or at least one bound is dynamic (but no
910 -- discriminants are present), then the size will be computed as an
911 -- expression that calculates the proper size.
913 -- If there is at least one discriminant bound, then the size is also
914 -- computed as an expression, but this expression contains discriminant
915 -- values which are obtained by selecting from a function parameter, and
916 -- the size is given by a function that is passed the variant record in
917 -- question, and whose body is the expression.
922 record
926 -- Calculated value so far if Val_Status = Const
930 -- Expression value so far if Val_Status /= Const
934 -- Records the value or expression computed so far. Const means that
935 -- the value is constant, and Val is the current constant value.
936 -- Dynamic means that the value is dynamic, and in this case Nod is
937 -- the Node_Id of the expression to compute the value, and Discrim
938 -- means that at least one bound is a discriminant, in which case Nod
939 -- is the expression so far (which will be the body of the function).
942 -- Value of size computed so far. See comments above
945 -- Variant record type for the formal parameter of the discriminant
946 -- function V if Status = Discrim.
949 -- This is set to True if the final result must be converted from
950 -- bits to storage units (rounding up to a storage unit boundary).
953 -- This is the amount that a nonstatic computed size will be divided
954 -- by to convert it from bits to storage units. This is normally
955 -- equal to SSU, but can be reduced in the case of packed components
956 -- that fit evenly into a storage unit.
959 -- Indicates whether to request that SO_Ref_From_Expr should
960 -- encapsulate the array size expression in a function.
963 -- If N represents a discriminant, then the Size.Status is set to
964 -- Discrim, and Vtyp is set. The parameter N is replaced with the
965 -- proper expression to extract the discriminant value from V.
967 ----------------
968 -- Discrimify --
969 ----------------
975 begin
978 then
989 N :=
994 -- Set the Etype attributes of the selected name and its prefix.
995 -- Analyze_And_Resolve can't be called here because the Vname
996 -- entity denoted by the prefix will not yet exist (it's created
997 -- by SO_Ref_From_Expr, called at the end of Layout_Array_Type).
1004 -- Start of processing for Layout_Array_Type
1006 begin
1007 -- Default alignment is component alignment
1013 -- Calculate proper type for insertions
1017 else
1021 -- If the component type is a generic formal type then there's no point
1022 -- in determining a size for the array type.
1028 -- Deal with component size if base type
1032 -- Cannot do anything if Esize of component type unknown
1038 -- Set component size if not set already
1045 -- (RM 13.3 (48)) says that the size of an unconstrained array
1046 -- is implementation defined. We choose to leave it as Unknown
1047 -- here, and the actual behavior is determined by the back end.
1053 -- Initialize status from component size
1058 else
1062 -- Loop to process array indices
1068 -- If an index of the array is a generic formal type then there is
1069 -- no point in determining a size for the array type.
1078 -- Value of the current subscript range is statically known
1082 then
1085 -- If known flat bound, entire size of array is zero!
1093 -- If constant, evolve value
1098 -- Current value is dynamic
1100 else
1101 -- An interesting little optimization, if we have a pending
1102 -- conversion from bits to storage units, and the current
1103 -- length is a multiple of the storage unit size, then we
1104 -- can take the factor out here statically, avoiding some
1105 -- extra dynamic computations at the end.
1112 -- Now go ahead and evolve the expression
1117 Right_Opnd =>
1121 -- Value of the current subscript range is dynamic
1123 else
1124 -- If the current size value is constant, then here is where we
1125 -- make a transition to dynamic values, which are always stored
1126 -- in storage units, However, we do not want to convert to SU's
1127 -- too soon, consider the case of a packed array of single bits,
1128 -- we want to do the SU conversion after computing the size in
1129 -- this case.
1133 -- If the current value is a multiple of the storage unit,
1134 -- then most certainly we can do the conversion now, simply
1135 -- by dividing the current value by the storage unit value.
1136 -- If this works, we set SU_Convert_Required to False.
1139 Size :=
1143 -- If the current value is a factor of the storage unit, then
1144 -- we can use a value of one for the size and reduce the
1145 -- strength of the later division.
1152 -- Otherwise, we go ahead and convert the value in bits, and
1153 -- set SU_Convert_Required to True to ensure that the final
1154 -- value is indeed properly converted.
1156 else
1165 -- Length is hi-lo+1
1169 -- If Len isn't a Length attribute, then its range needs to be
1170 -- checked a possible Max with zero needs to be computed.
1174 then
1175 declare
1180 begin
1181 -- Check possible range of Len
1188 -- If range definitely flat or superflat,
1189 -- result size is zero
1197 -- If we cannot verify that range cannot be super-flat, we
1198 -- need a max with zero, since length cannot be negative.
1201 Len :=
1203 Prefix =>
1208 Len));
1213 -- At this stage, Len has the expression for the length
1224 -- Here after processing all bounds to set sizes. If the value is a
1225 -- constant, then it is bits, and the only thing we need to do is to
1226 -- check against explicit given size and do alignment adjust.
1232 -- Case where the value is dynamic
1234 else
1235 -- Do convert from bits to SU's if needed
1239 -- The expression required is:
1240 -- (Size.Nod + Storage_Divisor - 1) / Storage_Divisor
1244 Left_Opnd =>
1247 Right_Opnd => Make_Integer_Literal
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.
1262 declare
1265 begin
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
1282 -- correct?
1284 Set_Esize
1286 SO_Ref_From_Expr
1292 -------------------
1293 -- Layout_Object --
1294 -------------------
1299 begin
1300 -- Nothing to do if backend does layout
1306 -- Set size if not set for object and known for type. Use the RM_Size if
1307 -- that is known for the type and Esize is not.
1318 -- Set alignment from type if unknown and type alignment known
1324 -- Make sure size and alignment are consistent
1328 -- Final adjustment, if we don't know the alignment, and the Esize was
1329 -- not set by an explicit Object_Size attribute clause, then we reset
1330 -- the Esize to unknown, since we really don't know it.
1334 then
1339 ------------------------
1340 -- Layout_Record_Type --
1341 ------------------------
1348 -- Current component being laid out
1351 -- Previous laid out component
1353 procedure Get_Next_Component_Location
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.
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
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.
1401 -- Procedure called to lay out a non-variant record type or subtype
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
1418 is
1419 begin
1420 -- No previous component, return zero position
1429 -- Here we have a previous component
1431 declare
1440 -- Expression representing maximum size of previous component
1442 begin
1443 -- Case where previous field had a dynamic size
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.
1458 New_Npos :=
1459 SO_Ref_From_Expr
1461 Left_Opnd =>
1463 Right_Opnd =>
1468 -- Get maximum size of previous component
1472 else
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.
1482 then
1485 -- Otherwise new max position is dynamic
1487 else
1488 New_NPMax :=
1489 SO_Ref_From_Expr
1497 -- Previous field has known static Esize
1499 else
1502 -- Bump New_Fbit to storage unit boundary if required
1508 -- If old normalized position is static, we can go ahead and
1509 -- compute the new normalized position directly.
1519 -- Bump alignment if stricter than prev
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.
1532 -- Case of old normalized position is dynamic
1534 else
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).
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
1547 else
1548 New_Npos :=
1549 SO_Ref_From_Expr
1552 Right_Opnd =>
1558 New_NPMax :=
1559 SO_Ref_From_Expr
1562 Right_Opnd =>
1574 ----------------------
1575 -- Layout_Component --
1576 ----------------------
1586 begin
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.
1595 then
1599 -- If original component set, then use same layout
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
1622 -- Check case of type of component has a scope of the record we are
1623 -- laying out. When this happens, the type in question is an Itype
1624 -- that has not yet been laid out (that's because such types do not
1625 -- get frozen in the normal manner, because there is no place for
1626 -- the freeze nodes).
1632 -- If component already laid out, then we are done
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 what the
1640 -- RM_Size value, as distinct from the Object_Size is useful for!)
1644 else
1648 -- Compute the component position from the previous one. See if
1649 -- current component requires being on a storage unit boundary.
1651 -- If record is not packed, we always go to a storage unit boundary
1656 -- Packed cases
1658 else
1659 -- Elementary types do not need SU boundary in packed record
1664 -- Packed array types with a modular packed array type do not
1665 -- force a storage unit boundary (since the code generation
1666 -- treats these as equivalent to the underlying modular type),
1671 then
1674 -- Record types with known length less than or equal to the length
1675 -- of long long integer can also be unaligned, since they can be
1676 -- treated as scalars.
1681 then
1684 -- All other cases force a storage unit boundary, even when packed
1686 else
1691 -- Now get the next component location
1693 Get_Next_Component_Location
1699 -- Set Component_Bit_Offset in the static case
1703 then
1708 -----------------------
1709 -- Layout_Components --
1710 -----------------------
1712 procedure Layout_Components
1717 is
1722 begin
1723 -- Only lay out components if there are some to lay out!
1727 -- Lay out components with no component clauses
1730 loop
1733 then
1734 -- The compatibility of component clauses with composite
1735 -- types isn't checked in Sem_Ch13, so we check it here.
1740 then
1742 Error_Msg_NE
1745 Comp);
1748 else
1759 -- Set size fields, both are zero if no components
1765 -- If record subtype with non-static discriminants, then we don't
1766 -- know which variant will be the one which gets chosen. We don't
1767 -- just want to set the maximum size from the base, because the
1768 -- size should depend on the particular variant.
1770 -- What we do is to use the RM_Size of the base type, which has
1771 -- the necessary conditional computation of the size, using the
1772 -- size information for the particular variant chosen. Records
1773 -- with default discriminants for example have an Esize that is
1774 -- set to the maximum of all variants, but that's not what we
1775 -- want for a constrained subtype.
1779 then
1780 declare
1782 begin
1788 else
1789 -- First the object size, for which we align past the last field
1790 -- to the alignment of the record (the object size is required to
1791 -- be a multiple of the alignment).
1793 Get_Next_Component_Location
1796 End_Npos,
1797 End_Fbit,
1798 End_NPMax,
1801 -- If the resulting normalized position is a dynamic reference,
1802 -- then the size is dynamic, and is stored in storage units. In
1803 -- this case, we set the RM_Size to the same value, it is simply
1804 -- not worth distinguishing Esize and RM_Size values in the
1805 -- dynamic case, since the RM has nothing to say about them.
1807 -- Note that a size cannot have been given in this case, since
1808 -- size specifications cannot be given for variable length types.
1810 declare
1813 begin
1817 -- Set the Object_Size allowing for the alignment. In the
1818 -- dynamic case, we must do the actual runtime computation.
1819 -- We can skip this in the non-packed record case if the
1820 -- last component has a smaller alignment than the overall
1821 -- record alignment.
1828 then
1829 -- The expression we build is:
1830 -- (expr + align - 1) / align * align
1832 Esiz :=
1833 SO_Ref_From_Expr
1836 Left_Opnd =>
1838 Left_Opnd =>
1840 Left_Opnd =>
1842 Right_Opnd =>
1845 Right_Opnd =>
1847 Right_Opnd =>
1853 -- Here Esiz is static, so we can adjust the alignment
1854 -- directly go give the required aligned value.
1856 else
1860 -- Case where computed size is static
1862 else
1863 -- The ending size was computed in Npos in storage units,
1864 -- but the actual size is stored in bits, so adjust
1865 -- accordingly. We also adjust the size to match the
1866 -- alignment here.
1870 -- Compute the resulting Value_Size (RM_Size). For this
1871 -- purpose we do not force alignment of the record or
1872 -- storage size alignment of the result.
1874 Get_Next_Component_Location
1876 Uint_0,
1877 End_Npos,
1878 End_Fbit,
1879 End_NPMax,
1889 -------------------------------
1890 -- Layout_Non_Variant_Record --
1891 -------------------------------
1896 begin
1902 ---------------------------
1903 -- Layout_Variant_Record --
1904 ---------------------------
1916 -- Expression for the evolving RM_Siz value. This is typically a
1917 -- conditional expression which involves tests of discriminant values
1918 -- that are formed as references to the entity V. At the end of
1919 -- scanning all the components, a suitable function is constructed
1920 -- in which V is the parameter.
1922 -----------------------
1923 -- Local Subprograms --
1924 -----------------------
1926 procedure Layout_Component_List
1930 -- Recursive procedure, called to lay out one component list Esiz
1931 -- and RM_Siz_Expr are set to the Object_Size and Value_Size values
1932 -- respectively representing the record size up to and including the
1933 -- last component in the component list (including any variants in
1934 -- this component list). RM_Siz_Expr is returned as an expression
1935 -- which may in the general case involve some references to the
1936 -- discriminants of the current record value, referenced by selecting
1937 -- from the entity V.
1939 ---------------------------
1940 -- Layout_Component_List --
1941 ---------------------------
1943 procedure Layout_Component_List
1947 is
1955 begin
1957 Layout_Components
1962 else
1966 -- Case where no variants are present in the component list
1970 -- The Esiz value has been correctly set by the call to
1971 -- Layout_Components, so there is nothing more to be done.
1973 -- For RM_Siz, we have an SO_Ref value, which we must convert
1974 -- to an appropriate expression.
1977 RM_Siz_Expr :=
1981 else
1984 -- If the size is represented by a function, then we create
1985 -- an appropriate function call using V as the parameter to
1986 -- the call.
1989 RM_Siz_Expr :=
1995 -- If the size is represented by a constant, then the
1996 -- expression we want is a reference to this constant
1998 else
2003 -- Case where variants are present in this component list
2005 else
2006 declare
2015 begin
2022 Layout_Component_List
2025 -- Set the Object_Size. If this is the first variant,
2026 -- we just set the size of this first variant.
2031 -- Otherwise the Object_Size is formed as a maximum
2032 -- of Esiz so far from previous variants, and the new
2033 -- Esiz value from the variant we just processed.
2035 -- If both values are static, we can just compute the
2036 -- maximum directly to save building junk nodes.
2040 then
2043 -- If either value is dynamic, then we have to generate
2044 -- an appropriate Standard_Unsigned'Max attribute call.
2045 -- If one of the values is static then it needs to be
2046 -- converted from bits to storage units to be compatible
2047 -- with the dynamic value.
2049 else
2058 Esiz :=
2059 SO_Ref_From_Expr
2062 Prefix =>
2071 -- Now deal with Value_Size (RM_Siz). We are aiming at
2072 -- an expression that looks like:
2074 -- if xxDx (V.disc) then rmsiz1
2075 -- else if xxDx (V.disc) then rmsiz2
2076 -- else ...
2078 -- Where rmsiz1, rmsiz2... are the RM_Siz values for the
2079 -- individual variants, and xxDx are the discriminant
2080 -- checking functions generated for the variant type.
2082 -- If this is the first variant, we simply set the result
2083 -- as the expression. Note that this takes care of the
2084 -- others case.
2089 -- Otherwise construct the appropriate test
2091 else
2092 -- The test to be used in general is a call to the
2093 -- discriminant checking function. However, it is
2094 -- definitely worth special casing the very common
2095 -- case where a single value is involved.
2101 then
2102 -- Discriminant to be tested
2104 Discrim :=
2106 Prefix =>
2108 Selector_Name =>
2109 New_Occurrence_Of
2112 Dtest :=
2117 -- Generate a call to the discriminant-checking
2118 -- function for the variant. Note that the result
2119 -- has to be complemented since the function returns
2120 -- False when the passed discriminant value matches.
2122 else
2123 -- The checking function takes all of the type's
2124 -- discriminants as parameters, so a list of all
2125 -- the selected discriminants must be constructed.
2130 Append (
2132 Prefix =>
2134 Selector_Name =>
2135 New_Occurrence_Of
2137 D_List);
2142 Dtest :=
2144 Right_Opnd =>
2146 Name =>
2147 New_Occurrence_Of
2149 Parameter_Associations =>
2150 D_List));
2153 RM_Siz_Expr :=
2155 Expressions =>
2156 New_List
2166 -- Start of processing for Layout_Variant_Record
2168 begin
2169 -- We need the discriminant checking functions, since we generate
2170 -- calls to these functions for the RM_Size expression, so make
2171 -- sure that these functions have been constructed in time.
2175 -- Lay out the discriminants
2183 Layout_Components
2189 -- Lay out the main component list (this will make recursive calls
2190 -- to lay out all component lists nested within variants).
2195 -- If the RM_Size is a literal, set its value
2200 -- Otherwise we construct a dynamic SO_Ref
2202 else
2204 SO_Ref_From_Expr
2211 -- Start of processing for Layout_Record_Type
2213 begin
2214 -- If this is a cloned subtype, just copy the size fields from the
2215 -- original, nothing else needs to be done in this case, since the
2216 -- components themselves are all shared.
2219 or else
2222 then
2227 -- Another special case, class-wide types. The RM says that the size
2228 -- of such types is implementation defined (RM 13.3(48)). What we do
2229 -- here is to leave the fields set as unknown values, and the backend
2230 -- determines the actual behavior.
2235 -- All other cases
2237 else
2238 -- Initialize alignment conservatively to 1. This value will be
2239 -- increased as necessary during processing of the record.
2245 -- Initialize previous component. This is Empty unless there are
2246 -- components which have already been laid out by component clauses.
2247 -- If there are such components, we start our lay out of the
2248 -- remaining components following the last such component.
2256 or else
2259 then
2267 -- We have two separate circuits, one for non-variant records and
2268 -- one for variant records. For non-variant records, we simply go
2269 -- through the list of components. This handles all the non-variant
2270 -- cases including those cases of subtypes where there is no full
2271 -- type declaration, so the tree cannot be used to drive the layout.
2272 -- For variant records, we have to drive the layout from the tree
2273 -- since we need to understand the variant structure in this case.
2277 else
2281 -- Scan all the components
2287 and then
2289 then
2290 Layout_Variant_Record;
2291 else
2292 Layout_Non_Variant_Record;
2297 -----------------
2298 -- Layout_Type --
2299 -----------------
2304 begin
2305 -- For string literal types, for now, kill the size always, this is
2306 -- because gigi does not like or need the size to be set ???
2314 -- For access types, set size/alignment. This is system address size,
2315 -- except for fat pointers (unconstrained array access types), where the
2316 -- size is two times the address size, to accommodate the two pointers
2317 -- that are required for a fat pointer (data and template). Note that
2318 -- E_Access_Protected_Subprogram_Type is not an access type for this
2319 -- purpose since it is not a pointer but is equivalent to a record. For
2320 -- access subtypes, copy the size from the base type since Gigi
2321 -- represents them the same way.
2327 -- If we only have a limited view of the type, see whether the
2328 -- non-limited view is available.
2333 then
2337 -- If Esize already set (e.g. by a size clause), then nothing further
2338 -- to be done here.
2343 -- Access to subprogram is a strange beast, and we let the backend
2344 -- figure out what is needed (it may be some kind of fat pointer,
2345 -- including the static link for example.
2350 -- For access subtypes, copy the size information from base type
2356 -- For other access types, we use either address size, or, if a fat
2357 -- pointer is used (pointer-to-unconstrained array case), twice the
2358 -- address size to accommodate a fat pointer.
2364 and then not Debug_Flag_6
2365 then
2368 -- Check for bad convention set
2370 if Warn_On_Export_Import
2371 and then
2373 or else
2375 then
2376 Error_Msg_N
2380 -- If the designated type is a limited view it is unanalyzed. We can
2381 -- examine the declaration itself to determine whether it will need a
2382 -- fat pointer.
2387 and then
2389 = N_Unconstrained_Array_Definition
2390 then
2393 -- When the target is AAMP, access-to-subprogram types are fat
2394 -- pointers consisting of the subprogram address and a static link
2395 -- (with the exception of library-level access types, where a simple
2396 -- subprogram address is used).
2398 elsif AAMP_On_Target
2399 and then
2403 then
2406 else
2410 -- On VMS, reset size to 32 for convention C access type if no
2411 -- explicit size clause is given and the default size is 64. Really
2412 -- we do not know the size, since depending on options for the VMS
2413 -- compiler, the size of a pointer type can be 32 or 64, but choosing
2414 -- 32 as the default improves compatibility with legacy VMS code.
2416 -- Note: we do not use Has_Size_Clause in the test below, because we
2417 -- want to catch the case of a derived type inheriting a size clause.
2418 -- We want to consider this to be an explicit size clause for this
2419 -- purpose, since it would be weird not to inherit the size in this
2420 -- case.
2422 -- We do NOT do this if we are in -gnatdm mode on a non-VMS target
2423 -- since in that case we want the normal pointer representation.
2427 or else
2431 then
2437 -- Scalar types: set size and alignment
2441 -- For discrete types, the RM_Size and Esize must be set already,
2442 -- since this is part of the earlier processing and the front end is
2443 -- always required to lay out the sizes of such types (since they are
2444 -- available as static attributes). All we do is to check that this
2445 -- rule is indeed obeyed!
2449 -- If the RM_Size is not set, then here is where we set it
2451 -- Note: an RM_Size of zero looks like not set here, but this
2452 -- is a rare case, and we can simply reset it without any harm.
2458 -- If Esize for a discrete type is not set then set it
2461 declare
2464 begin
2465 loop
2466 -- If size is big enough, set it and exit
2472 -- If the RM_Size is greater than 64 (happens only when
2473 -- strange values are specified by the user, then Esize
2474 -- is simply a copy of RM_Size, it will be further
2475 -- refined later on)
2481 -- Otherwise double possible size and keep trying
2483 else
2490 -- For non-discrete scalar types, if the RM_Size is not set, then set
2491 -- it now to a copy of the Esize if the Esize is set.
2493 else
2501 -- Non-elementary (composite) types
2503 else
2504 -- For packed arrays, take size and alignment values from the packed
2505 -- array type if a packed array type has been created and the fields
2506 -- are not currently set.
2509 declare
2512 begin
2527 -- If RM_Size is known, set Esize if not known
2531 -- If the alignment is known, we bump the Esize up to the next
2532 -- alignment boundary if it is not already on one.
2535 declare
2538 begin
2543 -- If Esize is set, and RM_Size is not, RM_Size is copied from Esize.
2544 -- At least for now this seems reasonable, and is in any case needed
2545 -- for compatibility with old versions of gigi.
2551 -- For array base types, set component size if object size of the
2552 -- component type is known and is a small power of 2 (8, 16, 32, 64),
2553 -- since this is what will always be used.
2557 then
2558 declare
2561 begin
2562 -- For some reasons, access types can cause trouble, So let's
2563 -- just do this for scalar types ???
2568 then
2569 declare
2572 begin
2577 then
2586 -- Lay out array and record types if front end layout set
2595 -- Case of backend layout, we still do a little in the front end
2597 else
2598 -- Processing for record types
2602 -- Special remaining processing for record types with a known
2603 -- size of 16, 32, or 64 bits whose alignment is not yet set.
2604 -- For these types, we set a corresponding alignment matching
2605 -- the size if possible, or as large as possible if not.
2608 and then not Debug_Flag_Q
2609 then
2613 -- Processing for array types
2617 -- For arrays that are required to be atomic, we do the same
2618 -- processing as described above for short records, since we
2619 -- really need to have the alignment set for the whole array.
2625 -- For unpacked array types, set an alignment of 1 if we know
2626 -- that the component alignment is not greater than 1. The reason
2627 -- we do this is to avoid unnecessary copying of slices of such
2628 -- arrays when passed to subprogram parameters (see special test
2629 -- in Exp_Ch6.Expand_Actuals).
2633 then
2636 then
2643 -- Final step is to check that Esize and RM_Size are compatible
2648 -- Esize is less than RM_Size. That's not good. First we test
2649 -- whether this was set deliberately with an Object_Size clause
2650 -- and if so, object to the clause.
2654 Error_Msg_F
2656 Expression (Get_Attribute_Definition_Clause
2660 -- Adjust Esize up to RM_Size value
2662 declare
2665 begin
2668 -- For scalar types, increase Object_Size to power of 2, but
2669 -- not less than a storage unit in any case (i.e., normally
2670 -- this means it will be storage-unit addressable).
2679 else
2683 -- Finally, make sure that alignment is consistent with
2684 -- the newly assigned size.
2688 loop
2697 ---------------------
2698 -- Rewrite_Integer --
2699 ---------------------
2704 begin
2709 -------------------------------
2710 -- Set_And_Check_Static_Size --
2711 -------------------------------
2713 procedure Set_And_Check_Static_Size
2717 is
2721 -- Spec is the number of bit specified in the size clause, and Min is
2722 -- the minimum computed size. An error is given that the specified size
2723 -- is too small if Spec < Min, and in this case both Esize and RM_Size
2724 -- are set to unknown in E. The error message is posted on node SC.
2727 -- Spec is the number of bits specified in the size clause, and Max is
2728 -- the maximum computed size. A warning is given about unused bits if
2729 -- Spec > Max. This warning is posted on node SC.
2731 --------------------------
2732 -- Check_Size_Too_Small --
2733 --------------------------
2736 begin
2745 -----------------------
2746 -- Check_Unused_Bits --
2747 -----------------------
2750 begin
2757 -- Start of processing for Set_And_Check_Static_Size
2759 begin
2760 -- Case where Object_Size (Esize) is already set by a size clause
2769 -- Perform checks on specified size against computed sizes
2777 -- Case where Value_Size (RM_Size) is set by specific Value_Size clause
2778 -- (we do not need to worry about Value_Size being set by a Size clause,
2779 -- since that will have set Esize as well, and we already took care of
2780 -- that case).
2785 -- Perform checks on specified size against computed sizes
2793 -- Set sizes if unknown
2804 -----------------------------
2805 -- Set_Composite_Alignment --
2806 -----------------------------
2812 begin
2813 -- If alignment is already set, then nothing to do
2819 -- Alignment is not known, see if we can set it, taking into account
2820 -- the setting of the Optimize_Alignment mode.
2822 -- If Optimize_Alignment is set to Space, then packed records always
2823 -- have an alignment of 1. But don't do anything for atomic records
2824 -- since we may need higher alignment for indivisible access.
2830 then
2833 -- Not a record, or not packed
2835 else
2836 -- The only other cases we worry about here are where the size is
2837 -- statically known at compile time.
2844 then
2847 else
2851 -- Size is known, alignment is not set
2853 -- Reset alignment to match size if the known size is exactly 2, 4,
2854 -- or 8 storage units.
2863 -- If Optimize_Alignment is set to Space, then make sure the
2864 -- alignment matches the size, for example, if the size is 17
2865 -- bytes then we want an alignment of 1 for the type.
2874 else
2878 -- If Optimize_Alignment is set to Time, then we reset for odd
2879 -- "in between sizes", for example a 17 bit record is given an
2880 -- alignment of 4. Note that this matches the old VMS behavior
2881 -- in versions of GNAT prior to 6.1.1.
2886 then
2895 -- No special alignment fiddling needed
2897 else
2902 -- Here we have Set Align to the proposed improved value. Make sure the
2903 -- value set does not exceed Maximum_Alignment for the target.
2909 -- Further processing for record types only to reduce the alignment
2910 -- set by the above processing in some specific cases. We do not
2911 -- do this for atomic records, since we need max alignment there,
2915 -- For records, there is generally no point in setting alignment
2916 -- higher than word size since we cannot do better than move by
2917 -- words in any case. Omit this if we are optimizing for time,
2918 -- since conceivably we may be able to do better.
2922 then
2926 -- Check components. If any component requires a higher alignment,
2927 -- then we set that higher alignment in any case. Don't do this if
2928 -- we have Optimize_Alignment set to Space. Note that that covers
2929 -- the case of packed records, where we already set alignment to 1.
2932 declare
2935 begin
2939 declare
2942 begin
2943 -- The cases to process are when the alignment of the
2944 -- component type is larger than the alignment we have
2945 -- so far, and either there is no component clause for
2946 -- the component, or the length set by the component
2947 -- clause matches the length of the component type.
2950 and then
2953 and then
2956 then
2968 -- Set chosen alignment, and increase Esize if necessary to match the
2969 -- chosen alignment.
2975 then
2980 --------------------------
2981 -- Set_Discrete_RM_Size --
2982 --------------------------
2987 begin
2988 -- All discrete types except for the base types in standard are
2989 -- constrained, so indicate this by setting Is_Constrained.
2993 -- Set generic types to have an unknown size, since the representation
2994 -- of a generic type is irrelevant, in view of the fact that they have
2995 -- nothing to do with code.
3000 -- If the subtype statically matches the first subtype, then it is
3001 -- required to have exactly the same layout. This is required by
3002 -- aliasing considerations.
3006 then
3010 -- In all other cases the RM_Size is set to the minimum size. Note that
3011 -- this routine is never called for subtypes for which the RM_Size is
3012 -- set explicitly by an attribute clause.
3014 else
3019 ------------------------
3020 -- Set_Elem_Alignment --
3021 ------------------------
3024 begin
3025 -- Do not set alignment for packed array types, unless we are doing
3026 -- front end layout, because otherwise this is always handled in the
3027 -- backend.
3032 -- If there is an alignment clause, then we respect it
3037 -- If the size is not set, then don't attempt to set the alignment. This
3038 -- happens in the backend layout case for access-to-subprogram types.
3043 -- For access types, do not set the alignment if the size is less than
3044 -- the allowed minimum size. This avoids cascaded error messages.
3048 then
3052 -- Here we calculate the alignment as the largest power of two multiple
3053 -- of System.Storage_Unit that does not exceed either the actual size of
3054 -- the type, or the maximum allowed alignment.
3056 declare
3061 begin
3062 -- If the default alignment of "double" floating-point types is
3063 -- specifically capped, enforce the cap.
3068 then
3071 -- If the default alignment of "double" or larger scalar types is
3072 -- specifically capped, enforce the cap.
3077 then
3080 -- Otherwise enforce the overall alignment cap
3082 else
3091 -- Now we think we should set the alignment to A, but we skip this if
3092 -- an alignment is already set to a value greater than A (happens for
3093 -- derived types).
3095 -- However, if the alignment is known and too small it must be
3096 -- increased, this happens in a case like:
3098 -- type R is new Character;
3099 -- for R'Size use 16;
3101 -- Here the alignment inherited from Character is 1, but it must be
3102 -- increased to 2 to reflect the increased size.
3110 ----------------------
3111 -- SO_Ref_From_Expr --
3112 ----------------------
3114 function SO_Ref_From_Expr
3119 is
3127 -- Function used to check one node for reference to V
3130 -- Function used to traverse tree to check for reference to V
3132 ----------------------
3133 -- Check_Node_V_Ref --
3134 ----------------------
3137 begin
3141 else
3145 else
3150 -- Start of processing for SO_Ref_From_Expr
3152 begin
3153 -- Case of expression is an integer literal, in this case we just
3154 -- return the value (which must always be non-negative, since size
3155 -- and offset values can never be negative).
3162 -- Case where there is a reference to V, create function
3168 -- Check whether Vtype is a view of a private type and ensure that
3169 -- we use the primary view of the type (which is denoted by its
3170 -- Etype, whether it's the type's partial or full view entity).
3171 -- This is needed to make sure that we use the same (primary) view
3172 -- of the type for all V formals, whether the current view of the
3173 -- type is the partial or full view, so that types will always
3174 -- match on calls from one size function to another.
3178 else
3184 Decl :=
3187 Specification =>
3192 Defining_Identifier =>
3194 Parameter_Type =>
3196 Result_Definition =>
3201 Handled_Statement_Sequence =>
3207 -- The caller requests that the expression be encapsulated in a
3208 -- parameterless function.
3211 Decl :=
3214 Specification =>
3218 Result_Definition =>
3223 Handled_Statement_Sequence =>
3228 -- No reference to V and function not requested, so create a constant
3230 else
3231 Decl :=
3234 Object_Definition =>