| blob | 829d75c2eb923d233b1b578ee19b4df0e40cf0ae |
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-2013, Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
20 -- --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
23 -- --
24 ------------------------------------------------------------------------------
54 ------------------------
55 -- Local Declarations --
56 ------------------------
59 -- Short hand for System_Storage_Unit
62 -- Formal parameter name used for functions generated for size offset
63 -- values that depend on the discriminant. All such functions have the
64 -- following form:
65 --
66 -- function xxx (V : vtyp) return Unsigned is
67 -- begin
68 -- return ... expression involving V.discrim
69 -- end xxx;
71 -----------------------
72 -- Local Subprograms --
73 -----------------------
75 function Assoc_Add
79 -- This is like Make_Op_Add except that it optimizes some cases knowing
80 -- that associative rearrangement is allowed for constant folding if one
81 -- of the operands is a compile time known value.
83 function Assoc_Multiply
87 -- This is like Make_Op_Multiply except that it optimizes some cases
88 -- knowing that associative rearrangement is allowed for constant folding
89 -- if one of the operands is a compile time known value
91 function Assoc_Subtract
95 -- This is like Make_Op_Subtract except that it optimizes some cases
96 -- knowing that associative rearrangement is allowed for constant folding
97 -- if one of the operands is a compile time known value
100 -- This is used when we cross the boundary from static sizes in bits to
101 -- dynamic sizes in storage units. If the argument N is anything other
102 -- than an integer literal, it is returned unchanged, but if it is an
103 -- integer literal, then it is taken as a size in bits, and is replaced
104 -- by the corresponding size in storage units.
107 -- Given expressions for the low bound (Lo) and the high bound (Hi),
108 -- Build an expression for the value hi-lo+1, converted to type
109 -- Standard.Unsigned. Takes care of the case where the operands
110 -- are of an enumeration type (so that the subtraction cannot be
111 -- done directly) by applying the Pos operator to Hi/Lo first.
114 -- Given an array type or an array subtype E, compute whether its size
115 -- depends on the value of one or more discriminants and set the flag
116 -- Size_Depends_On_Discriminant accordingly. This need not be called
117 -- in front end layout mode since it does the computation on its own.
119 function Expr_From_SO_Ref
123 -- Given a value D from a size or offset field, return an expression
124 -- representing the value stored. If the value is known at compile time,
125 -- then an N_Integer_Literal is returned with the appropriate value. If
126 -- the value references a constant entity, then an N_Identifier node
127 -- referencing this entity is returned. If the value denotes a size
128 -- function, then returns a call node denoting the given function, with
129 -- a single actual parameter that either refers to the parameter V of
130 -- an enclosing size function (if Comp is Empty or its type doesn't match
131 -- the function's formal), or else is a selected component V.c when Comp
132 -- denotes a component c whose type matches that of the function formal.
133 -- The Loc value is used for the Sloc value of constructed notes.
135 function SO_Ref_From_Expr
140 -- This routine is used in the case where a size/offset value is dynamic
141 -- and is represented by the expression Expr. SO_Ref_From_Expr checks if
142 -- the Expr contains a reference to the identifier V, and if so builds
143 -- a function depending on discriminants of the formal parameter V which
144 -- is of type Vtype. Otherwise, if the parameter Make_Func is True, then
145 -- Expr will be encapsulated in a parameterless function; if Make_Func is
146 -- False, then a constant entity with the value Expr is built. The result
147 -- is a Dynamic_SO_Ref to the created entity. Note that Vtype can be
148 -- omitted if Expr does not contain any reference to V, the created entity.
149 -- The declaration created is inserted in the freeze actions of Ins_Type,
150 -- which also supplies the Sloc for created nodes. This function also takes
151 -- care of making sure that the expression is properly analyzed and
152 -- resolved (which may not be the case yet if we build the expression
153 -- in this unit).
156 -- E is an array type or subtype that has at least one index bound that
157 -- is the value of a record discriminant. For such an array, the function
158 -- computes an expression that yields the maximum possible size of the
159 -- array in storage units. The result is not defined for any other type,
160 -- or for arrays that do not depend on discriminants, and it is a fatal
161 -- error to call this unless Size_Depends_On_Discriminant (E) is True.
164 -- Front-end layout of non-bit-packed array type or subtype
167 -- Front-end layout of record type
170 -- Rewrite node N with an integer literal whose value is V. The Sloc for
171 -- the new node is taken from N, and the type of the literal is set to a
172 -- copy of the type of N on entry.
174 procedure Set_And_Check_Static_Size
178 -- This procedure is called to check explicit given sizes (possibly stored
179 -- in the Esize and RM_Size fields of E) against computed Object_Size
180 -- (Esiz) and Value_Size (RM_Siz) values. Appropriate errors and warnings
181 -- are posted if specified sizes are inconsistent with specified sizes. On
182 -- return, Esize and RM_Size fields of E are set (either from previously
183 -- given values, or from the newly computed values, as appropriate).
186 -- This procedure is called for record types and subtypes, and also for
187 -- atomic array types and subtypes. If no alignment is set, and the size
188 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
189 -- match the size.
191 ----------------------------
192 -- Adjust_Esize_Alignment --
193 ----------------------------
199 begin
200 -- Nothing to do if size unknown
206 -- Determine if size is constrained by an attribute definition clause
207 -- which must be obeyed. If so, we cannot increase the size in this
208 -- routine.
210 -- For a type, the issue is whether an object size clause has been set.
211 -- A normal size clause constrains only the value size (RM_Size)
216 -- For an object, the issue is whether a size clause is present
218 else
222 -- If size is known it must be a multiple of the storage unit size
226 -- If not, and size specified, then give error
229 Error_Msg_NE
234 -- Otherwise bump up size to a storage unit boundary
236 else
241 -- Now we have the size set, it must be a multiple of the alignment
242 -- nothing more we can do here if the alignment is unknown here.
248 -- At this point both the Esize and Alignment are known, so we need
249 -- to make sure they are consistent.
257 -- Here we have a situation where the Esize is not a multiple of the
258 -- alignment. We must either increase Esize or reduce the alignment to
259 -- correct this situation.
261 -- The case in which we can decrease the alignment is where the
262 -- alignment was not set by an alignment clause, and the type in
263 -- question is a discrete type, where it is definitely safe to reduce
264 -- the alignment. For example:
266 -- t : integer range 1 .. 2;
267 -- for t'size use 8;
269 -- In this situation, the initial alignment of t is 4, copied from
270 -- the Integer base type, but it is safe to reduce it to 1 at this
271 -- stage, since we will only be loading a single storage unit.
275 then
276 loop
285 -- Now the only possible approach left is to increase the Esize but we
286 -- can't do that if the size was set by a specific clause.
289 Error_Msg_NE
293 -- Otherwise we can indeed increase the size to a multiple of alignment
295 else
300 ---------------
301 -- Assoc_Add --
302 ---------------
304 function Assoc_Add
308 is
312 begin
313 -- Case of right operand is a constant
319 -- Case of left operand is a constant
325 -- Neither operand is a constant, do the addition with no optimization
327 else
331 -- Case of left operand is an addition
335 -- (C1 + E) + C2 = (C1 + C2) + E
338 Rewrite_Integer
343 -- (E + C1) + C2 = E + (C1 + C2)
346 Rewrite_Integer
352 -- Case of left operand is a subtraction
356 -- (C1 - E) + C2 = (C1 + C2) + E
359 Rewrite_Integer
364 -- (E - C1) + C2 = E - (C1 - C2)
367 Rewrite_Integer
374 -- Not optimizable, do the addition
379 --------------------
380 -- Assoc_Multiply --
381 --------------------
383 function Assoc_Multiply
387 is
391 begin
392 -- Case of right operand is a constant
398 -- Case of left operand is a constant
404 -- Neither operand is a constant, do the multiply with no optimization
406 else
410 -- Case of left operand is an multiplication
414 -- (C1 * E) * C2 = (C1 * C2) + E
417 Rewrite_Integer
422 -- (E * C1) * C2 = E * (C1 * C2)
425 Rewrite_Integer
432 -- Not optimizable, do the multiplication
437 --------------------
438 -- Assoc_Subtract --
439 --------------------
441 function Assoc_Subtract
445 is
449 begin
450 -- Case of right operand is a constant
456 -- Right operand is a constant, do the subtract with no optimization
458 else
462 -- Case of left operand is an addition
466 -- (C1 + E) - C2 = (C1 - C2) + E
469 Rewrite_Integer
474 -- (E + C1) - C2 = E + (C1 - C2)
477 Rewrite_Integer
483 -- Case of left operand is a subtraction
487 -- (C1 - E) - C2 = (C1 - C2) + E
490 Rewrite_Integer
495 -- (E - C1) - C2 = E - (C1 + C2)
498 Rewrite_Integer
505 -- Not optimizable, do the subtraction
510 ----------------
511 -- Bits_To_SU --
512 ----------------
515 begin
523 --------------------
524 -- Compute_Length --
525 --------------------
535 begin
536 -- If the bounds are First and Last attributes for the same dimension
537 -- and both have prefixes that denotes the same entity, then we create
538 -- and return a Length attribute. This may allow the back end to
539 -- generate better code in cases where it already has the length.
548 then
561 return
563 Prefix => New_Occurrence_Of
566 Expressions => New_List
574 -- If type is enumeration type, then use Pos attribute to convert
575 -- to integer type for which subtraction is a permitted operation.
578 Lo_Op :=
584 Hi_Op :=
591 return
593 Left_Opnd =>
600 ----------------------
601 -- Expr_From_SO_Ref --
602 ----------------------
604 function Expr_From_SO_Ref
608 is
611 begin
617 -- If a component is passed in whose type matches the type of
618 -- the function formal, then select that component from the "V"
619 -- parameter rather than passing "V" directly.
624 then
625 return
633 else
634 return
641 else
645 else
650 ---------------------
651 -- Get_Max_SU_Size --
652 ---------------------
666 record
672 -- Shows the status of the value so far. Const means that the value is
673 -- constant, and Val is the current constant value. Dynamic means that
674 -- the value is dynamic, and in this case Nod is the Node_Id of the
675 -- expression to compute the value.
678 -- Calculated value so far if Size.Status = Const,
679 -- or expression value so far if Size.Status = Dynamic.
682 -- This is set to True if the final result must be converted from bits
683 -- to storage units (rounding up to a storage unit boundary).
685 -----------------------
686 -- Local Subprograms --
687 -----------------------
690 -- If the node N represents a discriminant, replace it by the maximum
691 -- value of the discriminant.
694 -- If the node N represents a discriminant, replace it by the minimum
695 -- value of the discriminant.
697 -----------------
698 -- Max_Discrim --
699 -----------------
702 begin
705 then
710 -----------------
711 -- Min_Discrim --
712 -----------------
715 begin
718 then
723 -- Start of processing for Get_Max_SU_Size
725 begin
728 -- Initialize status from component size
733 else
737 -- Loop through indexes
748 -- Value of the current subscript range is statically known
752 then
755 -- If known flat bound, entire size of array is zero
761 -- Current value is constant, evolve value
766 -- Current value is dynamic
768 else
769 -- An interesting little optimization, if we have a pending
770 -- conversion from bits to storage units, and the current
771 -- length is a multiple of the storage unit size, then we
772 -- can take the factor out here statically, avoiding some
773 -- extra dynamic computations at the end.
783 Right_Opnd =>
787 -- Value of the current subscript range is dynamic
789 else
790 -- If the current size value is constant, then here is where we
791 -- make a transition to dynamic values, which are always stored
792 -- in storage units, However, we do not want to convert to SU's
793 -- too soon, consider the case of a packed array of single bits,
794 -- we want to do the SU conversion after computing the size in
795 -- this case.
799 -- If the current value is a multiple of the storage unit,
800 -- then most certainly we can do the conversion now, simply
801 -- by dividing the current value by the storage unit value.
802 -- If this works, we set SU_Convert_Required to False.
806 Size :=
810 -- Otherwise, we go ahead and convert the value in bits, and
811 -- set SU_Convert_Required to True to ensure that the final
812 -- value is indeed properly converted.
814 else
820 -- Length is hi-lo+1
824 -- Check possible range of Len
826 declare
832 begin
838 -- If we cannot verify that range cannot be super-flat, we need
839 -- a max with zero, since length must be non-negative.
842 Len :=
844 Prefix =>
849 Len));
857 -- Here after processing all bounds to set sizes. If the value is a
858 -- constant, then it is bits, so we convert to storage units.
863 -- Case where the value is dynamic
865 else
866 -- Do convert from bits to SU's if needed
870 -- The expression required is (Size.Nod + SU - 1) / SU
874 Left_Opnd =>
885 -----------------------
886 -- Layout_Array_Type --
887 -----------------------
900 -- This is the type with which any generated constants or functions
901 -- will be associated (i.e. inserted into the freeze actions). This
902 -- is normally the type being laid out. The exception occurs when
903 -- we are laying out Itype's which are local to a record type, and
904 -- whose scope is this record type. Such types do not have freeze
905 -- nodes (because we have no place to put them).
907 ------------------------------------
908 -- How An Array Type is Laid Out --
909 ------------------------------------
911 -- Here is what goes on. We need to multiply the component size of the
912 -- array (which has already been set) by the length of each of the
913 -- indexes. If all these values are known at compile time, then the
914 -- resulting size of the array is the appropriate constant value.
916 -- If the component size or at least one bound is dynamic (but no
917 -- discriminants are present), then the size will be computed as an
918 -- expression that calculates the proper size.
920 -- If there is at least one discriminant bound, then the size is also
921 -- computed as an expression, but this expression contains discriminant
922 -- values which are obtained by selecting from a function parameter, and
923 -- the size is given by a function that is passed the variant record in
924 -- question, and whose body is the expression.
929 record
933 -- Calculated value so far if Val_Status = Const
937 -- Expression value so far if Val_Status /= Const
941 -- Records the value or expression computed so far. Const means that
942 -- the value is constant, and Val is the current constant value.
943 -- Dynamic means that the value is dynamic, and in this case Nod is
944 -- the Node_Id of the expression to compute the value, and Discrim
945 -- means that at least one bound is a discriminant, in which case Nod
946 -- is the expression so far (which will be the body of the function).
949 -- Value of size computed so far. See comments above
952 -- Variant record type for the formal parameter of the discriminant
953 -- function V if Status = Discrim.
956 -- This is set to True if the final result must be converted from
957 -- bits to storage units (rounding up to a storage unit boundary).
960 -- This is the amount that a nonstatic computed size will be divided
961 -- by to convert it from bits to storage units. This is normally
962 -- equal to SSU, but can be reduced in the case of packed components
963 -- that fit evenly into a storage unit.
966 -- Indicates whether to request that SO_Ref_From_Expr should
967 -- encapsulate the array size expression in a function.
970 -- If N represents a discriminant, then the Size.Status is set to
971 -- Discrim, and Vtyp is set. The parameter N is replaced with the
972 -- proper expression to extract the discriminant value from V.
974 ----------------
975 -- Discrimify --
976 ----------------
982 begin
985 then
996 N :=
1001 -- Set the Etype attributes of the selected name and its prefix.
1002 -- Analyze_And_Resolve can't be called here because the Vname
1003 -- entity denoted by the prefix will not yet exist (it's created
1004 -- by SO_Ref_From_Expr, called at the end of Layout_Array_Type).
1011 -- Start of processing for Layout_Array_Type
1013 begin
1014 -- Default alignment is component alignment
1020 -- Calculate proper type for insertions
1024 else
1028 -- If the component type is a generic formal type then there's no point
1029 -- in determining a size for the array type.
1035 -- Deal with component size if base type
1039 -- Cannot do anything if Esize of component type unknown
1045 -- Set component size if not set already
1052 -- (RM 13.3 (48)) says that the size of an unconstrained array
1053 -- is implementation defined. We choose to leave it as Unknown
1054 -- here, and the actual behavior is determined by the back end.
1060 -- Initialize status from component size
1065 else
1069 -- Loop to process array indexes
1075 -- If an index of the array is a generic formal type then there is
1076 -- no point in determining a size for the array type.
1085 -- Value of the current subscript range is statically known
1089 then
1092 -- If known flat bound, entire size of array is zero
1100 -- If constant, evolve value
1105 -- Current value is dynamic
1107 else
1108 -- An interesting little optimization, if we have a pending
1109 -- conversion from bits to storage units, and the current
1110 -- length is a multiple of the storage unit size, then we
1111 -- can take the factor out here statically, avoiding some
1112 -- extra dynamic computations at the end.
1119 -- Now go ahead and evolve the expression
1124 Right_Opnd =>
1128 -- Value of the current subscript range is dynamic
1130 else
1131 -- If the current size value is constant, then here is where we
1132 -- make a transition to dynamic values, which are always stored
1133 -- in storage units, However, we do not want to convert to SU's
1134 -- too soon, consider the case of a packed array of single bits,
1135 -- we want to do the SU conversion after computing the size in
1136 -- this case.
1140 -- If the current value is a multiple of the storage unit,
1141 -- then most certainly we can do the conversion now, simply
1142 -- by dividing the current value by the storage unit value.
1143 -- If this works, we set SU_Convert_Required to False.
1146 Size :=
1150 -- If the current value is a factor of the storage unit, then
1151 -- we can use a value of one for the size and reduce the
1152 -- strength of the later division.
1159 -- Otherwise, we go ahead and convert the value in bits, and
1160 -- set SU_Convert_Required to True to ensure that the final
1161 -- value is indeed properly converted.
1163 else
1172 -- Length is hi-lo+1
1176 -- If Len isn't a Length attribute, then its range needs to be
1177 -- checked a possible Max with zero needs to be computed.
1181 then
1182 declare
1187 begin
1188 -- Check possible range of Len
1195 -- If range definitely flat or superflat,
1196 -- result size is zero
1204 -- If we cannot verify that range cannot be super-flat, we
1205 -- need a max with zero, since length cannot be negative.
1208 Len :=
1210 Prefix =>
1215 Len));
1220 -- At this stage, Len has the expression for the length
1231 -- Here after processing all bounds to set sizes. If the value is a
1232 -- constant, then it is bits, and the only thing we need to do is to
1233 -- check against explicit given size and do alignment adjust.
1239 -- Case where the value is dynamic
1241 else
1242 -- Do convert from bits to SU's if needed
1246 -- The expression required is:
1247 -- (Size.Nod + Storage_Divisor - 1) / Storage_Divisor
1251 Left_Opnd =>
1254 Right_Opnd => Make_Integer_Literal
1259 -- If the array entity is not declared at the library level and its
1260 -- not nested within a subprogram that is marked for inlining, then
1261 -- we request that the size expression be encapsulated in a function.
1262 -- Since this expression is not needed in most cases, we prefer not
1263 -- to incur the overhead of the computation on calls to the enclosing
1264 -- subprogram except for subprograms that require the size.
1269 declare
1272 begin
1284 -- Now set the dynamic size (the Value_Size is always the same as the
1285 -- Object_Size for arrays whose length is dynamic).
1287 -- ??? If Size.Status = Dynamic, Vtyp will not have been set.
1288 -- The added initialization sets it to Empty now, but is this
1289 -- correct?
1291 Set_Esize
1293 SO_Ref_From_Expr
1299 ------------------------------------------
1300 -- Compute_Size_Depends_On_Discriminant --
1301 ------------------------------------------
1310 begin
1311 -- Loop to process array indexes
1317 -- If an index of the array is a generic formal type then there is
1318 -- no point in determining a size for the array type.
1329 or else
1332 then
1344 -------------------
1345 -- Layout_Object --
1346 -------------------
1351 begin
1352 -- Nothing to do if backend does layout
1358 -- Set size if not set for object and known for type. Use the RM_Size if
1359 -- that is known for the type and Esize is not.
1370 -- Set alignment from type if unknown and type alignment known
1376 -- Make sure size and alignment are consistent
1380 -- Final adjustment, if we don't know the alignment, and the Esize was
1381 -- not set by an explicit Object_Size attribute clause, then we reset
1382 -- the Esize to unknown, since we really don't know it.
1386 then
1391 ------------------------
1392 -- Layout_Record_Type --
1393 ------------------------
1400 -- Current component being laid out
1403 -- Previous laid out component
1405 procedure Get_Next_Component_Location
1412 -- Given the previous component in Prev_Comp, which is already laid
1413 -- out, and the alignment of the following component, lays out the
1414 -- following component, and returns its starting position in New_Npos
1415 -- (Normalized_Position value), New_Fbit (Normalized_First_Bit value),
1416 -- and New_NPMax (Normalized_Position_Max value). If Prev_Comp is empty
1417 -- (no previous component is present), then New_Npos, New_Fbit and
1418 -- New_NPMax are all set to zero on return. This procedure is also
1419 -- used to compute the size of a record or variant by giving it the
1420 -- last component, and the record alignment. Force_SU is used to force
1421 -- the new component location to be aligned on a storage unit boundary,
1422 -- even in a packed record, False means that the new position does not
1423 -- need to be bumped to a storage unit boundary, True means a storage
1424 -- unit boundary is always required.
1427 -- Lays out component Comp, given Prev_Comp, the previously laid-out
1428 -- component (Prev_Comp = Empty if no components laid out yet). The
1429 -- alignment of the record itself is also updated if needed. Both
1430 -- Comp and Prev_Comp can be either components or discriminants.
1432 procedure Layout_Components
1437 -- This procedure lays out the components of the given component list
1438 -- which contains the components starting with From and ending with To.
1439 -- The Next_Entity chain is used to traverse the components. On entry,
1440 -- Prev_Comp is set to the component preceding the list, so that the
1441 -- list is laid out after this component. Prev_Comp is set to Empty if
1442 -- the component list is to be laid out starting at the start of the
1443 -- record. On return, the components are all laid out, and Prev_Comp is
1444 -- set to the last laid out component. On return, Esiz is set to the
1445 -- resulting Object_Size value, which is the length of the record up
1446 -- to and including the last laid out entity. For Esiz, the value is
1447 -- adjusted to match the alignment of the record. RM_Siz is similarly
1448 -- set to the resulting Value_Size value, which is the same length, but
1449 -- not adjusted to meet the alignment. Note that in the case of variant
1450 -- records, Esiz represents the maximum size.
1453 -- Procedure called to lay out a non-variant record type or subtype
1456 -- Procedure called to lay out a variant record type. Decl is set to the
1457 -- full type declaration for the variant record.
1459 ---------------------------------
1460 -- Get_Next_Component_Location --
1461 ---------------------------------
1463 procedure Get_Next_Component_Location
1470 is
1471 begin
1472 -- No previous component, return zero position
1481 -- Here we have a previous component
1483 declare
1492 -- Expression representing maximum size of previous component
1494 begin
1495 -- Case where previous field had a dynamic size
1499 -- If the previous field had a dynamic length, then it is
1500 -- required to occupy an integral number of storage units,
1501 -- and start on a storage unit boundary. This means that
1502 -- the Normalized_First_Bit value is zero in the previous
1503 -- component, and the new value is also set to zero.
1507 -- In this case, the new position is given by an expression
1508 -- that is the sum of old normalized position and old size.
1510 New_Npos :=
1511 SO_Ref_From_Expr
1513 Left_Opnd =>
1515 Right_Opnd =>
1520 -- Get maximum size of previous component
1524 else
1528 -- Now we can compute the new max position. If the max size
1529 -- is static and the old position is static, then we can
1530 -- compute the new position statically.
1534 then
1537 -- Otherwise new max position is dynamic
1539 else
1540 New_NPMax :=
1541 SO_Ref_From_Expr
1549 -- Previous field has known static Esize
1551 else
1554 -- Bump New_Fbit to storage unit boundary if required
1560 -- If old normalized position is static, we can go ahead and
1561 -- compute the new normalized position directly.
1571 -- Bump alignment if stricter than prev
1577 -- The max position is always equal to the position if
1578 -- the latter is static, since arrays depending on the
1579 -- values of discriminants never have static sizes.
1584 -- Case of old normalized position is dynamic
1586 else
1587 -- If new bit position is within the current storage unit,
1588 -- we can just copy the old position as the result position
1589 -- (we have already set the new first bit value).
1595 -- If new bit position is past the current storage unit, we
1596 -- need to generate a new dynamic value for the position
1597 -- ??? need to deal with alignment
1599 else
1600 New_Npos :=
1601 SO_Ref_From_Expr
1604 Right_Opnd =>
1610 New_NPMax :=
1611 SO_Ref_From_Expr
1614 Right_Opnd =>
1626 ----------------------
1627 -- Layout_Component --
1628 ----------------------
1638 begin
1639 -- Increase alignment of record if necessary. Note that we do not
1640 -- do this for packed records, which have an alignment of one by
1641 -- default, or for records for which an explicit alignment was
1642 -- specified with an alignment clause.
1647 then
1651 -- If original component set, then use same layout
1662 -- Parent field is always at start of record, this will overlap
1663 -- the actual fields that are part of the parent, and that's fine
1674 -- Check case of type of component has a scope of the record we are
1675 -- laying out. When this happens, the type in question is an Itype
1676 -- that has not yet been laid out (that's because such types do not
1677 -- get frozen in the normal manner, because there is no place for
1678 -- the freeze nodes).
1684 -- If component already laid out, then we are done
1690 -- Set size of component from type. We use the Esize except in a
1691 -- packed record, where we use the RM_Size (since that is what the
1692 -- RM_Size value, as distinct from the Object_Size is useful for).
1696 else
1700 -- Compute the component position from the previous one. See if
1701 -- current component requires being on a storage unit boundary.
1703 -- If record is not packed, we always go to a storage unit boundary
1708 -- Packed cases
1710 else
1711 -- Elementary types do not need SU boundary in packed record
1716 -- Packed array types with a modular packed array type do not
1717 -- force a storage unit boundary (since the code generation
1718 -- treats these as equivalent to the underlying modular type),
1723 then
1726 -- Record types with known length less than or equal to the length
1727 -- of long long integer can also be unaligned, since they can be
1728 -- treated as scalars.
1733 then
1736 -- All other cases force a storage unit boundary, even when packed
1738 else
1743 -- Now get the next component location
1745 Get_Next_Component_Location
1751 -- Set Component_Bit_Offset in the static case
1755 then
1760 -----------------------
1761 -- Layout_Components --
1762 -----------------------
1764 procedure Layout_Components
1769 is
1774 begin
1775 -- Only lay out components if there are some to lay out
1779 -- Lay out components with no component clauses
1782 loop
1785 then
1786 -- The compatibility of component clauses with composite
1787 -- types isn't checked in Sem_Ch13, so we check it here.
1792 then
1794 Error_Msg_NE
1797 Comp);
1800 else
1811 -- Set size fields, both are zero if no components
1817 -- If record subtype with non-static discriminants, then we don't
1818 -- know which variant will be the one which gets chosen. We don't
1819 -- just want to set the maximum size from the base, because the
1820 -- size should depend on the particular variant.
1822 -- What we do is to use the RM_Size of the base type, which has
1823 -- the necessary conditional computation of the size, using the
1824 -- size information for the particular variant chosen. Records
1825 -- with default discriminants for example have an Esize that is
1826 -- set to the maximum of all variants, but that's not what we
1827 -- want for a constrained subtype.
1831 then
1832 declare
1834 begin
1840 else
1841 -- First the object size, for which we align past the last field
1842 -- to the alignment of the record (the object size is required to
1843 -- be a multiple of the alignment).
1845 Get_Next_Component_Location
1848 End_Npos,
1849 End_Fbit,
1850 End_NPMax,
1853 -- If the resulting normalized position is a dynamic reference,
1854 -- then the size is dynamic, and is stored in storage units. In
1855 -- this case, we set the RM_Size to the same value, it is simply
1856 -- not worth distinguishing Esize and RM_Size values in the
1857 -- dynamic case, since the RM has nothing to say about them.
1859 -- Note that a size cannot have been given in this case, since
1860 -- size specifications cannot be given for variable length types.
1862 declare
1865 begin
1869 -- Set the Object_Size allowing for the alignment. In the
1870 -- dynamic case, we must do the actual runtime computation.
1871 -- We can skip this in the non-packed record case if the
1872 -- last component has a smaller alignment than the overall
1873 -- record alignment.
1880 then
1881 -- The expression we build is:
1882 -- (expr + align - 1) / align * align
1884 Esiz :=
1885 SO_Ref_From_Expr
1888 Left_Opnd =>
1890 Left_Opnd =>
1892 Left_Opnd =>
1894 Right_Opnd =>
1897 Right_Opnd =>
1899 Right_Opnd =>
1905 -- Here Esiz is static, so we can adjust the alignment
1906 -- directly go give the required aligned value.
1908 else
1912 -- Case where computed size is static
1914 else
1915 -- The ending size was computed in Npos in storage units,
1916 -- but the actual size is stored in bits, so adjust
1917 -- accordingly. We also adjust the size to match the
1918 -- alignment here.
1922 -- Compute the resulting Value_Size (RM_Size). For this
1923 -- purpose we do not force alignment of the record or
1924 -- storage size alignment of the result.
1926 Get_Next_Component_Location
1928 Uint_0,
1929 End_Npos,
1930 End_Fbit,
1931 End_NPMax,
1941 -------------------------------
1942 -- Layout_Non_Variant_Record --
1943 -------------------------------
1948 begin
1954 ---------------------------
1955 -- Layout_Variant_Record --
1956 ---------------------------
1968 -- Expression for the evolving RM_Siz value. This is typically an if
1969 -- expression which involves tests of discriminant values that are
1970 -- formed as references to the entity V. At the end of scanning all
1971 -- the components, a suitable function is constructed in which V is
1972 -- the parameter.
1974 -----------------------
1975 -- Local Subprograms --
1976 -----------------------
1978 procedure Layout_Component_List
1982 -- Recursive procedure, called to lay out one component list Esiz
1983 -- and RM_Siz_Expr are set to the Object_Size and Value_Size values
1984 -- respectively representing the record size up to and including the
1985 -- last component in the component list (including any variants in
1986 -- this component list). RM_Siz_Expr is returned as an expression
1987 -- which may in the general case involve some references to the
1988 -- discriminants of the current record value, referenced by selecting
1989 -- from the entity V.
1991 ---------------------------
1992 -- Layout_Component_List --
1993 ---------------------------
1995 procedure Layout_Component_List
1999 is
2007 begin
2009 Layout_Components
2014 else
2018 -- Case where no variants are present in the component list
2022 -- The Esiz value has been correctly set by the call to
2023 -- Layout_Components, so there is nothing more to be done.
2025 -- For RM_Siz, we have an SO_Ref value, which we must convert
2026 -- to an appropriate expression.
2029 RM_Siz_Expr :=
2033 else
2036 -- If the size is represented by a function, then we create
2037 -- an appropriate function call using V as the parameter to
2038 -- the call.
2041 RM_Siz_Expr :=
2047 -- If the size is represented by a constant, then the
2048 -- expression we want is a reference to this constant
2050 else
2055 -- Case where variants are present in this component list
2057 else
2058 declare
2067 begin
2074 Layout_Component_List
2077 -- Set the Object_Size. If this is the first variant,
2078 -- we just set the size of this first variant.
2083 -- Otherwise the Object_Size is formed as a maximum
2084 -- of Esiz so far from previous variants, and the new
2085 -- Esiz value from the variant we just processed.
2087 -- If both values are static, we can just compute the
2088 -- maximum directly to save building junk nodes.
2092 then
2095 -- If either value is dynamic, then we have to generate
2096 -- an appropriate Standard_Unsigned'Max attribute call.
2097 -- If one of the values is static then it needs to be
2098 -- converted from bits to storage units to be compatible
2099 -- with the dynamic value.
2101 else
2110 Esiz :=
2111 SO_Ref_From_Expr
2114 Prefix =>
2123 -- Now deal with Value_Size (RM_Siz). We are aiming at
2124 -- an expression that looks like:
2126 -- if xxDx (V.disc) then rmsiz1
2127 -- else if xxDx (V.disc) then rmsiz2
2128 -- else ...
2130 -- Where rmsiz1, rmsiz2... are the RM_Siz values for the
2131 -- individual variants, and xxDx are the discriminant
2132 -- checking functions generated for the variant type.
2134 -- If this is the first variant, we simply set the result
2135 -- as the expression. Note that this takes care of the
2136 -- others case.
2140 -- If this is the only variant and the size is a
2141 -- literal, then use bit size as is, otherwise convert
2142 -- to storage units and continue to the next variant.
2146 then
2148 else
2152 -- Otherwise construct the appropriate test
2154 else
2155 -- The test to be used in general is a call to the
2156 -- discriminant checking function. However, it is
2157 -- definitely worth special casing the very common
2158 -- case where a single value is involved.
2164 then
2165 -- Discriminant to be tested
2167 Discrim :=
2169 Prefix =>
2171 Selector_Name =>
2172 New_Occurrence_Of
2175 Dtest :=
2180 -- Generate a call to the discriminant-checking
2181 -- function for the variant. Note that the result
2182 -- has to be complemented since the function returns
2183 -- False when the passed discriminant value matches.
2185 else
2186 -- The checking function takes all of the type's
2187 -- discriminants as parameters, so a list of all
2188 -- the selected discriminants must be constructed.
2193 Append (
2195 Prefix =>
2197 Selector_Name =>
2199 D_List);
2204 Dtest :=
2206 Right_Opnd =>
2208 Name =>
2209 New_Occurrence_Of
2211 Parameter_Associations =>
2212 D_List));
2215 RM_Siz_Expr :=
2217 Expressions =>
2218 New_List
2230 -- Indicates others present, not used in this case
2233 -- Error routine invoked by the generic instantiation below when
2234 -- the variant part has a nonstatic choice.
2237 Generic_Check_Choices
2243 -----------------------------
2244 -- Non_Static_Choice_Error --
2245 -----------------------------
2248 begin
2249 Flag_Non_Static_Expr
2253 -- Start of processing for Layout_Variant_Record
2255 begin
2256 -- Call Check_Choices here to ensure that Others_Discrete_Choices
2257 -- gets set on any 'others' choice before the discriminant-checking
2258 -- functions are generated. Otherwise the function for the 'others'
2259 -- alternative will unconditionally return True, causing discriminant
2260 -- checks to fail. However, Check_Choices is now normally delayed
2261 -- until the type's freeze entity is processed, due to requirements
2262 -- coming from subtype predicates, so doing it at this point is
2263 -- probably not right in general, but it's not clear how else to deal
2264 -- with this situation. Perhaps we should only generate declarations
2265 -- for the checking functions here, and somehow delay generation of
2266 -- their bodies, but that would be a nontrivial change. ???
2268 declare
2271 begin
2272 Check_Choices
2276 -- We need the discriminant checking functions, since we generate
2277 -- calls to these functions for the RM_Size expression, so make
2278 -- sure that these functions have been constructed in time.
2282 -- Lay out the discriminants
2290 Layout_Components
2296 -- Lay out the main component list (this will make recursive calls
2297 -- to lay out all component lists nested within variants).
2302 -- If the RM_Size is a literal, set its value
2307 -- Otherwise we construct a dynamic SO_Ref
2309 else
2311 SO_Ref_From_Expr
2318 -- Start of processing for Layout_Record_Type
2320 begin
2321 -- If this is a cloned subtype, just copy the size fields from the
2322 -- original, nothing else needs to be done in this case, since the
2323 -- components themselves are all shared.
2327 then
2332 -- Another special case, class-wide types. The RM says that the size
2333 -- of such types is implementation defined (RM 13.3(48)). What we do
2334 -- here is to leave the fields set as unknown values, and the backend
2335 -- determines the actual behavior.
2340 -- All other cases
2342 else
2343 -- Initialize alignment conservatively to 1. This value will be
2344 -- increased as necessary during processing of the record.
2350 -- Initialize previous component. This is Empty unless there are
2351 -- components which have already been laid out by component clauses.
2352 -- If there are such components, we start our lay out of the
2353 -- remaining components following the last such component.
2361 or else
2364 then
2372 -- We have two separate circuits, one for non-variant records and
2373 -- one for variant records. For non-variant records, we simply go
2374 -- through the list of components. This handles all the non-variant
2375 -- cases including those cases of subtypes where there is no full
2376 -- type declaration, so the tree cannot be used to drive the layout.
2377 -- For variant records, we have to drive the layout from the tree
2378 -- since we need to understand the variant structure in this case.
2382 else
2386 -- Scan all the components
2392 and then
2394 then
2395 Layout_Variant_Record;
2396 else
2397 Layout_Non_Variant_Record;
2402 -----------------
2403 -- Layout_Type --
2404 -----------------
2409 begin
2410 -- For string literal types, for now, kill the size always, this is
2411 -- because gigi does not like or need the size to be set ???
2419 -- For access types, set size/alignment. This is system address size,
2420 -- except for fat pointers (unconstrained array access types), where the
2421 -- size is two times the address size, to accommodate the two pointers
2422 -- that are required for a fat pointer (data and template). Note that
2423 -- E_Access_Protected_Subprogram_Type is not an access type for this
2424 -- purpose since it is not a pointer but is equivalent to a record. For
2425 -- access subtypes, copy the size from the base type since Gigi
2426 -- represents them the same way.
2432 -- If we only have a limited view of the type, see whether the
2433 -- non-limited view is available.
2438 then
2442 -- If Esize already set (e.g. by a size clause), then nothing further
2443 -- to be done here.
2448 -- Access to subprogram is a strange beast, and we let the backend
2449 -- figure out what is needed (it may be some kind of fat pointer,
2450 -- including the static link for example.
2455 -- For access subtypes, copy the size information from base type
2461 -- For other access types, we use either address size, or, if a fat
2462 -- pointer is used (pointer-to-unconstrained array case), twice the
2463 -- address size to accommodate a fat pointer.
2469 and then not Debug_Flag_6
2470 then
2473 -- Check for bad convention set
2475 if Warn_On_Export_Import
2476 and then
2478 or else
2480 then
2481 Error_Msg_N
2485 -- If the designated type is a limited view it is unanalyzed. We can
2486 -- examine the declaration itself to determine whether it will need a
2487 -- fat pointer.
2492 and then
2494 = N_Unconstrained_Array_Definition
2495 and then not Debug_Flag_6
2496 then
2499 -- When the target is AAMP, access-to-subprogram types are fat
2500 -- pointers consisting of the subprogram address and a static link,
2501 -- with the exception of library-level access types (including
2502 -- library-level anonymous access types, such as for components),
2503 -- where a simple subprogram address is used.
2505 elsif AAMP_On_Target
2506 and then
2509 or else
2511 and then
2514 then
2516 else
2520 -- On VMS, reset size to 32 for convention C access type if no
2521 -- explicit size clause is given and the default size is 64. Really
2522 -- we do not know the size, since depending on options for the VMS
2523 -- compiler, the size of a pointer type can be 32 or 64, but choosing
2524 -- 32 as the default improves compatibility with legacy VMS code.
2526 -- Note: we do not use Has_Size_Clause in the test below, because we
2527 -- want to catch the case of a derived type inheriting a size clause.
2528 -- We want to consider this to be an explicit size clause for this
2529 -- purpose, since it would be weird not to inherit the size in this
2530 -- case.
2532 -- We do NOT do this if we are in -gnatdm mode on a non-VMS target
2533 -- since in that case we want the normal pointer representation.
2537 or else
2541 then
2547 -- Scalar types: set size and alignment
2551 -- For discrete types, the RM_Size and Esize must be set already,
2552 -- since this is part of the earlier processing and the front end is
2553 -- always required to lay out the sizes of such types (since they are
2554 -- available as static attributes). All we do is to check that this
2555 -- rule is indeed obeyed.
2559 -- If the RM_Size is not set, then here is where we set it
2561 -- Note: an RM_Size of zero looks like not set here, but this
2562 -- is a rare case, and we can simply reset it without any harm.
2568 -- If Esize for a discrete type is not set then set it
2571 declare
2574 begin
2575 loop
2576 -- If size is big enough, set it and exit
2582 -- If the RM_Size is greater than 64 (happens only when
2583 -- strange values are specified by the user, then Esize
2584 -- is simply a copy of RM_Size, it will be further
2585 -- refined later on)
2591 -- Otherwise double possible size and keep trying
2593 else
2600 -- For non-discrete scalar types, if the RM_Size is not set, then set
2601 -- it now to a copy of the Esize if the Esize is set.
2603 else
2611 -- Non-elementary (composite) types
2613 else
2614 -- For packed arrays, take size and alignment values from the packed
2615 -- array type if a packed array type has been created and the fields
2616 -- are not currently set.
2619 declare
2622 begin
2637 -- If Esize is set, and RM_Size is not, RM_Size is copied from Esize.
2638 -- At least for now this seems reasonable, and is in any case needed
2639 -- for compatibility with old versions of gigi.
2645 -- For array base types, set component size if object size of the
2646 -- component type is known and is a small power of 2 (8, 16, 32, 64),
2647 -- since this is what will always be used.
2651 then
2652 declare
2655 begin
2656 -- For some reasons, access types can cause trouble, So let's
2657 -- just do this for scalar types ???
2662 then
2663 declare
2665 begin
2675 -- Lay out array and record types if front end layout set
2684 -- Case of backend layout, we still do a little in the front end
2686 else
2687 -- Processing for record types
2691 -- Special remaining processing for record types with a known
2692 -- size of 16, 32, or 64 bits whose alignment is not yet set.
2693 -- For these types, we set a corresponding alignment matching
2694 -- the size if possible, or as large as possible if not.
2697 and then not Debug_Flag_Q
2698 then
2702 -- Processing for array types
2706 -- For arrays that are required to be atomic, we do the same
2707 -- processing as described above for short records, since we
2708 -- really need to have the alignment set for the whole array.
2714 -- For unpacked array types, set an alignment of 1 if we know
2715 -- that the component alignment is not greater than 1. The reason
2716 -- we do this is to avoid unnecessary copying of slices of such
2717 -- arrays when passed to subprogram parameters (see special test
2718 -- in Exp_Ch6.Expand_Actuals).
2722 then
2725 then
2730 -- We need to know whether the size depends on the value of one
2731 -- or more discriminants to select the return mechanism. Skip if
2732 -- errors are present, to prevent cascaded messages.
2741 -- Final step is to check that Esize and RM_Size are compatible
2746 -- Esize is less than RM_Size. That's not good. First we test
2747 -- whether this was set deliberately with an Object_Size clause
2748 -- and if so, object to the clause.
2752 Error_Msg_F
2754 Expression (Get_Attribute_Definition_Clause
2758 -- Adjust Esize up to RM_Size value
2760 declare
2763 begin
2766 -- For scalar types, increase Object_Size to power of 2, but
2767 -- not less than a storage unit in any case (i.e., normally
2768 -- this means it will be storage-unit addressable).
2777 else
2781 -- Finally, make sure that alignment is consistent with
2782 -- the newly assigned size.
2786 loop
2795 ---------------------
2796 -- Rewrite_Integer --
2797 ---------------------
2802 begin
2807 -------------------------------
2808 -- Set_And_Check_Static_Size --
2809 -------------------------------
2811 procedure Set_And_Check_Static_Size
2815 is
2819 -- Spec is the number of bit specified in the size clause, and Min is
2820 -- the minimum computed size. An error is given that the specified size
2821 -- is too small if Spec < Min, and in this case both Esize and RM_Size
2822 -- are set to unknown in E. The error message is posted on node SC.
2825 -- Spec is the number of bits specified in the size clause, and Max is
2826 -- the maximum computed size. A warning is given about unused bits if
2827 -- Spec > Max. This warning is posted on node SC.
2829 --------------------------
2830 -- Check_Size_Too_Small --
2831 --------------------------
2834 begin
2843 -----------------------
2844 -- Check_Unused_Bits --
2845 -----------------------
2848 begin
2855 -- Start of processing for Set_And_Check_Static_Size
2857 begin
2858 -- Case where Object_Size (Esize) is already set by a size clause
2867 -- Perform checks on specified size against computed sizes
2875 -- Case where Value_Size (RM_Size) is set by specific Value_Size clause
2876 -- (we do not need to worry about Value_Size being set by a Size clause,
2877 -- since that will have set Esize as well, and we already took care of
2878 -- that case).
2883 -- Perform checks on specified size against computed sizes
2891 -- Set sizes if unknown
2902 -----------------------------
2903 -- Set_Composite_Alignment --
2904 -----------------------------
2910 begin
2911 -- If alignment is already set, then nothing to do
2917 -- Alignment is not known, see if we can set it, taking into account
2918 -- the setting of the Optimize_Alignment mode.
2920 -- If Optimize_Alignment is set to Space, then we try to give packed
2921 -- records an aligmment of 1, unless there is some reason we can't.
2926 then
2927 -- No effect for record with atomic components
2935 -- No effect if independent components
2939 Error_Msg_N
2944 -- No effect if any component is atomic or is a by reference type
2946 declare
2948 begin
2954 then
2956 Error_Msg_N
2959 else
2965 -- Optimize_Alignment has no effect on variable length record
2973 -- All tests passed, we can set alignment to 1
2977 -- Not a record, or not packed
2979 else
2980 -- The only other cases we worry about here are where the size is
2981 -- statically known at compile time.
2988 then
2991 else
2995 -- Size is known, alignment is not set
2997 -- Reset alignment to match size if the known size is exactly 2, 4,
2998 -- or 8 storage units.
3007 -- If Optimize_Alignment is set to Space, then make sure the
3008 -- alignment matches the size, for example, if the size is 17
3009 -- bytes then we want an alignment of 1 for the type.
3018 else
3022 -- If Optimize_Alignment is set to Time, then we reset for odd
3023 -- "in between sizes", for example a 17 bit record is given an
3024 -- alignment of 4. Note that this matches the old VMS behavior
3025 -- in versions of GNAT prior to 6.1.1.
3030 then
3039 -- No special alignment fiddling needed
3041 else
3046 -- Here we have Set Align to the proposed improved value. Make sure the
3047 -- value set does not exceed Maximum_Alignment for the target.
3053 -- Further processing for record types only to reduce the alignment
3054 -- set by the above processing in some specific cases. We do not
3055 -- do this for atomic records, since we need max alignment there,
3059 -- For records, there is generally no point in setting alignment
3060 -- higher than word size since we cannot do better than move by
3061 -- words in any case. Omit this if we are optimizing for time,
3062 -- since conceivably we may be able to do better.
3066 then
3070 -- Check components. If any component requires a higher alignment,
3071 -- then we set that higher alignment in any case. Don't do this if
3072 -- we have Optimize_Alignment set to Space. Note that that covers
3073 -- the case of packed records, where we already set alignment to 1.
3076 declare
3079 begin
3083 declare
3086 begin
3087 -- The cases to process are when the alignment of the
3088 -- component type is larger than the alignment we have
3089 -- so far, and either there is no component clause for
3090 -- the component, or the length set by the component
3091 -- clause matches the length of the component type.
3094 and then
3097 and then
3100 then
3112 -- Set chosen alignment, and increase Esize if necessary to match the
3113 -- chosen alignment.
3119 then
3124 --------------------------
3125 -- Set_Discrete_RM_Size --
3126 --------------------------
3131 begin
3132 -- All discrete types except for the base types in standard are
3133 -- constrained, so indicate this by setting Is_Constrained.
3137 -- Set generic types to have an unknown size, since the representation
3138 -- of a generic type is irrelevant, in view of the fact that they have
3139 -- nothing to do with code.
3144 -- If the subtype statically matches the first subtype, then it is
3145 -- required to have exactly the same layout. This is required by
3146 -- aliasing considerations.
3150 then
3154 -- In all other cases the RM_Size is set to the minimum size. Note that
3155 -- this routine is never called for subtypes for which the RM_Size is
3156 -- set explicitly by an attribute clause.
3158 else
3163 ------------------------
3164 -- Set_Elem_Alignment --
3165 ------------------------
3168 begin
3169 -- Do not set alignment for packed array types, unless we are doing
3170 -- front end layout, because otherwise this is always handled in the
3171 -- backend.
3176 -- If there is an alignment clause, then we respect it
3181 -- If the size is not set, then don't attempt to set the alignment. This
3182 -- happens in the backend layout case for access-to-subprogram types.
3187 -- For access types, do not set the alignment if the size is less than
3188 -- the allowed minimum size. This avoids cascaded error messages.
3192 then
3196 -- Here we calculate the alignment as the largest power of two multiple
3197 -- of System.Storage_Unit that does not exceed either the object size of
3198 -- the type, or the maximum allowed alignment.
3200 declare
3206 begin
3207 -- The given Esize may be larger that int'last because of a previous
3208 -- error, and the call to UI_To_Int will fail, so use default.
3213 -- If this is an access type and the target doesn't have strict
3214 -- alignment and we are not doing front end layout, then cap the
3215 -- alignment to that of a regular access type. This will avoid
3216 -- giving fat pointers twice the usual alignment for no practical
3217 -- benefit since the misalignment doesn't really matter.
3220 and then not Target_Strict_Alignment
3221 and then not Frontend_Layout_On_Target
3222 then
3225 else
3229 -- If the default alignment of "double" floating-point types is
3230 -- specifically capped, enforce the cap.
3235 then
3238 -- If the default alignment of "double" or larger scalar types is
3239 -- specifically capped, enforce the cap.
3244 then
3247 -- Otherwise enforce the overall alignment cap
3249 else
3258 -- If alignment is currently not set, then we can safetly set it to
3259 -- this new calculated value.
3264 -- Cases where we have inherited an alignment
3266 -- For constructed types, always reset the alignment, these are
3267 -- Generally invisible to the user anyway, and that way we are
3268 -- sure that no constructed types have weird alignments.
3273 -- If this inherited alignment is the same as the one we computed,
3274 -- then obviously everything is fine, and we do not need to reset it.
3279 -- Now we come to the difficult cases where we have inherited an
3280 -- alignment and size, but overridden the size but not the alignment.
3284 -- This is tricky, it might be thought that we should try to
3285 -- inherit the alignment, since that's what the RM implies, but
3286 -- that leads to complex rules and oddities. Consider for example:
3288 -- type R is new Character;
3289 -- for R'Size use 16;
3291 -- It seems quite bogus in this case to inherit an alignment of 1
3292 -- from the parent type Character. Furthermore, if that's what the
3293 -- programmer really wanted for some odd reason, then they could
3294 -- specify the alignment they wanted.
3296 -- Furthermore we really don't want to inherit the alignment in
3297 -- the case of a specified Object_Size for a subtype, since then
3298 -- there would be no way of overriding to give a reasonable value
3299 -- (we don't have an Object_Subtype attribute). Consider:
3301 -- subtype R is new Character;
3302 -- for R'Object_Size use 16;
3304 -- If we inherit the alignment of 1, then we have an odd
3305 -- inefficient alignment for the subtype, which cannot be fixed.
3307 -- So we make the decision that if Size (or Object_Size) is given
3308 -- (and, in the case of a first subtype, the alignment is not set
3309 -- with a specific alignment clause). We reset the alignment to
3310 -- the appropriate value for the specified size. This is a nice
3311 -- simple rule to implement and document.
3313 -- There is one slight glitch, which is that a confirming size
3314 -- clause can now change the alignment, which, if we really think
3315 -- that confirming rep clauses should have no effect, is a no-no.
3317 -- type R is new Character;
3318 -- for R'Alignment use 2;
3319 -- type S is new R;
3320 -- for S'Size use Character'Size;
3322 -- Now the alignment of S is 1 instead of 2, as a result of
3323 -- applying the above rule to the confirming rep clause for S. Not
3324 -- clear this is worth worrying about. If we recorded whether a
3325 -- size clause was confirming we could avoid this, but right now
3326 -- we have no way of doing that or easily figuring it out, so we
3327 -- don't bother.
3329 -- Historical note. In versions of GNAT prior to Nov 6th, 2010, an
3330 -- odd distinction was made between inherited alignments greater
3331 -- than the computed alignment (where the larger alignment was
3332 -- inherited) and inherited alignments smaller than the computed
3333 -- alignment (where the smaller alignment was overridden). This
3334 -- was a dubious fix to get around an ACATS problem which seems
3335 -- to have disappeared anyway, and in any case, this peculiarity
3336 -- was never documented.
3340 -- If no Size (or Object_Size) was specified, then we inherited the
3341 -- object size, so we should inherit the alignment as well and not
3342 -- modify it. This takes care of cases like:
3344 -- type R is new Integer;
3345 -- for R'Alignment use 1;
3346 -- subtype S is R;
3348 -- Here we have R has a default Object_Size of 32, and a specified
3349 -- alignment of 1, and it seeems right for S to inherit both values.
3351 else
3357 ----------------------
3358 -- SO_Ref_From_Expr --
3359 ----------------------
3361 function SO_Ref_From_Expr
3366 is
3374 -- Function used to check one node for reference to V
3377 -- Function used to traverse tree to check for reference to V
3379 ----------------------
3380 -- Check_Node_V_Ref --
3381 ----------------------
3384 begin
3388 else
3392 else
3397 -- Start of processing for SO_Ref_From_Expr
3399 begin
3400 -- Case of expression is an integer literal, in this case we just
3401 -- return the value (which must always be non-negative, since size
3402 -- and offset values can never be negative).
3409 -- Case where there is a reference to V, create function
3415 -- Check whether Vtype is a view of a private type and ensure that
3416 -- we use the primary view of the type (which is denoted by its
3417 -- Etype, whether it's the type's partial or full view entity).
3418 -- This is needed to make sure that we use the same (primary) view
3419 -- of the type for all V formals, whether the current view of the
3420 -- type is the partial or full view, so that types will always
3421 -- match on calls from one size function to another.
3425 else
3431 Decl :=
3434 Specification =>
3439 Defining_Identifier =>
3441 Parameter_Type =>
3443 Result_Definition =>
3448 Handled_Statement_Sequence =>
3454 -- The caller requests that the expression be encapsulated in a
3455 -- parameterless function.
3458 Decl :=
3461 Specification =>
3465 Result_Definition =>
3470 Handled_Statement_Sequence =>
3475 -- No reference to V and function not requested, so create a constant
3477 else
3478 Decl :=
3481 Object_Definition =>