| blob | b5b1ef97e53430f79680486a6686c24241803ea9 |
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-2006, 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, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, 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
82 -- This is like Make_Op_Add except that it optimizes some cases knowing
83 -- that associative rearrangement is allowed for constant folding if one
84 -- of the operands is a compile time known value.
86 function Assoc_Multiply
90 -- This is like Make_Op_Multiply except that it optimizes some cases
91 -- knowing that associative rearrangement is allowed for constant
92 -- folding if one of the operands is a compile time known value
94 function Assoc_Subtract
98 -- This is like Make_Op_Subtract except that it optimizes some cases
99 -- knowing that associative rearrangement is allowed for constant
100 -- folding if one of the operands is a compile time known value
103 -- This is used when we cross the boundary from static sizes in bits to
104 -- dynamic sizes in storage units. If the argument N is anything other
105 -- than an integer literal, it is returned unchanged, but if it is an
106 -- integer literal, then it is taken as a size in bits, and is replaced
107 -- by the corresponding size in storage units.
110 -- Given expressions for the low bound (Lo) and the high bound (Hi),
111 -- Build an expression for the value hi-lo+1, converted to type
112 -- Standard.Unsigned. Takes care of the case where the operands
113 -- are of an enumeration type (so that the subtraction cannot be
114 -- done directly) by applying the Pos operator to Hi/Lo first.
116 function Expr_From_SO_Ref
120 -- Given a value D from a size or offset field, return an expression
121 -- representing the value stored. If the value is known at compile time,
122 -- then an N_Integer_Literal is returned with the appropriate value. If
123 -- the value references a constant entity, then an N_Identifier node
124 -- referencing this entity is returned. If the value denotes a size
125 -- function, then returns a call node denoting the given function, with
126 -- a single actual parameter that either refers to the parameter V of
127 -- an enclosing size function (if Comp is Empty or its type doesn't match
128 -- the function's formal), or else is a selected component V.c when Comp
129 -- denotes a component c whose type matches that of the function formal.
130 -- The Loc value is used for the Sloc value of constructed notes.
132 function SO_Ref_From_Expr
137 -- This routine is used in the case where a size/offset value is dynamic
138 -- and is represented by the expression Expr. SO_Ref_From_Expr checks if
139 -- the Expr contains a reference to the identifier V, and if so builds
140 -- a function depending on discriminants of the formal parameter V which
141 -- is of type Vtype. Otherwise, if the parameter Make_Func is True, then
142 -- Expr will be encapsulated in a parameterless function; if Make_Func is
143 -- False, then a constant entity with the value Expr is built. The result
144 -- is a Dynamic_SO_Ref to the created entity. Note that Vtype can be
145 -- omitted if Expr does not contain any reference to V, the created entity.
146 -- The declaration created is inserted in the freeze actions of Ins_Type,
147 -- which also supplies the Sloc for created nodes. This function also takes
148 -- care of making sure that the expression is properly analyzed and
149 -- resolved (which may not be the case yet if we build the expression
150 -- in this unit).
153 -- E is an array type or subtype that has at least one index bound that
154 -- is the value of a record discriminant. For such an array, the function
155 -- computes an expression that yields the maximum possible size of the
156 -- array in storage units. The result is not defined for any other type,
157 -- or for arrays that do not depend on discriminants, and it is a fatal
158 -- error to call this unless Size_Depends_On_Discriminant (E) is True.
161 -- Front-end layout of non-bit-packed array type or subtype
164 -- Front-end layout of record type
167 -- Rewrite node N with an integer literal whose value is V. The Sloc
168 -- for the new node is taken from N, and the type of the literal is
169 -- set to a copy of the type of N on entry.
171 procedure Set_And_Check_Static_Size
175 -- This procedure is called to check explicit given sizes (possibly
176 -- stored in the Esize and RM_Size fields of E) against computed
177 -- Object_Size (Esiz) and Value_Size (RM_Siz) values. Appropriate
178 -- errors and warnings are posted if specified sizes are inconsistent
179 -- with specified sizes. On return, the Esize and RM_Size fields of
180 -- E are set (either from previously given values, or from the newly
181 -- computed values, as appropriate).
184 -- This procedure is called for record types and subtypes, and also for
185 -- atomic array types and subtypes. If no alignment is set, and the size
186 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
187 -- match the size.
189 ----------------------------
190 -- Adjust_Esize_Alignment --
191 ----------------------------
197 begin
198 -- Nothing to do if size unknown
204 -- Determine if size is constrained by an attribute definition clause
205 -- which must be obeyed. If so, we cannot increase the size in this
206 -- routine.
208 -- For a type, the issue is whether an object size clause has been
209 -- set. A normal size clause constrains only the value size (RM_Size)
214 -- For an object, the issue is whether a size clause is present
216 else
220 -- If size is known it must be a multiple of the storage unit size
224 -- If not, and size specified, then give error
227 Error_Msg_NE
232 -- Otherwise bump up size to a storage unit boundary
234 else
239 -- Now we have the size set, it must be a multiple of the alignment
240 -- nothing more we can do here if the alignment is unknown here.
246 -- At this point both the Esize and Alignment are known, so we need
247 -- to make sure they are consistent.
255 -- Here we have a situation where the Esize is not a multiple of
256 -- the alignment. We must either increase Esize or reduce the
257 -- alignment to correct this situation.
259 -- The case in which we can decrease the alignment is where the
260 -- alignment was not set by an alignment clause, and the type in
261 -- question is a discrete type, where it is definitely safe to
262 -- reduce the alignment. For example:
264 -- t : integer range 1 .. 2;
265 -- for t'size use 8;
267 -- In this situation, the initial alignment of t is 4, copied from
268 -- the Integer base type, but it is safe to reduce it to 1 at this
269 -- stage, since we will only be loading a single storage unit.
273 then
274 loop
283 -- Now the only possible approach left is to increase the Esize
284 -- but we can't do that if the size was set by a specific clause.
287 Error_Msg_NE
291 -- Otherwise we can indeed increase the size to a multiple of alignment
293 else
298 ---------------
299 -- Assoc_Add --
300 ---------------
302 function Assoc_Add
306 is
310 begin
311 -- Case of right operand is a constant
317 -- Case of left operand is a constant
323 -- Neither operand is a constant, do the addition with no optimization
325 else
329 -- Case of left operand is an addition
333 -- (C1 + E) + C2 = (C1 + C2) + E
336 Rewrite_Integer
341 -- (E + C1) + C2 = E + (C1 + C2)
344 Rewrite_Integer
350 -- Case of left operand is a subtraction
354 -- (C1 - E) + C2 = (C1 + C2) + E
357 Rewrite_Integer
362 -- (E - C1) + C2 = E - (C1 - C2)
365 Rewrite_Integer
372 -- Not optimizable, do the addition
377 --------------------
378 -- Assoc_Multiply --
379 --------------------
381 function Assoc_Multiply
385 is
389 begin
390 -- Case of right operand is a constant
396 -- Case of left operand is a constant
402 -- Neither operand is a constant, do the multiply with no optimization
404 else
408 -- Case of left operand is an multiplication
412 -- (C1 * E) * C2 = (C1 * C2) + E
415 Rewrite_Integer
420 -- (E * C1) * C2 = E * (C1 * C2)
423 Rewrite_Integer
430 -- Not optimizable, do the multiplication
435 --------------------
436 -- Assoc_Subtract --
437 --------------------
439 function Assoc_Subtract
443 is
447 begin
448 -- Case of right operand is a constant
454 -- Right operand is a constant, do the subtract with no optimization
456 else
460 -- Case of left operand is an addition
464 -- (C1 + E) - C2 = (C1 - C2) + E
467 Rewrite_Integer
472 -- (E + C1) - C2 = E + (C1 - C2)
475 Rewrite_Integer
481 -- Case of left operand is a subtraction
485 -- (C1 - E) - C2 = (C1 - C2) + E
488 Rewrite_Integer
493 -- (E - C1) - C2 = E - (C1 + C2)
496 Rewrite_Integer
503 -- Not optimizable, do the subtraction
508 ----------------
509 -- Bits_To_SU --
510 ----------------
513 begin
521 --------------------
522 -- Compute_Length --
523 --------------------
533 begin
534 -- If the bounds are First and Last attributes for the same dimension
535 -- and both have prefixes that denotes the same entity, then we create
536 -- and return a Length attribute. This may allow the back end to
537 -- generate better code in cases where it already has the length.
546 then
559 return
561 Prefix => New_Occurrence_Of
564 Expressions => New_List
572 -- If type is enumeration type, then use Pos attribute to convert
573 -- to integer type for which subtraction is a permitted operation.
576 Lo_Op :=
582 Hi_Op :=
589 return
591 Left_Opnd =>
598 ----------------------
599 -- Expr_From_SO_Ref --
600 ----------------------
602 function Expr_From_SO_Ref
606 is
609 begin
614 -- If a component is passed in whose type matches the type
615 -- of the function formal, then select that component from
616 -- the "V" parameter rather than passing "V" directly.
621 then
622 return
630 else
631 return
638 else
642 else
647 ---------------------
648 -- Get_Max_SU_Size --
649 ---------------------
663 record
669 -- Shows the status of the value so far. Const means that the value
670 -- is constant, and Val is the current constant value. Dynamic means
671 -- that the value is dynamic, and in this case Nod is the Node_Id of
672 -- the expression to compute the value.
675 -- Calculated value so far if Size.Status = Const,
676 -- or expression value so far if Size.Status = Dynamic.
679 -- This is set to True if the final result must be converted from
680 -- bits to storage units (rounding up to a storage unit boundary).
682 -----------------------
683 -- Local Subprograms --
684 -----------------------
687 -- If the node N represents a discriminant, replace it by the maximum
688 -- value of the discriminant.
691 -- If the node N represents a discriminant, replace it by the minimum
692 -- value of the discriminant.
694 -----------------
695 -- Max_Discrim --
696 -----------------
699 begin
702 then
707 -----------------
708 -- Min_Discrim --
709 -----------------
712 begin
715 then
720 -- Start of processing for Get_Max_SU_Size
722 begin
725 -- Initialize status from component size
730 else
734 -- Loop through indices
745 -- Value of the current subscript range is statically known
749 then
752 -- If known flat bound, entire size of array is zero!
758 -- Current value is constant, evolve value
763 -- Current value is dynamic
765 else
766 -- An interesting little optimization, if we have a pending
767 -- conversion from bits to storage units, and the current
768 -- length is a multiple of the storage unit size, then we
769 -- can take the factor out here statically, avoiding some
770 -- extra dynamic computations at the end.
780 Right_Opnd =>
784 -- Value of the current subscript range is dynamic
786 else
787 -- If the current size value is constant, then here is where we
788 -- make a transition to dynamic values, which are always stored
789 -- in storage units, However, we do not want to convert to SU's
790 -- too soon, consider the case of a packed array of single bits,
791 -- we want to do the SU conversion after computing the size in
792 -- this case.
796 -- If the current value is a multiple of the storage unit,
797 -- then most certainly we can do the conversion now, simply
798 -- by dividing the current value by the storage unit value.
799 -- If this works, we set SU_Convert_Required to False.
803 Size :=
807 -- Otherwise, we go ahead and convert the value in bits,
808 -- and set SU_Convert_Required to True to ensure that the
809 -- final value is indeed properly converted.
811 else
817 -- Length is hi-lo+1
821 -- Check possible range of Len
823 declare
828 begin
834 -- If we cannot verify that range cannot be super-flat,
835 -- we need a max with zero, since length must be non-neg.
838 Len :=
840 Prefix =>
845 Len));
853 -- Here after processing all bounds to set sizes. If the value is
854 -- a constant, then it is bits, so we convert to storage units.
859 -- Case where the value is dynamic
861 else
862 -- Do convert from bits to SU's if needed
866 -- The expression required is (Size.Nod + SU - 1) / SU
870 Left_Opnd =>
881 -----------------------
882 -- Layout_Array_Type --
883 -----------------------
896 -- This is the type with which any generated constants or functions
897 -- will be associated (i.e. inserted into the freeze actions). This
898 -- is normally the type being laid out. The exception occurs when
899 -- we are laying out Itype's which are local to a record type, and
900 -- whose scope is this record type. Such types do not have freeze
901 -- nodes (because we have no place to put them).
903 ------------------------------------
904 -- How An Array Type is Laid Out --
905 ------------------------------------
907 -- Here is what goes on. We need to multiply the component size of
908 -- the array (which has already been set) by the length of each of
909 -- the indexes. If all these values are known at compile time, then
910 -- the resulting size of the array is the appropriate constant value.
912 -- If the component size or at least one bound is dynamic (but no
913 -- discriminants are present), then the size will be computed as an
914 -- expression that calculates the proper size.
916 -- If there is at least one discriminant bound, then the size is also
917 -- computed as an expression, but this expression contains discriminant
918 -- values which are obtained by selecting from a function parameter, and
919 -- the size is given by a function that is passed the variant record in
920 -- question, and whose body is the expression.
925 record
929 -- Calculated value so far if Val_Status = Const
933 -- Expression value so far if Val_Status /= Const
937 -- Records the value or expression computed so far. Const means that
938 -- the value is constant, and Val is the current constant value.
939 -- Dynamic means that the value is dynamic, and in this case Nod is
940 -- the Node_Id of the expression to compute the value, and Discrim
941 -- means that at least one bound is a discriminant, in which case Nod
942 -- is the expression so far (which will be the body of the function).
945 -- Value of size computed so far. See comments above
948 -- Variant record type for the formal parameter of the
949 -- discriminant function V if Status = Discrim.
952 -- This is set to True if the final result must be converted from
953 -- bits to storage units (rounding up to a storage unit boundary).
956 -- This is the amount that a nonstatic computed size will be divided
957 -- by to convert it from bits to storage units. This is normally
958 -- equal to SSU, but can be reduced in the case of packed components
959 -- that fit evenly into a storage unit.
962 -- Indicates whether to request that SO_Ref_From_Expr should
963 -- encapsulate the array size expresion in a function.
966 -- If N represents a discriminant, then the Size.Status is set to
967 -- Discrim, and Vtyp is set. The parameter N is replaced with the
968 -- proper expression to extract the discriminant value from V.
970 ----------------
971 -- Discrimify --
972 ----------------
978 begin
981 then
992 N :=
997 -- Set the Etype attributes of the selected name and its prefix.
998 -- Analyze_And_Resolve can't be called here because the Vname
999 -- entity denoted by the prefix will not yet exist (it's created
1000 -- by SO_Ref_From_Expr, called at the end of Layout_Array_Type).
1007 -- Start of processing for Layout_Array_Type
1009 begin
1010 -- Default alignment is component alignment
1016 -- Calculate proper type for insertions
1020 else
1024 -- If the component type is a generic formal type then there's no point
1025 -- in determining a size for the array type.
1031 -- Deal with component size if base type
1035 -- Cannot do anything if Esize of component type unknown
1041 -- Set component size if not set already
1048 -- (RM 13.3 (48)) says that the size of an unconstrained array
1049 -- is implementation defined. We choose to leave it as Unknown
1050 -- here, and the actual behavior is determined by the back end.
1056 -- Initialize status from component size
1061 else
1065 -- Loop to process array indices
1071 -- If an index of the array is a generic formal type then there's
1072 -- no point in determining a size for the array type.
1081 -- Value of the current subscript range is statically known
1085 then
1088 -- If known flat bound, entire size of array is zero!
1096 -- If constant, evolve value
1101 -- Current value is dynamic
1103 else
1104 -- An interesting little optimization, if we have a pending
1105 -- conversion from bits to storage units, and the current
1106 -- length is a multiple of the storage unit size, then we
1107 -- can take the factor out here statically, avoiding some
1108 -- extra dynamic computations at the end.
1115 -- Now go ahead and evolve the expression
1120 Right_Opnd =>
1124 -- Value of the current subscript range is dynamic
1126 else
1127 -- If the current size value is constant, then here is where we
1128 -- make a transition to dynamic values, which are always stored
1129 -- in storage units, However, we do not want to convert to SU's
1130 -- too soon, consider the case of a packed array of single bits,
1131 -- we want to do the SU conversion after computing the size in
1132 -- this case.
1136 -- If the current value is a multiple of the storage unit,
1137 -- then most certainly we can do the conversion now, simply
1138 -- by dividing the current value by the storage unit value.
1139 -- If this works, we set SU_Convert_Required to False.
1142 Size :=
1146 -- If the current value is a factor of the storage unit,
1147 -- then we can use a value of one for the size and reduce
1148 -- the strength of the later division.
1155 -- Otherwise, we go ahead and convert the value in bits,
1156 -- and set SU_Convert_Required to True to ensure that the
1157 -- final value is indeed properly converted.
1159 else
1168 -- Length is hi-lo+1
1172 -- If Len isn't a Length attribute, then its range needs to
1173 -- be checked a possible Max with zero needs to be computed.
1177 then
1178 declare
1183 begin
1184 -- Check possible range of Len
1191 -- If range definitely flat or superflat,
1192 -- result size is zero
1200 -- If we cannot verify that range cannot be super-flat,
1201 -- we need a maximum with zero, since length cannot be
1202 -- negative.
1205 Len :=
1207 Prefix =>
1212 Len));
1217 -- At this stage, Len has the expression for the length
1228 -- Here after processing all bounds to set sizes. If the value is
1229 -- a constant, then it is bits, and the only thing we need to do
1230 -- is to check against explicit given size and do alignment adjust.
1236 -- Case where the value is dynamic
1238 else
1239 -- Do convert from bits to SU's if needed
1243 -- The expression required is:
1244 -- (Size.Nod + Storage_Divisor - 1) / Storage_Divisor
1248 Left_Opnd =>
1251 Right_Opnd => Make_Integer_Literal
1256 -- If the array entity is not declared at the library level and its
1257 -- not nested within a subprogram that is marked for inlining, then
1258 -- we request that the size expression be encapsulated in a function.
1259 -- Since this expression is not needed in most cases, we prefer not
1260 -- to incur the overhead of the computation on calls to the enclosing
1261 -- subprogram except for subprograms that require the size.
1266 declare
1269 begin
1281 -- Now set the dynamic size (the Value_Size is always the same
1282 -- as the Object_Size for arrays whose length is dynamic).
1284 -- ??? If Size.Status = Dynamic, Vtyp will not have been set.
1285 -- The added initialization sets it to Empty now, but is this
1286 -- correct?
1288 Set_Esize
1290 SO_Ref_From_Expr
1296 -------------------
1297 -- Layout_Object --
1298 -------------------
1303 begin
1304 -- Nothing to do if backend does layout
1310 -- Set size if not set for object and known for type. Use the
1311 -- RM_Size if that is known for the type and Esize is not.
1322 -- Set alignment from type if unknown and type alignment known
1328 -- Make sure size and alignment are consistent
1332 -- Final adjustment, if we don't know the alignment, and the Esize
1333 -- was not set by an explicit Object_Size attribute clause, then
1334 -- we reset the Esize to unknown, since we really don't know it.
1338 then
1343 ------------------------
1344 -- Layout_Record_Type --
1345 ------------------------
1352 -- Current component being laid out
1355 -- Previous laid out component
1357 procedure Get_Next_Component_Location
1364 -- Given the previous component in Prev_Comp, which is already laid
1365 -- out, and the alignment of the following component, lays out the
1366 -- following component, and returns its starting position in New_Npos
1367 -- (Normalized_Position value), New_Fbit (Normalized_First_Bit value),
1368 -- and New_NPMax (Normalized_Position_Max value). If Prev_Comp is empty
1369 -- (no previous component is present), then New_Npos, New_Fbit and
1370 -- New_NPMax are all set to zero on return. This procedure is also
1371 -- used to compute the size of a record or variant by giving it the
1372 -- last component, and the record alignment. Force_SU is used to force
1373 -- the new component location to be aligned on a storage unit boundary,
1374 -- even in a packed record, False means that the new position does not
1375 -- need to be bumped to a storage unit boundary, True means a storage
1376 -- unit boundary is always required.
1379 -- Lays out component Comp, given Prev_Comp, the previously laid-out
1380 -- component (Prev_Comp = Empty if no components laid out yet). The
1381 -- alignment of the record itself is also updated if needed. Both
1382 -- Comp and Prev_Comp can be either components or discriminants.
1384 procedure Layout_Components
1389 -- This procedure lays out the components of the given component list
1390 -- which contains the components starting with From and ending with To.
1391 -- The Next_Entity chain is used to traverse the components. On entry,
1392 -- Prev_Comp is set to the component preceding the list, so that the
1393 -- list is laid out after this component. Prev_Comp is set to Empty if
1394 -- the component list is to be laid out starting at the start of the
1395 -- record. On return, the components are all laid out, and Prev_Comp is
1396 -- set to the last laid out component. On return, Esiz is set to the
1397 -- resulting Object_Size value, which is the length of the record up
1398 -- to and including the last laid out entity. For Esiz, the value is
1399 -- adjusted to match the alignment of the record. RM_Siz is similarly
1400 -- set to the resulting Value_Size value, which is the same length, but
1401 -- not adjusted to meet the alignment. Note that in the case of variant
1402 -- records, Esiz represents the maximum size.
1405 -- Procedure called to lay out a non-variant record type or subtype
1408 -- Procedure called to lay out a variant record type. Decl is set to the
1409 -- full type declaration for the variant record.
1411 ---------------------------------
1412 -- Get_Next_Component_Location --
1413 ---------------------------------
1415 procedure Get_Next_Component_Location
1422 is
1423 begin
1424 -- No previous component, return zero position
1433 -- Here we have a previous component
1435 declare
1444 -- Expression representing maximum size of previous component
1446 begin
1447 -- Case where previous field had a dynamic size
1451 -- If the previous field had a dynamic length, then it is
1452 -- required to occupy an integral number of storage units,
1453 -- and start on a storage unit boundary. This means that
1454 -- the Normalized_First_Bit value is zero in the previous
1455 -- component, and the new value is also set to zero.
1459 -- In this case, the new position is given by an expression
1460 -- that is the sum of old normalized position and old size.
1462 New_Npos :=
1463 SO_Ref_From_Expr
1465 Left_Opnd =>
1467 Right_Opnd =>
1472 -- Get maximum size of previous component
1476 else
1480 -- Now we can compute the new max position. If the max size
1481 -- is static and the old position is static, then we can
1482 -- compute the new position statically.
1486 then
1489 -- Otherwise new max position is dynamic
1491 else
1492 New_NPMax :=
1493 SO_Ref_From_Expr
1501 -- Previous field has known static Esize
1503 else
1506 -- Bump New_Fbit to storage unit boundary if required
1512 -- If old normalized position is static, we can go ahead
1513 -- and compute the new normalized position directly.
1523 -- Bump alignment if stricter than prev
1529 -- The max position is always equal to the position if
1530 -- the latter is static, since arrays depending on the
1531 -- values of discriminants never have static sizes.
1536 -- Case of old normalized position is dynamic
1538 else
1539 -- If new bit position is within the current storage unit,
1540 -- we can just copy the old position as the result position
1541 -- (we have already set the new first bit value).
1547 -- If new bit position is past the current storage unit, we
1548 -- need to generate a new dynamic value for the position
1549 -- ??? need to deal with alignment
1551 else
1552 New_Npos :=
1553 SO_Ref_From_Expr
1556 Right_Opnd =>
1562 New_NPMax :=
1563 SO_Ref_From_Expr
1566 Right_Opnd =>
1578 ----------------------
1579 -- Layout_Component --
1580 ----------------------
1590 begin
1591 -- Increase alignment of record if necessary. Note that we do not
1592 -- do this for packed records, which have an alignment of one by
1593 -- default, or for records for which an explicit alignment was
1594 -- specified with an alignment clause.
1599 then
1603 -- If original component set, then use same layout
1614 -- Parent field is always at start of record, this will overlap
1615 -- the actual fields that are part of the parent, and that's fine
1626 -- Check case of type of component has a scope of the record we
1627 -- are laying out. When this happens, the type in question is an
1628 -- Itype that has not yet been laid out (that's because such
1629 -- types do not get frozen in the normal manner, because there
1630 -- is no place for the freeze nodes).
1636 -- If component already laid out, then we are done
1642 -- Set size of component from type. We use the Esize except in a
1643 -- packed record, where we use the RM_Size (since that is exactly
1644 -- what the RM_Size value, as distinct from the Object_Size is
1645 -- useful for!)
1649 else
1653 -- Compute the component position from the previous one. See if
1654 -- current component requires being on a storage unit boundary.
1656 -- If record is not packed, we always go to a storage unit boundary
1661 -- Packed cases
1663 else
1664 -- Elementary types do not need SU boundary in packed record
1669 -- Packed array types with a modular packed array type do not
1670 -- force a storage unit boundary (since the code generation
1671 -- treats these as equivalent to the underlying modular type),
1676 then
1679 -- Record types with known length less than or equal to the length
1680 -- of long long integer can also be unaligned, since they can be
1681 -- treated as scalars.
1686 then
1689 -- All other cases force a storage unit boundary, even when packed
1691 else
1696 -- Now get the next component location
1698 Get_Next_Component_Location
1704 -- Set Component_Bit_Offset in the static case
1708 then
1713 -----------------------
1714 -- Layout_Components --
1715 -----------------------
1717 procedure Layout_Components
1722 is
1727 begin
1728 -- Only lay out components if there are some to lay out!
1732 -- Lay out components with no component clauses
1735 loop
1738 then
1739 -- The compatibility of component clauses with composite
1740 -- types isn't checked in Sem_Ch13, so we check it here.
1745 then
1747 Error_Msg_NE
1750 Comp);
1753 else
1764 -- Set size fields, both are zero if no components
1770 -- If record subtype with non-static discriminants, then we don't
1771 -- know which variant will be the one which gets chosen. We don't
1772 -- just want to set the maximum size from the base, because the
1773 -- size should depend on the particular variant.
1775 -- What we do is to use the RM_Size of the base type, which has
1776 -- the necessary conditional computation of the size, using the
1777 -- size information for the particular variant chosen. Records
1778 -- with default discriminants for example have an Esize that is
1779 -- set to the maximum of all variants, but that's not what we
1780 -- want for a constrained subtype.
1784 then
1785 declare
1787 begin
1793 else
1794 -- First the object size, for which we align past the last field
1795 -- to the alignment of the record (the object size is required to
1796 -- be a multiple of the alignment).
1798 Get_Next_Component_Location
1801 End_Npos,
1802 End_Fbit,
1803 End_NPMax,
1806 -- If the resulting normalized position is a dynamic reference,
1807 -- then the size is dynamic, and is stored in storage units. In
1808 -- this case, we set the RM_Size to the same value, it is simply
1809 -- not worth distinguishing Esize and RM_Size values in the
1810 -- dynamic case, since the RM has nothing to say about them.
1812 -- Note that a size cannot have been given in this case, since
1813 -- size specifications cannot be given for variable length types.
1815 declare
1818 begin
1822 -- Set the Object_Size allowing for the alignment. In the
1823 -- dynamic case, we must do the actual runtime computation.
1824 -- We can skip this in the non-packed record case if the
1825 -- last component has a smaller alignment than the overall
1826 -- record alignment.
1833 then
1834 -- The expression we build is:
1835 -- (expr + align - 1) / align * align
1837 Esiz :=
1838 SO_Ref_From_Expr
1841 Left_Opnd =>
1843 Left_Opnd =>
1845 Left_Opnd =>
1847 Right_Opnd =>
1850 Right_Opnd =>
1852 Right_Opnd =>
1858 -- Here Esiz is static, so we can adjust the alignment
1859 -- directly go give the required aligned value.
1861 else
1865 -- Case where computed size is static
1867 else
1868 -- The ending size was computed in Npos in storage units,
1869 -- but the actual size is stored in bits, so adjust
1870 -- accordingly. We also adjust the size to match the
1871 -- alignment here.
1875 -- Compute the resulting Value_Size (RM_Size). For this
1876 -- purpose we do not force alignment of the record or
1877 -- storage size alignment of the result.
1879 Get_Next_Component_Location
1881 Uint_0,
1882 End_Npos,
1883 End_Fbit,
1884 End_NPMax,
1894 -------------------------------
1895 -- Layout_Non_Variant_Record --
1896 -------------------------------
1901 begin
1907 ---------------------------
1908 -- Layout_Variant_Record --
1909 ---------------------------
1919 -- Expression for the evolving RM_Siz value. This is typically a
1920 -- conditional expression which involves tests of discriminant
1921 -- values that are formed as references to the entity V. At
1922 -- the end of scanning all the components, a suitable function
1923 -- is constructed in which V is the parameter.
1925 -----------------------
1926 -- Local Subprograms --
1927 -----------------------
1929 procedure Layout_Component_List
1933 -- Recursive procedure, called to lay out one component list
1934 -- Esiz and RM_Siz_Expr are set to the Object_Size and Value_Size
1935 -- values respectively representing the record size up to and
1936 -- including the last component in the component list (including
1937 -- any variants in this component list). RM_Siz_Expr is returned
1938 -- as an expression which may in the general case involve some
1939 -- references to the discriminants of the current record value,
1940 -- referenced by selecting from the entity V.
1942 ---------------------------
1943 -- Layout_Component_List --
1944 ---------------------------
1946 procedure Layout_Component_List
1950 is
1958 begin
1960 Layout_Components
1965 else
1969 -- Case where no variants are present in the component list
1973 -- The Esiz value has been correctly set by the call to
1974 -- Layout_Components, so there is nothing more to be done.
1976 -- For RM_Siz, we have an SO_Ref value, which we must convert
1977 -- to an appropriate expression.
1980 RM_Siz_Expr :=
1984 else
1987 -- If the size is represented by a function, then we
1988 -- create an appropriate function call using V as
1989 -- the parameter to the call.
1992 RM_Siz_Expr :=
1998 -- If the size is represented by a constant, then the
1999 -- expression we want is a reference to this constant
2001 else
2006 -- Case where variants are present in this component list
2008 else
2009 declare
2018 begin
2025 Layout_Component_List
2028 -- Set the Object_Size. If this is the first variant,
2029 -- we just set the size of this first variant.
2034 -- Otherwise the Object_Size is formed as a maximum
2035 -- of Esiz so far from previous variants, and the new
2036 -- Esiz value from the variant we just processed.
2038 -- If both values are static, we can just compute the
2039 -- maximum directly to save building junk nodes.
2043 then
2046 -- If either value is dynamic, then we have to generate
2047 -- an appropriate Standard_Unsigned'Max attribute call.
2048 -- If one of the values is static then it needs to be
2049 -- converted from bits to storage units to be compatible
2050 -- with the dynamic value.
2052 else
2061 Esiz :=
2062 SO_Ref_From_Expr
2065 Prefix =>
2074 -- Now deal with Value_Size (RM_Siz). We are aiming at
2075 -- an expression that looks like:
2077 -- if xxDx (V.disc) then rmsiz1
2078 -- else if xxDx (V.disc) then rmsiz2
2079 -- else ...
2081 -- Where rmsiz1, rmsiz2... are the RM_Siz values for the
2082 -- individual variants, and xxDx are the discriminant
2083 -- checking functions generated for the variant type.
2085 -- If this is the first variant, we simply set the
2086 -- result as the expression. Note that this takes
2087 -- care of the others case.
2092 -- Otherwise construct the appropriate test
2094 else
2095 -- The test to be used in general is a call to the
2096 -- discriminant checking function. However, it is
2097 -- definitely worth special casing the very common
2098 -- case where a single value is involved.
2104 then
2105 -- Discriminant to be tested
2107 Discrim :=
2109 Prefix =>
2111 Selector_Name =>
2112 New_Occurrence_Of
2115 Dtest :=
2120 -- Generate a call to the discriminant-checking
2121 -- function for the variant. Note that the result
2122 -- has to be complemented since the function returns
2123 -- False when the passed discriminant value matches.
2125 else
2126 -- The checking function takes all of the type's
2127 -- discriminants as parameters, so a list of all
2128 -- the selected discriminants must be constructed.
2133 Append (
2135 Prefix =>
2137 Selector_Name =>
2138 New_Occurrence_Of
2140 D_List);
2145 Dtest :=
2147 Right_Opnd =>
2149 Name =>
2150 New_Occurrence_Of
2152 Parameter_Associations =>
2153 D_List));
2156 RM_Siz_Expr :=
2158 Expressions =>
2159 New_List
2169 -- Start of processing for Layout_Variant_Record
2171 begin
2172 -- We need the discriminant checking functions, since we generate
2173 -- calls to these functions for the RM_Size expression, so make
2174 -- sure that these functions have been constructed in time.
2178 -- Lay out the discriminants
2186 Layout_Components
2192 -- Lay out the main component list (this will make recursive calls
2193 -- to lay out all component lists nested within variants).
2198 -- If the RM_Size is a literal, set its value
2203 -- Otherwise we construct a dynamic SO_Ref
2205 else
2207 SO_Ref_From_Expr
2214 -- Start of processing for Layout_Record_Type
2216 begin
2217 -- If this is a cloned subtype, just copy the size fields from the
2218 -- original, nothing else needs to be done in this case, since the
2219 -- components themselves are all shared.
2222 or else
2225 then
2230 -- Another special case, class-wide types. The RM says that the size
2231 -- of such types is implementation defined (RM 13.3(48)). What we do
2232 -- here is to leave the fields set as unknown values, and the backend
2233 -- determines the actual behavior.
2238 -- All other cases
2240 else
2241 -- Initialize alignment conservatively to 1. This value will
2242 -- be increased as necessary during processing of the record.
2248 -- Initialize previous component. This is Empty unless there
2249 -- are components which have already been laid out by component
2250 -- clauses. If there are such components, we start our lay out of
2251 -- the remaining components following the last such component.
2260 then
2262 or else
2265 then
2273 -- We have two separate circuits, one for non-variant records and
2274 -- one for variant records. For non-variant records, we simply go
2275 -- through the list of components. This handles all the non-variant
2276 -- cases including those cases of subtypes where there is no full
2277 -- type declaration, so the tree cannot be used to drive the layout.
2278 -- For variant records, we have to drive the layout from the tree
2279 -- since we need to understand the variant structure in this case.
2283 else
2287 -- Scan all the components
2293 and then
2295 then
2296 Layout_Variant_Record;
2297 else
2298 Layout_Non_Variant_Record;
2303 -----------------
2304 -- Layout_Type --
2305 -----------------
2308 begin
2309 -- For string literal types, for now, kill the size always, this
2310 -- is because gigi does not like or need the size to be set ???
2318 -- For access types, set size/alignment. This is system address
2319 -- size, except for fat pointers (unconstrained array access types),
2320 -- where the size is two times the address size, to accommodate the
2321 -- two pointers that are required for a fat pointer (data and
2322 -- template). Note that E_Access_Protected_Subprogram_Type is not
2323 -- an access type for this purpose since it is not a pointer but is
2324 -- equivalent to a record. For access subtypes, copy the size from
2325 -- the base type since Gigi represents them the same way.
2329 -- If Esize already set (e.g. by a size clause), then nothing
2330 -- further to be done here.
2335 -- Access to subprogram is a strange beast, and we let the
2336 -- backend figure out what is needed (it may be some kind
2337 -- of fat pointer, including the static link for example.
2342 -- For access subtypes, copy the size information from base type
2348 -- For other access types, we use either address size, or, if
2349 -- a fat pointer is used (pointer-to-unconstrained array case),
2350 -- twice the address size to accommodate a fat pointer.
2352 else
2353 declare
2356 begin
2359 then
2366 and then not Debug_Flag_6
2367 then
2370 -- Check for bad convention set
2372 if Warn_On_Export_Import
2373 and then
2375 or else
2377 then
2378 Error_Msg_N
2383 else
2389 -- On VMS, reset size to 32 for convention C access type if no
2390 -- explicit size clause is given and the default size is 64. Really
2391 -- we do not know the size, since depending on options for the VMS
2392 -- compiler, the size of a pointer type can be 32 or 64, but choosing
2393 -- 32 as the default improves compatibility with legacy VMS code.
2395 -- Note: we do not use Has_Size_Clause in the test below, because we
2396 -- want to catch the case of a derived type inheriting a size clause.
2397 -- We want to consider this to be an explicit size clause for this
2398 -- purpose, since it would be weird not to inherit the size in this
2399 -- case.
2401 if OpenVMS_On_Target
2403 or else
2407 then
2413 -- Scalar types: set size and alignment
2417 -- For discrete types, the RM_Size and Esize must be set
2418 -- already, since this is part of the earlier processing
2419 -- and the front end is always required to lay out the
2420 -- sizes of such types (since they are available as static
2421 -- attributes). All we do is to check that this rule is
2422 -- indeed obeyed!
2426 -- If the RM_Size is not set, then here is where we set it
2428 -- Note: an RM_Size of zero looks like not set here, but this
2429 -- is a rare case, and we can simply reset it without any harm.
2435 -- If Esize for a discrete type is not set then set it
2438 declare
2441 begin
2442 loop
2443 -- If size is big enough, set it and exit
2449 -- If the RM_Size is greater than 64 (happens only
2450 -- when strange values are specified by the user,
2451 -- then Esize is simply a copy of RM_Size, it will
2452 -- be further refined later on)
2458 -- Otherwise double possible size and keep trying
2460 else
2467 -- For non-discrete sclar types, if the RM_Size is not set,
2468 -- then set it now to a copy of the Esize if the Esize is set.
2470 else
2478 -- Non-elementary (composite) types
2480 else
2481 -- If RM_Size is known, set Esize if not known
2485 -- If the alignment is known, we bump the Esize up to the
2486 -- next alignment boundary if it is not already on one.
2489 declare
2493 begin
2498 -- If Esize is set, and RM_Size is not, RM_Size is copied from
2499 -- Esize at least for now this seems reasonable, and is in any
2500 -- case needed for compatibility with old versions of gigi.
2501 -- look to be unknown.
2507 -- For array base types, set component size if object size of
2508 -- the component type is known and is a small power of 2 (8,
2509 -- 16, 32, 64), since this is what will always be used.
2513 then
2514 declare
2517 begin
2518 -- For some reasons, access types can cause trouble,
2519 -- So let's just do this for discrete types ???
2524 then
2525 declare
2528 begin
2533 then
2542 -- Lay out array and record types if front end layout set
2551 -- Case of backend layout, we still do a little in the front end
2553 else
2554 -- Processing for record types
2558 -- Special remaining processing for record types with a known
2559 -- size of 16, 32, or 64 bits whose alignment is not yet set.
2560 -- For these types, we set a corresponding alignment matching
2561 -- the size if possible, or as large as possible if not.
2564 and then not Debug_Flag_Q
2565 then
2569 -- Procressing for array types
2573 -- For arrays that are required to be atomic, we do the same
2574 -- processing as described above for short records, since we
2575 -- really need to have the alignment set for the whole array.
2581 -- For unpacked array types, set an alignment of 1 if we know
2582 -- that the component alignment is not greater than 1. The reason
2583 -- we do this is to avoid unnecessary copying of slices of such
2584 -- arrays when passed to subprogram parameters (see special test
2585 -- in Exp_Ch6.Expand_Actuals).
2589 then
2592 then
2599 -- Final step is to check that Esize and RM_Size are compatible
2604 -- Esize is less than RM_Size. That's not good. First we test
2605 -- whether this was set deliberately with an Object_Size clause
2606 -- and if so, object to the clause.
2610 Error_Msg_F
2612 Expression (Get_Attribute_Definition_Clause
2616 -- Adjust Esize up to RM_Size value
2618 declare
2621 begin
2624 -- For scalar types, increase Object_Size to power of 2,
2625 -- but not less than a storage unit in any case (i.e.,
2626 -- normally this means it will be storage-unit addressable).
2635 else
2639 -- Finally, make sure that alignment is consistent with
2640 -- the newly assigned size.
2644 loop
2653 ---------------------
2654 -- Rewrite_Integer --
2655 ---------------------
2661 begin
2666 -------------------------------
2667 -- Set_And_Check_Static_Size --
2668 -------------------------------
2670 procedure Set_And_Check_Static_Size
2674 is
2678 -- Spec is the number of bit specified in the size clause, and
2679 -- Min is the minimum computed size. An error is given that the
2680 -- specified size is too small if Spec < Min, and in this case
2681 -- both Esize and RM_Size are set to unknown in E. The error
2682 -- message is posted on node SC.
2685 -- Spec is the number of bits specified in the size clause, and
2686 -- Max is the maximum computed size. A warning is given about
2687 -- unused bits if Spec > Max. This warning is posted on node SC.
2689 --------------------------
2690 -- Check_Size_Too_Small --
2691 --------------------------
2694 begin
2697 Error_Msg_NE
2704 -----------------------
2705 -- Check_Unused_Bits --
2706 -----------------------
2709 begin
2716 -- Start of processing for Set_And_Check_Static_Size
2718 begin
2719 -- Case where Object_Size (Esize) is already set by a size clause
2728 -- Perform checks on specified size against computed sizes
2736 -- Case where Value_Size (RM_Size) is set by specific Value_Size
2737 -- clause (we do not need to worry about Value_Size being set by
2738 -- a Size clause, since that will have set Esize as well, and we
2739 -- already took care of that case).
2744 -- Perform checks on specified size against computed sizes
2752 -- Set sizes if unknown
2763 -----------------------------
2764 -- Set_Composite_Alignment --
2765 -----------------------------
2771 begin
2778 then
2781 else
2785 -- Size is known, alignment is not set
2787 -- Reset alignment to match size if size is exactly 2, 4, or 8
2788 -- storage units.
2797 -- On VMS, also reset for odd "in between" sizes, e.g. a 17-bit
2798 -- record is given an alignment of 4. This is more consistent with
2799 -- what DEC Ada does.
2809 else
2813 -- No special alignment fiddling needed
2815 else
2819 -- Here Align is set to the proposed improved alignment
2825 -- Further processing for record types only to reduce the alignment
2826 -- set by the above processing in some specific cases. We do not
2827 -- do this for atomic records, since we need max alignment there.
2831 -- For records, there is generally no point in setting alignment
2832 -- higher than word size since we cannot do better than move by
2833 -- words in any case
2839 -- Check components. If any component requires a higher
2840 -- alignment, then we set that higher alignment in any case.
2842 declare
2845 begin
2849 declare
2852 begin
2853 -- The cases to worry about are when the alignment
2854 -- of the component type is larger than the alignment
2855 -- we have so far, and either there is no component
2856 -- clause for the alignment, or the length set by
2857 -- the component clause matches the alignment set.
2860 and then
2863 and then
2866 then
2877 -- Set chosen alignment
2883 then
2889 --------------------------
2890 -- Set_Discrete_RM_Size --
2891 --------------------------
2896 begin
2897 -- All discrete types except for the base types in standard
2898 -- are constrained, so indicate this by setting Is_Constrained.
2902 -- We set generic types to have an unknown size, since the
2903 -- representation of a generic type is irrelevant, in view
2904 -- of the fact that they have nothing to do with code.
2909 -- If the subtype statically matches the first subtype, then
2910 -- it is required to have exactly the same layout. This is
2911 -- required by aliasing considerations.
2915 then
2919 -- In all other cases the RM_Size is set to the minimum size.
2920 -- Note that this routine is never called for subtypes for which
2921 -- the RM_Size is set explicitly by an attribute clause.
2923 else
2928 ------------------------
2929 -- Set_Elem_Alignment --
2930 ------------------------
2933 begin
2934 -- Do not set alignment for packed array types, unless we are doing
2935 -- front end layout, because otherwise this is always handled in the
2936 -- backend.
2941 -- If there is an alignment clause, then we respect it
2946 -- If the size is not set, then don't attempt to set the alignment. This
2947 -- happens in the backend layout case for access-to-subprogram types.
2952 -- For access types, do not set the alignment if the size is less than
2953 -- the allowed minimum size. This avoids cascaded error messages.
2957 then
2961 -- Here we calculate the alignment as the largest power of two
2962 -- multiple of System.Storage_Unit that does not exceed either
2963 -- the actual size of the type, or the maximum allowed alignment.
2965 declare
2970 begin
2974 loop
2978 -- Now we think we should set the alignment to A, but we
2979 -- skip this if an alignment is already set to a value
2980 -- greater than A (happens for derived types).
2982 -- However, if the alignment is known and too small it
2983 -- must be increased, this happens in a case like:
2985 -- type R is new Character;
2986 -- for R'Size use 16;
2988 -- Here the alignment inherited from Character is 1, but
2989 -- it must be increased to 2 to reflect the increased size.
2997 ----------------------
2998 -- SO_Ref_From_Expr --
2999 ----------------------
3001 function SO_Ref_From_Expr
3006 is
3018 -- Function used to check one node for reference to V
3021 -- Function used to traverse tree to check for reference to V
3023 ----------------------
3024 -- Check_Node_V_Ref --
3025 ----------------------
3028 begin
3032 else
3036 else
3041 -- Start of processing for SO_Ref_From_Expr
3043 begin
3044 -- Case of expression is an integer literal, in this case we just
3045 -- return the value (which must always be non-negative, since size
3046 -- and offset values can never be negative).
3053 -- Case where there is a reference to V, create function
3059 -- Check whether Vtype is a view of a private type and ensure that
3060 -- we use the primary view of the type (which is denoted by its
3061 -- Etype, whether it's the type's partial or full view entity).
3062 -- This is needed to make sure that we use the same (primary) view
3063 -- of the type for all V formals, whether the current view of the
3064 -- type is the partial or full view, so that types will always
3065 -- match on calls from one size function to another.
3069 else
3075 Decl :=
3078 Specification =>
3083 Defining_Identifier =>
3085 Parameter_Type =>
3087 Result_Definition =>
3092 Handled_Statement_Sequence =>
3098 -- The caller requests that the expression be encapsulated in
3099 -- a parameterless function.
3102 Decl :=
3105 Specification =>
3109 Result_Definition =>
3114 Handled_Statement_Sequence =>
3119 -- No reference to V and function not requested, so create a constant
3121 else
3122 Decl :=
3125 Object_Definition =>