| blob | 212dd3cd751f828ac595c480c81624b397172946 |
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-2004 Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
21 -- --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 -- --
25 ------------------------------------------------------------------------------
52 ------------------------
53 -- Local Declarations --
54 ------------------------
57 -- Short hand for System_Storage_Unit
60 -- Formal parameter name used for functions generated for size offset
61 -- values that depend on the discriminant. All such functions have the
62 -- following form:
63 --
64 -- function xxx (V : vtyp) return Unsigned is
65 -- begin
66 -- return ... expression involving V.discrim
67 -- end xxx;
69 -----------------------
70 -- Local Subprograms --
71 -----------------------
74 -- E is the entity for a type or object. This procedure checks that the
75 -- size and alignment are compatible, and if not either gives an error
76 -- message if they cannot be adjusted or else adjusts them appropriately.
78 function Assoc_Add
83 -- This is like Make_Op_Add except that it optimizes some cases knowing
84 -- that associative rearrangement is allowed for constant folding if one
85 -- of the operands is a compile time known value.
87 function Assoc_Multiply
92 -- This is like Make_Op_Multiply except that it optimizes some cases
93 -- knowing that associative rearrangement is allowed for constant
94 -- folding if one of the operands is a compile time known value
96 function Assoc_Subtract
101 -- This is like Make_Op_Subtract except that it optimizes some cases
102 -- knowing that associative rearrangement is allowed for constant
103 -- folding if one of the operands is a compile time known value
106 -- This is used when we cross the boundary from static sizes in bits to
107 -- dynamic sizes in storage units. If the argument N is anything other
108 -- than an integer literal, it is returned unchanged, but if it is an
109 -- integer literal, then it is taken as a size in bits, and is replaced
110 -- by the corresponding size in bytes.
113 -- Given expressions for the low bound (Lo) and the high bound (Hi),
114 -- Build an expression for the value hi-lo+1, converted to type
115 -- Standard.Unsigned. Takes care of the case where the operands
116 -- are of an enumeration type (so that the subtraction cannot be
117 -- done directly) by applying the Pos operator to Hi/Lo first.
119 function Expr_From_SO_Ref
124 -- Given a value D from a size or offset field, return an expression
125 -- representing the value stored. If the value is known at compile time,
126 -- then an N_Integer_Literal is returned with the appropriate value. If
127 -- the value references a constant entity, then an N_Identifier node
128 -- referencing this entity is returned. If the value denotes a size
129 -- function, then returns a call node denoting the given function, with
130 -- a single actual parameter that either refers to the parameter V of
131 -- an enclosing size function (if Comp is Empty or its type doesn't match
132 -- the function's formal), or else is a selected component V.c when Comp
133 -- denotes a component c whose type matches that of the function formal.
134 -- The Loc value is used for the Sloc value of constructed notes.
136 function SO_Ref_From_Expr
142 -- This routine is used in the case where a size/offset value is dynamic
143 -- and is represented by the expression Expr. SO_Ref_From_Expr checks if
144 -- the Expr contains a reference to the identifier V, and if so builds
145 -- a function depending on discriminants of the formal parameter V which
146 -- is of type Vtype. Otherwise, if the parameter Make_Func is True, then
147 -- Expr will be encapsulated in a parameterless function; if Make_Func is
148 -- False, then a constant entity with the value Expr is built. The result
149 -- is a Dynamic_SO_Ref to the created entity. Note that Vtype can be
150 -- omitted if Expr does not contain any reference to V, the created entity.
151 -- The declaration created is inserted in the freeze actions of Ins_Type,
152 -- which also supplies the Sloc for created nodes. This function also takes
153 -- care of making sure that the expression is properly analyzed and
154 -- resolved (which may not be the case yet if we build the expression
155 -- in this unit).
158 -- E is an array type or subtype that has at least one index bound that
159 -- is the value of a record discriminant. For such an array, the function
160 -- computes an expression that yields the maximum possible size of the
161 -- array in storage units. The result is not defined for any other type,
162 -- or for arrays that do not depend on discriminants, and it is a fatal
163 -- error to call this unless Size_Depends_On_Discriminant (E) is True.
166 -- Front-end layout of non-bit-packed array type or subtype
169 -- Front-end layout of record type
172 -- Rewrite node N with an integer literal whose value is V. The Sloc
173 -- for the new node is taken from N, and the type of the literal is
174 -- set to a copy of the type of N on entry.
176 procedure Set_And_Check_Static_Size
180 -- This procedure is called to check explicit given sizes (possibly
181 -- stored in the Esize and RM_Size fields of E) against computed
182 -- Object_Size (Esiz) and Value_Size (RM_Siz) values. Appropriate
183 -- errors and warnings are posted if specified sizes are inconsistent
184 -- with specified sizes. On return, the Esize and RM_Size fields of
185 -- E are set (either from previously given values, or from the newly
186 -- computed values, as appropriate).
189 -- This procedure is called for record types and subtypes, and also for
190 -- atomic array types and subtypes. If no alignment is set, and the size
191 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
192 -- match the size.
194 ----------------------------
195 -- Adjust_Esize_Alignment --
196 ----------------------------
202 begin
203 -- Nothing to do if size unknown
209 -- Determine if size is constrained by an attribute definition clause
210 -- which must be obeyed. If so, we cannot increase the size in this
211 -- routine.
213 -- For a type, the issue is whether an object size clause has been
214 -- set. A normal size clause constrains only the value size (RM_Size)
219 -- For an object, the issue is whether a size clause is present
221 else
225 -- If size is known it must be a multiple of the byte size
229 -- If not, and size specified, then give error
232 Error_Msg_NE
236 -- Otherwise bump up size to a byte boundary
238 else
243 -- Now we have the size set, it must be a multiple of the alignment
244 -- nothing more we can do here if the alignment is unknown here.
250 -- At this point both the Esize and Alignment are known, so we need
251 -- to make sure they are consistent.
259 -- Here we have a situation where the Esize is not a multiple of
260 -- the alignment. We must either increase Esize or reduce the
261 -- alignment to correct this situation.
263 -- The case in which we can decrease the alignment is where the
264 -- alignment was not set by an alignment clause, and the type in
265 -- question is a discrete type, where it is definitely safe to
266 -- reduce the alignment. For example:
268 -- t : integer range 1 .. 2;
269 -- for t'size use 8;
271 -- In this situation, the initial alignment of t is 4, copied from
272 -- the Integer base type, but it is safe to reduce it to 1 at this
273 -- stage, since we will only be loading a single byte.
277 then
278 loop
287 -- Now the only possible approach left is to increase the Esize
288 -- but we can't do that if the size was set by a specific clause.
291 Error_Msg_NE
295 -- Otherwise we can indeed increase the size to a multiple of alignment
297 else
302 ---------------
303 -- Assoc_Add --
304 ---------------
306 function Assoc_Add
310 return Node_Id
311 is
315 begin
316 -- Case of right operand is a constant
322 -- Case of left operand is a constant
328 -- Neither operand is a constant, do the addition with no optimization
330 else
334 -- Case of left operand is an addition
338 -- (C1 + E) + C2 = (C1 + C2) + E
341 Rewrite_Integer
346 -- (E + C1) + C2 = E + (C1 + C2)
349 Rewrite_Integer
355 -- Case of left operand is a subtraction
359 -- (C1 - E) + C2 = (C1 + C2) + E
362 Rewrite_Integer
367 -- (E - C1) + C2 = E - (C1 - C2)
370 Rewrite_Integer
377 -- Not optimizable, do the addition
382 --------------------
383 -- Assoc_Multiply --
384 --------------------
386 function Assoc_Multiply
390 return Node_Id
391 is
395 begin
396 -- Case of right operand is a constant
402 -- Case of left operand is a constant
408 -- Neither operand is a constant, do the multiply with no optimization
410 else
414 -- Case of left operand is an multiplication
418 -- (C1 * E) * C2 = (C1 * C2) + E
421 Rewrite_Integer
426 -- (E * C1) * C2 = E * (C1 * C2)
429 Rewrite_Integer
436 -- Not optimizable, do the multiplication
441 --------------------
442 -- Assoc_Subtract --
443 --------------------
445 function Assoc_Subtract
449 return Node_Id
450 is
454 begin
455 -- Case of right operand is a constant
461 -- Right operand is a constant, do the subtract with no optimization
463 else
467 -- Case of left operand is an addition
471 -- (C1 + E) - C2 = (C1 - C2) + E
474 Rewrite_Integer
479 -- (E + C1) - C2 = E + (C1 - C2)
482 Rewrite_Integer
488 -- Case of left operand is a subtraction
492 -- (C1 - E) - C2 = (C1 - C2) + E
495 Rewrite_Integer
500 -- (E - C1) - C2 = E - (C1 + C2)
503 Rewrite_Integer
510 -- Not optimizable, do the subtraction
515 ----------------
516 -- Bits_To_SU --
517 ----------------
520 begin
528 --------------------
529 -- Compute_Length --
530 --------------------
540 begin
541 -- If the bounds are First and Last attributes for the same dimension
542 -- and both have prefixes that denotes the same entity, then we create
543 -- and return a Length attribute. This may allow the back end to
544 -- generate better code in cases where it already has the length.
553 then
566 return
568 Prefix => New_Occurrence_Of
571 Expressions => New_List
579 -- If type is enumeration type, then use Pos attribute to convert
580 -- to integer type for which subtraction is a permitted operation.
583 Lo_Op :=
589 Hi_Op :=
596 return
598 Left_Opnd =>
605 ----------------------
606 -- Expr_From_SO_Ref --
607 ----------------------
609 function Expr_From_SO_Ref
613 return Node_Id
614 is
617 begin
622 -- If a component is passed in whose type matches the type
623 -- of the function formal, then select that component from
624 -- the "V" parameter rather than passing "V" directly.
629 then
630 return
638 else
639 return
646 else
650 else
655 ------------------
656 -- Get_Max_Size --
657 ------------------
671 record
677 -- Shows the status of the value so far. Const means that the value
678 -- is constant, and Val is the current constant value. Dynamic means
679 -- that the value is dynamic, and in this case Nod is the Node_Id of
680 -- the expression to compute the value.
683 -- Calculated value so far if Size.Status = Const,
684 -- or expression value so far if Size.Status = Dynamic.
687 -- This is set to True if the final result must be converted from
688 -- bits to storage units (rounding up to a storage unit boundary).
690 -----------------------
691 -- Local Subprograms --
692 -----------------------
695 -- If the node N represents a discriminant, replace it by the maximum
696 -- value of the discriminant.
699 -- If the node N represents a discriminant, replace it by the minimum
700 -- value of the discriminant.
702 -----------------
703 -- Max_Discrim --
704 -----------------
707 begin
710 then
715 -----------------
716 -- Min_Discrim --
717 -----------------
720 begin
723 then
728 -- Start of processing for Get_Max_Size
730 begin
733 -- Initialize status from component size
738 else
742 -- Loop through indices
753 -- Value of the current subscript range is statically known
757 then
760 -- If known flat bound, entire size of array is zero!
766 -- Current value is constant, evolve value
771 -- Current value is dynamic
773 else
774 -- An interesting little optimization, if we have a pending
775 -- conversion from bits to storage units, and the current
776 -- length is a multiple of the storage unit size, then we
777 -- can take the factor out here statically, avoiding some
778 -- extra dynamic computations at the end.
788 Right_Opnd =>
792 -- Value of the current subscript range is dynamic
794 else
795 -- If the current size value is constant, then here is where we
796 -- make a transition to dynamic values, which are always stored
797 -- in storage units, However, we do not want to convert to SU's
798 -- too soon, consider the case of a packed array of single bits,
799 -- we want to do the SU conversion after computing the size in
800 -- this case.
804 -- If the current value is a multiple of the storage unit,
805 -- then most certainly we can do the conversion now, simply
806 -- by dividing the current value by the storage unit value.
807 -- If this works, we set SU_Convert_Required to False.
811 Size :=
815 -- Otherwise, we go ahead and convert the value in bits,
816 -- and set SU_Convert_Required to True to ensure that the
817 -- final value is indeed properly converted.
819 else
825 -- Length is hi-lo+1
829 -- Check possible range of Len
831 declare
836 begin
842 -- If we cannot verify that range cannot be super-flat,
843 -- we need a max with zero, since length must be non-neg.
846 Len :=
848 Prefix =>
853 Len));
861 -- Here after processing all bounds to set sizes. If the value is
862 -- a constant, then it is bits, and we just return the value.
867 -- Case where the value is dynamic
869 else
870 -- Do convert from bits to SU's if needed
874 -- The expression required is (Size.Nod + SU - 1) / SU
878 Left_Opnd =>
889 -----------------------
890 -- Layout_Array_Type --
891 -----------------------
904 -- This is the type with which any generated constants or functions
905 -- will be associated (i.e. inserted into the freeze actions). This
906 -- is normally the type being laid out. The exception occurs when
907 -- we are laying out Itype's which are local to a record type, and
908 -- whose scope is this record type. Such types do not have freeze
909 -- nodes (because we have no place to put them).
911 ------------------------------------
912 -- How An Array Type is Laid Out --
913 ------------------------------------
915 -- Here is what goes on. We need to multiply the component size of
916 -- the array (which has already been set) by the length of each of
917 -- the indexes. If all these values are known at compile time, then
918 -- the resulting size of the array is the appropriate constant value.
920 -- If the component size or at least one bound is dynamic (but no
921 -- discriminants are present), then the size will be computed as an
922 -- expression that calculates the proper size.
924 -- If there is at least one discriminant bound, then the size is also
925 -- computed as an expression, but this expression contains discriminant
926 -- values which are obtained by selecting from a function parameter, and
927 -- the size is given by a function that is passed the variant record in
928 -- question, and whose body is the expression.
933 record
937 -- Calculated value so far if Val_Status = Const
941 -- Expression value so far if Val_Status /= Const
945 -- Records the value or expression computed so far. Const means that
946 -- the value is constant, and Val is the current constant value.
947 -- Dynamic means that the value is dynamic, and in this case Nod is
948 -- the Node_Id of the expression to compute the value, and Discrim
949 -- means that at least one bound is a discriminant, in which case Nod
950 -- is the expression so far (which will be the body of the function).
953 -- Value of size computed so far. See comments above.
956 -- Variant record type for the formal parameter of the
957 -- discriminant function V if Status = Discrim.
960 -- This is set to True if the final result must be converted from
961 -- bits to storage units (rounding up to a storage unit boundary).
964 -- This is the amount that a nonstatic computed size will be divided
965 -- by to convert it from bits to storage units. This is normally
966 -- equal to SSU, but can be reduced in the case of packed components
967 -- that fit evenly into a storage unit.
970 -- Indicates whether to request that SO_Ref_From_Expr should
971 -- encapsulate the array size expresion in a function.
974 -- If N represents a discriminant, then the Size.Status is set to
975 -- Discrim, and Vtyp is set. The parameter N is replaced with the
976 -- proper expression to extract the discriminant value from V.
978 ----------------
979 -- Discrimify --
980 ----------------
986 begin
989 then
997 -- Ensure that we get a private type's full type
1006 N :=
1011 -- Set the Etype attributes of the selected name and its prefix.
1012 -- Analyze_And_Resolve can't be called here because the Vname
1013 -- entity denoted by the prefix will not yet exist (it's created
1014 -- by SO_Ref_From_Expr, called at the end of Layout_Array_Type).
1021 -- Start of processing for Layout_Array_Type
1023 begin
1024 -- Default alignment is component alignment
1030 -- Calculate proper type for insertions
1034 else
1038 -- If the component type is a generic formal type then there's no point
1039 -- in determining a size for the array type.
1045 -- Deal with component size if base type
1049 -- Cannot do anything if Esize of component type unknown
1055 -- Set component size if not set already
1062 -- (RM 13.3 (48)) says that the size of an unconstrained array
1063 -- is implementation defined. We choose to leave it as Unknown
1064 -- here, and the actual behavior is determined by the back end.
1070 -- Initialize status from component size
1075 else
1079 -- Loop to process array indices
1085 -- If an index of the array is a generic formal type then there's
1086 -- no point in determining a size for the array type.
1095 -- Value of the current subscript range is statically known
1099 then
1102 -- If known flat bound, entire size of array is zero!
1110 -- If constant, evolve value
1115 -- Current value is dynamic
1117 else
1118 -- An interesting little optimization, if we have a pending
1119 -- conversion from bits to storage units, and the current
1120 -- length is a multiple of the storage unit size, then we
1121 -- can take the factor out here statically, avoiding some
1122 -- extra dynamic computations at the end.
1129 -- Now go ahead and evolve the expression
1134 Right_Opnd =>
1138 -- Value of the current subscript range is dynamic
1140 else
1141 -- If the current size value is constant, then here is where we
1142 -- make a transition to dynamic values, which are always stored
1143 -- in storage units, However, we do not want to convert to SU's
1144 -- too soon, consider the case of a packed array of single bits,
1145 -- we want to do the SU conversion after computing the size in
1146 -- this case.
1150 -- If the current value is a multiple of the storage unit,
1151 -- then most certainly we can do the conversion now, simply
1152 -- by dividing the current value by the storage unit value.
1153 -- If this works, we set SU_Convert_Required to False.
1156 Size :=
1160 -- If the current value is a factor of the storage unit,
1161 -- then we can use a value of one for the size and reduce
1162 -- the strength of the later division.
1169 -- Otherwise, we go ahead and convert the value in bits,
1170 -- and set SU_Convert_Required to True to ensure that the
1171 -- final value is indeed properly converted.
1173 else
1182 -- Length is hi-lo+1
1186 -- If Len isn't a Length attribute, then its range needs to
1187 -- be checked a possible Max with zero needs to be computed.
1191 then
1192 declare
1197 begin
1198 -- Check possible range of Len
1205 -- If range definitely flat or superflat,
1206 -- result size is zero
1214 -- If we cannot verify that range cannot be super-flat,
1215 -- we need a maximum with zero, since length cannot be
1216 -- negative.
1219 Len :=
1221 Prefix =>
1226 Len));
1231 -- At this stage, Len has the expression for the length
1242 -- Here after processing all bounds to set sizes. If the value is
1243 -- a constant, then it is bits, and the only thing we need to do
1244 -- is to check against explicit given size and do alignment adjust.
1250 -- Case where the value is dynamic
1252 else
1253 -- Do convert from bits to SU's if needed
1257 -- The expression required is:
1258 -- (Size.Nod + Storage_Divisor - 1) / Storage_Divisor
1262 Left_Opnd =>
1265 Right_Opnd => Make_Integer_Literal
1270 -- If the array entity is not declared at the library level and its
1271 -- not nested within a subprogram that is marked for inlining, then
1272 -- we request that the size expression be encapsulated in a function.
1273 -- Since this expression is not needed in most cases, we prefer not
1274 -- to incur the overhead of the computation on calls to the enclosing
1275 -- subprogram except for subprograms that require the size.
1280 declare
1283 begin
1295 -- Now set the dynamic size (the Value_Size is always the same
1296 -- as the Object_Size for arrays whose length is dynamic).
1298 -- ??? If Size.Status = Dynamic, Vtyp will not have been set.
1299 -- The added initialization sets it to Empty now, but is this
1300 -- correct?
1302 Set_Esize
1304 SO_Ref_From_Expr
1310 -------------------
1311 -- Layout_Object --
1312 -------------------
1317 begin
1318 -- Nothing to do if backend does layout
1324 -- Set size if not set for object and known for type. Use the
1325 -- RM_Size if that is known for the type and Esize is not.
1336 -- Set alignment from type if unknown and type alignment known
1342 -- Make sure size and alignment are consistent
1346 -- Final adjustment, if we don't know the alignment, and the Esize
1347 -- was not set by an explicit Object_Size attribute clause, then
1348 -- we reset the Esize to unknown, since we really don't know it.
1352 then
1357 ------------------------
1358 -- Layout_Record_Type --
1359 ------------------------
1366 -- Current component being laid out
1369 -- Previous laid out component
1371 procedure Get_Next_Component_Location
1378 -- Given the previous component in Prev_Comp, which is already laid
1379 -- out, and the alignment of the following component, lays out the
1380 -- following component, and returns its starting position in New_Npos
1381 -- (Normalized_Position value), New_Fbit (Normalized_First_Bit value),
1382 -- and New_NPMax (Normalized_Position_Max value). If Prev_Comp is empty
1383 -- (no previous component is present), then New_Npos, New_Fbit and
1384 -- New_NPMax are all set to zero on return. This procedure is also
1385 -- used to compute the size of a record or variant by giving it the
1386 -- last component, and the record alignment. Force_SU is used to force
1387 -- the new component location to be aligned on a storage unit boundary,
1388 -- even in a packed record, False means that the new position does not
1389 -- need to be bumped to a storage unit boundary, True means a storage
1390 -- unit boundary is always required.
1393 -- Lays out component Comp, given Prev_Comp, the previously laid-out
1394 -- component (Prev_Comp = Empty if no components laid out yet). The
1395 -- alignment of the record itself is also updated if needed. Both
1396 -- Comp and Prev_Comp can be either components or discriminants.
1398 procedure Layout_Components
1403 -- This procedure lays out the components of the given component list
1404 -- which contains the components starting with From and ending with To.
1405 -- The Next_Entity chain is used to traverse the components. On entry,
1406 -- Prev_Comp is set to the component preceding the list, so that the
1407 -- list is laid out after this component. Prev_Comp is set to Empty if
1408 -- the component list is to be laid out starting at the start of the
1409 -- record. On return, the components are all laid out, and Prev_Comp is
1410 -- set to the last laid out component. On return, Esiz is set to the
1411 -- resulting Object_Size value, which is the length of the record up
1412 -- to and including the last laid out entity. For Esiz, the value is
1413 -- adjusted to match the alignment of the record. RM_Siz is similarly
1414 -- set to the resulting Value_Size value, which is the same length, but
1415 -- not adjusted to meet the alignment. Note that in the case of variant
1416 -- records, Esiz represents the maximum size.
1419 -- Procedure called to lay out a non-variant record type or subtype
1422 -- Procedure called to lay out a variant record type. Decl is set to the
1423 -- full type declaration for the variant record.
1425 ---------------------------------
1426 -- Get_Next_Component_Location --
1427 ---------------------------------
1429 procedure Get_Next_Component_Location
1436 is
1437 begin
1438 -- No previous component, return zero position
1447 -- Here we have a previous component
1449 declare
1458 -- Expression representing maximum size of previous component
1460 begin
1461 -- Case where previous field had a dynamic size
1465 -- If the previous field had a dynamic length, then it is
1466 -- required to occupy an integral number of storage units,
1467 -- and start on a storage unit boundary. This means that
1468 -- the Normalized_First_Bit value is zero in the previous
1469 -- component, and the new value is also set to zero.
1473 -- In this case, the new position is given by an expression
1474 -- that is the sum of old normalized position and old size.
1476 New_Npos :=
1477 SO_Ref_From_Expr
1479 Left_Opnd =>
1481 Right_Opnd =>
1486 -- Get maximum size of previous component
1490 else
1494 -- Now we can compute the new max position. If the max size
1495 -- is static and the old position is static, then we can
1496 -- compute the new position statically.
1500 then
1503 -- Otherwise new max position is dynamic
1505 else
1506 New_NPMax :=
1507 SO_Ref_From_Expr
1515 -- Previous field has known static Esize
1517 else
1520 -- Bump New_Fbit to storage unit boundary if required
1526 -- If old normalized position is static, we can go ahead
1527 -- and compute the new normalized position directly.
1537 -- Bump alignment if stricter than prev
1543 -- The max position is always equal to the position if
1544 -- the latter is static, since arrays depending on the
1545 -- values of discriminants never have static sizes.
1550 -- Case of old normalized position is dynamic
1552 else
1553 -- If new bit position is within the current storage unit,
1554 -- we can just copy the old position as the result position
1555 -- (we have already set the new first bit value).
1561 -- If new bit position is past the current storage unit, we
1562 -- need to generate a new dynamic value for the position
1563 -- ??? need to deal with alignment
1565 else
1566 New_Npos :=
1567 SO_Ref_From_Expr
1570 Right_Opnd =>
1576 New_NPMax :=
1577 SO_Ref_From_Expr
1580 Right_Opnd =>
1592 ----------------------
1593 -- Layout_Component --
1594 ----------------------
1603 begin
1604 -- Parent field is always at start of record, this will overlap
1605 -- the actual fields that are part of the parent, and that's fine
1616 -- Check case of type of component has a scope of the record we
1617 -- are laying out. When this happens, the type in question is an
1618 -- Itype that has not yet been laid out (that's because such
1619 -- types do not get frozen in the normal manner, because there
1620 -- is no place for the freeze nodes).
1626 -- Increase alignment of record if necessary. Note that we do not
1627 -- do this for packed records, which have an alignment of one by
1628 -- default, or for records for which an explicit alignment was
1629 -- specified with an alignment clause.
1634 then
1638 -- If component already laid out, then we are done
1644 -- Set size of component from type. We use the Esize except in a
1645 -- packed record, where we use the RM_Size (since that is exactly
1646 -- what the RM_Size value, as distinct from the Object_Size is
1647 -- useful for!)
1651 else
1655 -- Compute the component position from the previous one. See if
1656 -- current component requires being on a storage unit boundary.
1658 -- If record is not packed, we always go to a storage unit boundary
1663 -- Packed cases
1665 else
1666 -- Elementary types do not need SU boundary in packed record
1671 -- Packed array types with a modular packed array type do not
1672 -- force a storage unit boundary (since the code generation
1673 -- treats these as equivalent to the underlying modular type),
1678 then
1681 -- Record types with known length less than or equal to the length
1682 -- of long long integer can also be unaligned, since they can be
1683 -- treated as scalars.
1688 then
1691 -- All other cases force a storage unit boundary, even when packed
1693 else
1698 -- Now get the next component location
1700 Get_Next_Component_Location
1706 -- Set Component_Bit_Offset in the static case
1710 then
1715 -----------------------
1716 -- Layout_Components --
1717 -----------------------
1719 procedure Layout_Components
1724 is
1729 begin
1730 -- Only lay out components if there are some to lay out!
1734 -- Lay out components with no component clauses
1737 loop
1740 then
1741 -- The compatibility of component clauses with composite
1742 -- types isn't checked in Sem_Ch13, so we check it here.
1747 then
1749 Error_Msg_NE
1752 Comp);
1755 else
1766 -- Set size fields, both are zero if no components
1772 else
1773 -- First the object size, for which we align past the last
1774 -- field to the alignment of the record (the object size
1775 -- is required to be a multiple of the alignment).
1777 Get_Next_Component_Location
1780 End_Npos,
1781 End_Fbit,
1782 End_NPMax,
1785 -- If the resulting normalized position is a dynamic reference,
1786 -- then the size is dynamic, and is stored in storage units.
1787 -- In this case, we set the RM_Size to the same value, it is
1788 -- simply not worth distinguishing Esize and RM_Size values in
1789 -- the dynamic case, since the RM has nothing to say about them.
1791 -- Note that a size cannot have been given in this case, since
1792 -- size specifications cannot be given for variable length types.
1794 declare
1797 begin
1801 -- Set the Object_Size allowing for alignment. In the
1802 -- dynamic case, we have to actually do the runtime
1803 -- computation. We can skip this in the non-packed
1804 -- record case if the last component has a smaller
1805 -- alignment than the overall record alignment.
1812 then
1813 -- The expression we build is
1814 -- (expr + align - 1) / align * align
1816 Esiz :=
1817 SO_Ref_From_Expr
1820 Left_Opnd =>
1822 Left_Opnd =>
1824 Left_Opnd =>
1826 Right_Opnd =>
1829 Right_Opnd =>
1831 Right_Opnd =>
1837 -- Here Esiz is static, so we can adjust the alignment
1838 -- directly go give the required aligned value.
1840 else
1844 -- Case where computed size is static
1846 else
1847 -- The ending size was computed in Npos in storage units,
1848 -- but the actual size is stored in bits, so adjust
1849 -- accordingly. We also adjust the size to match the
1850 -- alignment here.
1854 -- Compute the resulting Value_Size (RM_Size). For this
1855 -- purpose we do not force alignment of the record or
1856 -- storage size alignment of the result.
1858 Get_Next_Component_Location
1860 Uint_0,
1861 End_Npos,
1862 End_Fbit,
1863 End_NPMax,
1873 -------------------------------
1874 -- Layout_Non_Variant_Record --
1875 -------------------------------
1881 begin
1887 ---------------------------
1888 -- Layout_Variant_Record --
1889 ---------------------------
1898 -- Expression for the evolving RM_Siz value. This is typically a
1899 -- conditional expression which involves tests of discriminant
1900 -- values that are formed as references to the entity V. At
1901 -- the end of scanning all the components, a suitable function
1902 -- is constructed in which V is the parameter.
1904 -----------------------
1905 -- Local Subprograms --
1906 -----------------------
1908 procedure Layout_Component_List
1912 -- Recursive procedure, called to lay out one component list
1913 -- Esiz and RM_Siz_Expr are set to the Object_Size and Value_Size
1914 -- values respectively representing the record size up to and
1915 -- including the last component in the component list (including
1916 -- any variants in this component list). RM_Siz_Expr is returned
1917 -- as an expression which may in the general case involve some
1918 -- references to the discriminants of the current record value,
1919 -- referenced by selecting from the entity V.
1921 ---------------------------
1922 -- Layout_Component_List --
1923 ---------------------------
1925 procedure Layout_Component_List
1929 is
1937 begin
1939 Layout_Components
1944 else
1948 -- Case where no variants are present in the component list
1952 -- The Esiz value has been correctly set by the call to
1953 -- Layout_Components, so there is nothing more to be done.
1955 -- For RM_Siz, we have an SO_Ref value, which we must convert
1956 -- to an appropriate expression.
1959 RM_Siz_Expr :=
1963 else
1966 -- If the size is represented by a function, then we
1967 -- create an appropriate function call using V as
1968 -- the parameter to the call.
1971 RM_Siz_Expr :=
1977 -- If the size is represented by a constant, then the
1978 -- expression we want is a reference to this constant
1980 else
1985 -- Case where variants are present in this component list
1987 else
1988 declare
1997 begin
2004 Layout_Component_List
2007 -- Set the Object_Size. If this is the first variant,
2008 -- we just set the size of this first variant.
2013 -- Otherwise the Object_Size is formed as a maximum
2014 -- of Esiz so far from previous variants, and the new
2015 -- Esiz value from the variant we just processed.
2017 -- If both values are static, we can just compute the
2018 -- maximum directly to save building junk nodes.
2022 then
2025 -- If either value is dynamic, then we have to generate
2026 -- an appropriate Standard_Unsigned'Max attribute call.
2028 else
2029 Esiz :=
2030 SO_Ref_From_Expr
2033 Prefix =>
2042 -- Now deal with Value_Size (RM_Siz). We are aiming at
2043 -- an expression that looks like:
2045 -- if xxDx (V.disc) then rmsiz1
2046 -- else if xxDx (V.disc) then rmsiz2
2047 -- else ...
2049 -- Where rmsiz1, rmsiz2... are the RM_Siz values for the
2050 -- individual variants, and xxDx are the discriminant
2051 -- checking functions generated for the variant type.
2053 -- If this is the first variant, we simply set the
2054 -- result as the expression. Note that this takes
2055 -- care of the others case.
2060 -- Otherwise construct the appropriate test
2062 else
2063 -- The test to be used in general is a call to the
2064 -- discriminant checking function. However, it is
2065 -- definitely worth special casing the very common
2066 -- case where a single value is involved.
2072 then
2073 -- Discriminant to be tested
2075 Discrim :=
2077 Prefix =>
2079 Selector_Name =>
2080 New_Occurrence_Of
2083 Dtest :=
2088 -- Generate a call to the discriminant-checking
2089 -- function for the variant. Note that the result
2090 -- has to be complemented since the function returns
2091 -- False when the passed discriminant value matches.
2093 else
2094 -- The checking function takes all of the type's
2095 -- discriminants as parameters, so a list of all
2096 -- the selected discriminants must be constructed.
2101 Append (
2103 Prefix =>
2105 Selector_Name =>
2106 New_Occurrence_Of
2108 D_List);
2113 Dtest :=
2115 Right_Opnd =>
2117 Name =>
2118 New_Occurrence_Of
2120 Parameter_Associations =>
2121 D_List));
2124 RM_Siz_Expr :=
2126 Expressions =>
2127 New_List
2137 -- Start of processing for Layout_Variant_Record
2139 begin
2140 -- We need the discriminant checking functions, since we generate
2141 -- calls to these functions for the RM_Size expression, so make
2142 -- sure that these functions have been constructed in time.
2146 -- Lay out the discriminants
2148 Layout_Components
2154 -- Lay out the main component list (this will make recursive calls
2155 -- to lay out all component lists nested within variants).
2160 -- If the RM_Size is a literal, set its value
2165 -- Otherwise we construct a dynamic SO_Ref
2167 else
2169 SO_Ref_From_Expr
2176 -- Start of processing for Layout_Record_Type
2178 begin
2179 -- If this is a cloned subtype, just copy the size fields from the
2180 -- original, nothing else needs to be done in this case, since the
2181 -- components themselves are all shared.
2186 then
2191 -- Another special case, class-wide types. The RM says that the size
2192 -- of such types is implementation defined (RM 13.3(48)). What we do
2193 -- here is to leave the fields set as unknown values, and the backend
2194 -- determines the actual behavior.
2199 -- All other cases
2201 else
2202 -- Initialize alignment conservatively to 1. This value will
2203 -- be increased as necessary during processing of the record.
2209 -- Initialize previous component. This is Empty unless there
2210 -- are components which have already been laid out by component
2211 -- clauses. If there are such components, we start our lay out of
2212 -- the remaining components following the last such component.
2221 then
2223 or else
2226 then
2234 -- We have two separate circuits, one for non-variant records and
2235 -- one for variant records. For non-variant records, we simply go
2236 -- through the list of components. This handles all the non-variant
2237 -- cases including those cases of subtypes where there is no full
2238 -- type declaration, so the tree cannot be used to drive the layout.
2239 -- For variant records, we have to drive the layout from the tree
2240 -- since we need to understand the variant structure in this case.
2244 else
2248 -- Scan all the components
2254 and then
2256 then
2257 Layout_Variant_Record;
2258 else
2259 Layout_Non_Variant_Record;
2264 -----------------
2265 -- Layout_Type --
2266 -----------------
2269 begin
2270 -- For string literal types, for now, kill the size always, this
2271 -- is because gigi does not like or need the size to be set ???
2279 -- For access types, set size/alignment. This is system address
2280 -- size, except for fat pointers (unconstrained array access types),
2281 -- where the size is two times the address size, to accommodate the
2282 -- two pointers that are required for a fat pointer (data and
2283 -- template). Note that E_Access_Protected_Subprogram_Type is not
2284 -- an access type for this purpose since it is not a pointer but is
2285 -- equivalent to a record. For access subtypes, copy the size from
2286 -- the base type since Gigi represents them the same way.
2290 -- If Esize already set (e.g. by a size clause), then nothing
2291 -- further to be done here.
2296 -- Access to subprogram is a strange beast, and we let the
2297 -- backend figure out what is needed (it may be some kind
2298 -- of fat pointer, including the static link for example.
2303 -- For access subtypes, copy the size information from base type
2309 -- For other access types, we use either address size, or, if
2310 -- a fat pointer is used (pointer-to-unconstrained array case),
2311 -- twice the address size to accommodate a fat pointer.
2313 else
2314 declare
2317 begin
2320 then
2327 and then not Debug_Flag_6
2328 then
2331 -- Check for bad convention set
2333 if Warn_On_Export_Import
2334 and then
2336 or else
2338 then
2339 Error_Msg_N
2344 else
2352 -- Scalar types: set size and alignment
2356 -- For discrete types, the RM_Size and Esize must be set
2357 -- already, since this is part of the earlier processing
2358 -- and the front end is always required to lay out the
2359 -- sizes of such types (since they are available as static
2360 -- attributes). All we do is to check that this rule is
2361 -- indeed obeyed!
2365 -- If the RM_Size is not set, then here is where we set it.
2367 -- Note: an RM_Size of zero looks like not set here, but this
2368 -- is a rare case, and we can simply reset it without any harm.
2374 -- If Esize for a discrete type is not set then set it
2377 declare
2380 begin
2381 loop
2382 -- If size is big enough, set it and exit
2388 -- If the RM_Size is greater than 64 (happens only
2389 -- when strange values are specified by the user,
2390 -- then Esize is simply a copy of RM_Size, it will
2391 -- be further refined later on)
2397 -- Otherwise double possible size and keep trying
2399 else
2406 -- For non-discrete sclar types, if the RM_Size is not set,
2407 -- then set it now to a copy of the Esize if the Esize is set.
2409 else
2417 -- Non-elementary (composite) types
2419 else
2420 -- If RM_Size is known, set Esize if not known
2424 -- If the alignment is known, we bump the Esize up to the
2425 -- next alignment boundary if it is not already on one.
2428 declare
2432 begin
2437 -- If Esize is set, and RM_Size is not, RM_Size is copied from
2438 -- Esize at least for now this seems reasonable, and is in any
2439 -- case needed for compatibility with old versions of gigi.
2440 -- look to be unknown.
2446 -- For array base types, set component size if object size of
2447 -- the component type is known and is a small power of 2 (8,
2448 -- 16, 32, 64), since this is what will always be used.
2452 then
2453 declare
2456 begin
2457 -- For some reasons, access types can cause trouble,
2458 -- So let's just do this for discrete types ???
2463 then
2464 declare
2467 begin
2472 then
2481 -- Lay out array and record types if front end layout set
2490 -- Case of backend layout, we still do a little in the front end
2492 else
2493 -- Processing for record types
2497 -- Special remaining processing for record types with a known
2498 -- size of 16, 32, or 64 bits whose alignment is not yet set.
2499 -- For these types, we set a corresponding alignment matching
2500 -- the size if possible, or as large as possible if not.
2503 and then not Debug_Flag_Q
2504 then
2508 -- Procressing for array types
2512 -- For arrays that are required to be atomic, we do the same
2513 -- processing as described above for short records, since we
2514 -- really need to have the alignment set for the whole array.
2520 -- For unpacked array types, set an alignment of 1 if we know
2521 -- that the component alignment is not greater than 1. The reason
2522 -- we do this is to avoid unnecessary copying of slices of such
2523 -- arrays when passed to subprogram parameters (see special test
2524 -- in Exp_Ch6.Expand_Actuals).
2528 then
2531 then
2538 -- Final step is to check that Esize and RM_Size are compatible
2543 -- Esize is less than RM_Size. That's not good. First we test
2544 -- whether this was set deliberately with an Object_Size clause
2545 -- and if so, object to the clause.
2549 Error_Msg_F
2551 Expression (Get_Attribute_Definition_Clause
2555 -- Adjust Esize up to RM_Size value
2557 declare
2560 begin
2563 -- For scalar types, increase Object_Size to power of 2,
2564 -- but not less than a storage unit in any case (i.e.,
2565 -- normally this means it will be byte addressable).
2574 else
2578 -- Finally, make sure that alignment is consistent with
2579 -- the newly assigned size.
2583 loop
2592 ---------------------
2593 -- Rewrite_Integer --
2594 ---------------------
2600 begin
2605 -------------------------------
2606 -- Set_And_Check_Static_Size --
2607 -------------------------------
2609 procedure Set_And_Check_Static_Size
2613 is
2617 -- Spec is the number of bit specified in the size clause, and
2618 -- Min is the minimum computed size. An error is given that the
2619 -- specified size is too small if Spec < Min, and in this case
2620 -- both Esize and RM_Size are set to unknown in E. The error
2621 -- message is posted on node SC.
2624 -- Spec is the number of bits specified in the size clause, and
2625 -- Max is the maximum computed size. A warning is given about
2626 -- unused bits if Spec > Max. This warning is posted on node SC.
2628 --------------------------
2629 -- Check_Size_Too_Small --
2630 --------------------------
2633 begin
2636 Error_Msg_NE
2643 -----------------------
2644 -- Check_Unused_Bits --
2645 -----------------------
2648 begin
2655 -- Start of processing for Set_And_Check_Static_Size
2657 begin
2658 -- Case where Object_Size (Esize) is already set by a size clause
2667 -- Perform checks on specified size against computed sizes
2675 -- Case where Value_Size (RM_Size) is set by specific Value_Size
2676 -- clause (we do not need to worry about Value_Size being set by
2677 -- a Size clause, since that will have set Esize as well, and we
2678 -- already took care of that case).
2683 -- Perform checks on specified size against computed sizes
2691 -- Set sizes if unknown
2702 -----------------------------
2703 -- Set_Composite_Alignment --
2704 -----------------------------
2710 begin
2717 then
2720 else
2724 -- Size is known, alignment is not set
2726 -- Reset alignment to match size if size is exactly 2, 4, or 8 bytes
2735 -- On VMS, also reset for odd "in between" sizes, e.g. a 17-bit
2736 -- record is given an alignment of 4. This is more consistent with
2737 -- what DEC Ada does.
2747 else
2751 -- No special alignment fiddling needed
2753 else
2757 -- Here Align is set to the proposed improved alignment
2763 -- Further processing for record types only to reduce the alignment
2764 -- set by the above processing in some specific cases. We do not
2765 -- do this for atomic records, since we need max alignment there.
2769 -- For records, there is generally no point in setting alignment
2770 -- higher than word size since we cannot do better than move by
2771 -- words in any case
2777 -- Check components. If any component requires a higher
2778 -- alignment, then we set that higher alignment in any case.
2780 declare
2783 begin
2787 declare
2790 begin
2791 -- The cases to worry about are when the alignment
2792 -- of the component type is larger than the alignment
2793 -- we have so far, and either there is no component
2794 -- clause for the alignment, or the length set by
2795 -- the component clause matches the alignment set.
2798 and then
2801 and then
2804 then
2815 -- Set chosen alignment
2821 then
2827 --------------------------
2828 -- Set_Discrete_RM_Size --
2829 --------------------------
2834 begin
2835 -- All discrete types except for the base types in standard
2836 -- are constrained, so indicate this by setting Is_Constrained.
2840 -- We set generic types to have an unknown size, since the
2841 -- representation of a generic type is irrelevant, in view
2842 -- of the fact that they have nothing to do with code.
2847 -- If the subtype statically matches the first subtype, then
2848 -- it is required to have exactly the same layout. This is
2849 -- required by aliasing considerations.
2853 then
2857 -- In all other cases the RM_Size is set to the minimum size.
2858 -- Note that this routine is never called for subtypes for which
2859 -- the RM_Size is set explicitly by an attribute clause.
2861 else
2866 ------------------------
2867 -- Set_Elem_Alignment --
2868 ------------------------
2871 begin
2872 -- Do not set alignment for packed array types, unless we are doing
2873 -- front end layout, because otherwise this is always handled in the
2874 -- backend.
2879 -- If there is an alignment clause, then we respect it
2884 -- If the size is not set, then don't attempt to set the alignment. This
2885 -- happens in the backend layout case for access-to-subprogram types.
2890 -- For access types, do not set the alignment if the size is less than
2891 -- the allowed minimum size. This avoids cascaded error messages.
2895 then
2899 -- Here we calculate the alignment as the largest power of two
2900 -- multiple of System.Storage_Unit that does not exceed either
2901 -- the actual size of the type, or the maximum allowed alignment.
2903 declare
2908 begin
2912 loop
2916 -- Now we think we should set the alignment to A, but we
2917 -- skip this if an alignment is already set to a value
2918 -- greater than A (happens for derived types).
2920 -- However, if the alignment is known and too small it
2921 -- must be increased, this happens in a case like:
2923 -- type R is new Character;
2924 -- for R'Size use 16;
2926 -- Here the alignment inherited from Character is 1, but
2927 -- it must be increased to 2 to reflect the increased size.
2935 ----------------------
2936 -- SO_Ref_From_Expr --
2937 ----------------------
2939 function SO_Ref_From_Expr
2944 return Dynamic_SO_Ref
2945 is
2955 -- Function used to check one node for reference to V
2958 -- Function used to traverse tree to check for reference to V
2960 ----------------------
2961 -- Check_Node_V_Ref --
2962 ----------------------
2965 begin
2969 else
2973 else
2978 -- Start of processing for SO_Ref_From_Expr
2980 begin
2981 -- Case of expression is an integer literal, in this case we just
2982 -- return the value (which must always be non-negative, since size
2983 -- and offset values can never be negative).
2990 -- Case where there is a reference to V, create function
2997 Decl :=
3000 Specification =>
3005 Defining_Identifier =>
3007 Parameter_Type =>
3009 Subtype_Mark =>
3014 Handled_Statement_Sequence =>
3020 -- The caller requests that the expression be encapsulated in
3021 -- a parameterless function.
3024 Decl :=
3027 Specification =>
3035 Handled_Statement_Sequence =>
3040 -- No reference to V and function not requested, so create a constant
3042 else
3043 Decl :=
3046 Object_Definition =>