1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 2001-2018, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 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. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Atree; use Atree;
27 with Debug; use Debug;
28 with Einfo; use Einfo;
29 with Errout; use Errout;
31 with Sem_Aux; use Sem_Aux;
32 with Sem_Ch13; use Sem_Ch13;
33 with Sem_Eval; use Sem_Eval;
34 with Sem_Util; use Sem_Util;
35 with Sinfo; use Sinfo;
36 with Snames; use Snames;
37 with Ttypes; use Ttypes;
38 with Uintp; use Uintp;
40 package body Layout is
42 ------------------------
43 -- Local Declarations --
44 ------------------------
46 SSU : constant Int := Ttypes.System_Storage_Unit;
47 -- Short hand for System_Storage_Unit
49 -----------------------
50 -- Local Subprograms --
51 -----------------------
53 procedure Compute_Size_Depends_On_Discriminant (E : Entity_Id);
54 -- Given an array type or an array subtype E, compute whether its size
55 -- depends on the value of one or more discriminants and set the flag
56 -- Size_Depends_On_Discriminant accordingly. This need not be called
57 -- in front end layout mode since it does the computation on its own.
59 procedure Set_Composite_Alignment (E : Entity_Id);
60 -- This procedure is called for record types and subtypes, and also for
61 -- atomic array types and subtypes. If no alignment is set, and the size
62 -- is 2 or 4 (or 8 if the word size is 8), then the alignment is set to
65 ----------------------------
66 -- Adjust_Esize_Alignment --
67 ----------------------------
69 procedure Adjust_Esize_Alignment (E : Entity_Id) is
74 -- Nothing to do if size unknown
76 if Unknown_Esize (E) then
80 -- Determine if size is constrained by an attribute definition clause
81 -- which must be obeyed. If so, we cannot increase the size in this
84 -- For a type, the issue is whether an object size clause has been set.
85 -- A normal size clause constrains only the value size (RM_Size)
88 Esize_Set := Has_Object_Size_Clause (E);
90 -- For an object, the issue is whether a size clause is present
93 Esize_Set := Has_Size_Clause (E);
96 -- If size is known it must be a multiple of the storage unit size
98 if Esize (E) mod SSU /= 0 then
100 -- If not, and size specified, then give error
104 ("size for& not a multiple of storage unit size",
108 -- Otherwise bump up size to a storage unit boundary
111 Set_Esize (E, (Esize (E) + SSU - 1) / SSU * SSU);
115 -- Now we have the size set, it must be a multiple of the alignment
116 -- nothing more we can do here if the alignment is unknown here.
118 if Unknown_Alignment (E) then
122 -- At this point both the Esize and Alignment are known, so we need
123 -- to make sure they are consistent.
125 Abits := UI_To_Int (Alignment (E)) * SSU;
127 if Esize (E) mod Abits = 0 then
131 -- Here we have a situation where the Esize is not a multiple of the
132 -- alignment. We must either increase Esize or reduce the alignment to
133 -- correct this situation.
135 -- The case in which we can decrease the alignment is where the
136 -- alignment was not set by an alignment clause, and the type in
137 -- question is a discrete type, where it is definitely safe to reduce
138 -- the alignment. For example:
140 -- t : integer range 1 .. 2;
143 -- In this situation, the initial alignment of t is 4, copied from
144 -- the Integer base type, but it is safe to reduce it to 1 at this
145 -- stage, since we will only be loading a single storage unit.
147 if Is_Discrete_Type (Etype (E)) and then not Has_Alignment_Clause (E)
151 exit when Esize (E) mod Abits = 0;
154 Init_Alignment (E, Abits / SSU);
158 -- Now the only possible approach left is to increase the Esize but we
159 -- can't do that if the size was set by a specific clause.
163 ("size for& is not a multiple of alignment",
166 -- Otherwise we can indeed increase the size to a multiple of alignment
169 Set_Esize (E, ((Esize (E) + (Abits - 1)) / Abits) * Abits);
171 end Adjust_Esize_Alignment;
173 ------------------------------------------
174 -- Compute_Size_Depends_On_Discriminant --
175 ------------------------------------------
177 procedure Compute_Size_Depends_On_Discriminant (E : Entity_Id) is
182 Res : Boolean := False;
185 -- Loop to process array indexes
187 Indx := First_Index (E);
188 while Present (Indx) loop
189 Ityp := Etype (Indx);
191 -- If an index of the array is a generic formal type then there is
192 -- no point in determining a size for the array type.
194 if Is_Generic_Type (Ityp) then
198 Lo := Type_Low_Bound (Ityp);
199 Hi := Type_High_Bound (Ityp);
201 if (Nkind (Lo) = N_Identifier
202 and then Ekind (Entity (Lo)) = E_Discriminant)
204 (Nkind (Hi) = N_Identifier
205 and then Ekind (Entity (Hi)) = E_Discriminant)
214 Set_Size_Depends_On_Discriminant (E);
216 end Compute_Size_Depends_On_Discriminant;
222 procedure Layout_Object (E : Entity_Id) is
223 pragma Unreferenced (E);
225 -- Nothing to do for now, assume backend does the layout
234 procedure Layout_Type (E : Entity_Id) is
235 Desig_Type : Entity_Id;
238 -- For string literal types, for now, kill the size always, this is
239 -- because gigi does not like or need the size to be set ???
241 if Ekind (E) = E_String_Literal_Subtype then
242 Set_Esize (E, Uint_0);
243 Set_RM_Size (E, Uint_0);
247 -- For access types, set size/alignment. This is system address size,
248 -- except for fat pointers (unconstrained array access types), where the
249 -- size is two times the address size, to accommodate the two pointers
250 -- that are required for a fat pointer (data and template). Note that
251 -- E_Access_Protected_Subprogram_Type is not an access type for this
252 -- purpose since it is not a pointer but is equivalent to a record. For
253 -- access subtypes, copy the size from the base type since Gigi
254 -- represents them the same way.
256 if Is_Access_Type (E) then
257 Desig_Type := Underlying_Type (Designated_Type (E));
259 -- If we only have a limited view of the type, see whether the
260 -- non-limited view is available.
262 if From_Limited_With (Designated_Type (E))
263 and then Ekind (Designated_Type (E)) = E_Incomplete_Type
264 and then Present (Non_Limited_View (Designated_Type (E)))
266 Desig_Type := Non_Limited_View (Designated_Type (E));
269 -- If Esize already set (e.g. by a size clause), then nothing further
272 if Known_Esize (E) then
275 -- Access to subprogram is a strange beast, and we let the backend
276 -- figure out what is needed (it may be some kind of fat pointer,
277 -- including the static link for example.
279 elsif Is_Access_Protected_Subprogram_Type (E) then
282 -- For access subtypes, copy the size information from base type
284 elsif Ekind (E) = E_Access_Subtype then
285 Set_Size_Info (E, Base_Type (E));
286 Set_RM_Size (E, RM_Size (Base_Type (E)));
288 -- For other access types, we use either address size, or, if a fat
289 -- pointer is used (pointer-to-unconstrained array case), twice the
290 -- address size to accommodate a fat pointer.
292 elsif Present (Desig_Type)
293 and then Is_Array_Type (Desig_Type)
294 and then not Is_Constrained (Desig_Type)
295 and then not Has_Completion_In_Body (Desig_Type)
297 -- Debug Flag -gnatd6 says make all pointers to unconstrained thin
299 and then not Debug_Flag_6
301 Init_Size (E, 2 * System_Address_Size);
303 -- Check for bad convention set
305 if Warn_On_Export_Import
307 (Convention (E) = Convention_C
309 Convention (E) = Convention_CPP)
312 ("?x?this access type does not correspond to C pointer", E);
315 -- If the designated type is a limited view it is unanalyzed. We can
316 -- examine the declaration itself to determine whether it will need a
319 elsif Present (Desig_Type)
320 and then Present (Parent (Desig_Type))
321 and then Nkind (Parent (Desig_Type)) = N_Full_Type_Declaration
322 and then Nkind (Type_Definition (Parent (Desig_Type))) =
323 N_Unconstrained_Array_Definition
324 and then not Debug_Flag_6
326 Init_Size (E, 2 * System_Address_Size);
328 -- If unnesting subprograms, subprogram access types contain the
329 -- address of both the subprogram and an activation record. But
330 -- if we set that, we'll get a warning on different unchecked
331 -- conversion sizes in the RTS. So leave unset ub that case.
333 elsif Unnest_Subprogram_Mode
334 and then Is_Access_Subprogram_Type (E)
336 -- Init_Size (E, 2 * System_Address_Size);
339 -- Normal case of thin pointer
342 Init_Size (E, System_Address_Size);
345 Set_Elem_Alignment (E);
347 -- Scalar types: set size and alignment
349 elsif Is_Scalar_Type (E) then
351 -- For discrete types, the RM_Size and Esize must be set already,
352 -- since this is part of the earlier processing and the front end is
353 -- always required to lay out the sizes of such types (since they are
354 -- available as static attributes). All we do is to check that this
355 -- rule is indeed obeyed.
357 if Is_Discrete_Type (E) then
359 -- If the RM_Size is not set, then here is where we set it
361 -- Note: an RM_Size of zero looks like not set here, but this
362 -- is a rare case, and we can simply reset it without any harm.
364 if not Known_RM_Size (E) then
365 Set_Discrete_RM_Size (E);
368 -- If Esize for a discrete type is not set then set it
370 if not Known_Esize (E) then
376 -- If size is big enough, set it and exit
378 if S >= RM_Size (E) then
382 -- If the RM_Size is greater than 64 (happens only when
383 -- strange values are specified by the user, then Esize
384 -- is simply a copy of RM_Size, it will be further
388 Set_Esize (E, RM_Size (E));
391 -- Otherwise double possible size and keep trying
400 -- For non-discrete scalar types, if the RM_Size is not set, then set
401 -- it now to a copy of the Esize if the Esize is set.
404 if Known_Esize (E) and then Unknown_RM_Size (E) then
405 Set_RM_Size (E, Esize (E));
409 Set_Elem_Alignment (E);
411 -- Non-elementary (composite) types
414 -- For packed arrays, take size and alignment values from the packed
415 -- array type if a packed array type has been created and the fields
416 -- are not currently set.
419 and then Present (Packed_Array_Impl_Type (E))
422 PAT : constant Entity_Id := Packed_Array_Impl_Type (E);
425 if Unknown_Esize (E) then
426 Set_Esize (E, Esize (PAT));
429 if Unknown_RM_Size (E) then
430 Set_RM_Size (E, RM_Size (PAT));
433 if Unknown_Alignment (E) then
434 Set_Alignment (E, Alignment (PAT));
439 -- If Esize is set, and RM_Size is not, RM_Size is copied from Esize.
440 -- At least for now this seems reasonable, and is in any case needed
441 -- for compatibility with old versions of gigi.
443 if Known_Esize (E) and then Unknown_RM_Size (E) then
444 Set_RM_Size (E, Esize (E));
447 -- For array base types, set component size if object size of the
448 -- component type is known and is a small power of 2 (8, 16, 32, 64),
449 -- since this is what will always be used.
451 if Ekind (E) = E_Array_Type and then Unknown_Component_Size (E) then
453 CT : constant Entity_Id := Component_Type (E);
456 -- For some reason, access types can cause trouble, So let's
457 -- just do this for scalar types ???
460 and then Is_Scalar_Type (CT)
461 and then Known_Static_Esize (CT)
464 S : constant Uint := Esize (CT);
466 if Addressable (S) then
467 Set_Component_Size (E, S);
475 -- Even if the backend performs the layout, we still do a little in
478 -- Processing for record types
480 if Is_Record_Type (E) then
482 -- Special remaining processing for record types with a known
483 -- size of 16, 32, or 64 bits whose alignment is not yet set.
484 -- For these types, we set a corresponding alignment matching
485 -- the size if possible, or as large as possible if not.
487 if Convention (E) = Convention_Ada and then not Debug_Flag_Q then
488 Set_Composite_Alignment (E);
491 -- Processing for array types
493 elsif Is_Array_Type (E) then
495 -- For arrays that are required to be atomic/VFA, we do the same
496 -- processing as described above for short records, since we
497 -- really need to have the alignment set for the whole array.
499 if Is_Atomic_Or_VFA (E) and then not Debug_Flag_Q then
500 Set_Composite_Alignment (E);
503 -- For unpacked array types, set an alignment of 1 if we know
504 -- that the component alignment is not greater than 1. The reason
505 -- we do this is to avoid unnecessary copying of slices of such
506 -- arrays when passed to subprogram parameters (see special test
507 -- in Exp_Ch6.Expand_Actuals).
509 if not Is_Packed (E) and then Unknown_Alignment (E) then
510 if Known_Static_Component_Size (E)
511 and then Component_Size (E) = 1
513 Set_Alignment (E, Uint_1);
517 -- We need to know whether the size depends on the value of one
518 -- or more discriminants to select the return mechanism. Skip if
519 -- errors are present, to prevent cascaded messages.
521 if Serious_Errors_Detected = 0 then
522 Compute_Size_Depends_On_Discriminant (E);
526 -- Final step is to check that Esize and RM_Size are compatible
528 if Known_Static_Esize (E) and then Known_Static_RM_Size (E) then
529 if Esize (E) < RM_Size (E) then
531 -- Esize is less than RM_Size. That's not good. First we test
532 -- whether this was set deliberately with an Object_Size clause
533 -- and if so, object to the clause.
535 if Has_Object_Size_Clause (E) then
536 Error_Msg_Uint_1 := RM_Size (E);
538 ("object size is too small, minimum allowed is ^",
539 Expression (Get_Attribute_Definition_Clause
540 (E, Attribute_Object_Size)));
543 -- Adjust Esize up to RM_Size value
546 Size : constant Uint := RM_Size (E);
549 Set_Esize (E, RM_Size (E));
551 -- For scalar types, increase Object_Size to power of 2, but
552 -- not less than a storage unit in any case (i.e., normally
553 -- this means it will be storage-unit addressable).
555 if Is_Scalar_Type (E) then
558 elsif Size <= 16 then
560 elsif Size <= 32 then
563 Set_Esize (E, (Size + 63) / 64 * 64);
566 -- Finally, make sure that alignment is consistent with
567 -- the newly assigned size.
569 while Alignment (E) * SSU < Esize (E)
570 and then Alignment (E) < Maximum_Alignment
572 Set_Alignment (E, 2 * Alignment (E));
580 -----------------------------
581 -- Set_Composite_Alignment --
582 -----------------------------
584 procedure Set_Composite_Alignment (E : Entity_Id) is
589 -- If alignment is already set, then nothing to do
591 if Known_Alignment (E) then
595 -- Alignment is not known, see if we can set it, taking into account
596 -- the setting of the Optimize_Alignment mode.
598 -- If Optimize_Alignment is set to Space, then we try to give packed
599 -- records an aligmment of 1, unless there is some reason we can't.
601 if Optimize_Alignment_Space (E)
602 and then Is_Record_Type (E)
603 and then Is_Packed (E)
605 -- No effect for record with atomic/VFA components
607 if Is_Atomic_Or_VFA (E) then
608 Error_Msg_N ("Optimize_Alignment has no effect for &??", E);
610 if Is_Atomic (E) then
612 ("\pragma ignored for atomic record??", E);
615 ("\pragma ignored for bolatile full access record??", E);
621 -- No effect if independent components
623 if Has_Independent_Components (E) then
624 Error_Msg_N ("Optimize_Alignment has no effect for &??", E);
626 ("\pragma ignored for record with independent components??", E);
630 -- No effect if any component is atomic/VFA or is a by-reference type
636 Ent := First_Component_Or_Discriminant (E);
637 while Present (Ent) loop
638 if Is_By_Reference_Type (Etype (Ent))
639 or else Is_Atomic_Or_VFA (Etype (Ent))
640 or else Is_Atomic_Or_VFA (Ent)
642 Error_Msg_N ("Optimize_Alignment has no effect for &??", E);
644 if Is_Atomic (Etype (Ent)) or else Is_Atomic (Ent) then
646 ("\pragma is ignored if atomic "
647 & "components present??", E);
650 ("\pragma is ignored if bolatile full access "
651 & "components present??", E);
656 Next_Component_Or_Discriminant (Ent);
661 -- Optimize_Alignment has no effect on variable length record
663 if not Size_Known_At_Compile_Time (E) then
664 Error_Msg_N ("Optimize_Alignment has no effect for &??", E);
665 Error_Msg_N ("\pragma is ignored for variable length record??", E);
669 -- All tests passed, we can set alignment to 1
673 -- Not a record, or not packed
676 -- The only other cases we worry about here are where the size is
677 -- statically known at compile time.
679 if Known_Static_Esize (E) then
681 elsif Unknown_Esize (E) and then Known_Static_RM_Size (E) then
687 -- Size is known, alignment is not set
689 -- Reset alignment to match size if the known size is exactly 2, 4,
690 -- or 8 storage units.
692 if Siz = 2 * SSU then
694 elsif Siz = 4 * SSU then
696 elsif Siz = 8 * SSU then
699 -- If Optimize_Alignment is set to Space, then make sure the
700 -- alignment matches the size, for example, if the size is 17
701 -- bytes then we want an alignment of 1 for the type.
703 elsif Optimize_Alignment_Space (E) then
704 if Siz mod (8 * SSU) = 0 then
706 elsif Siz mod (4 * SSU) = 0 then
708 elsif Siz mod (2 * SSU) = 0 then
714 -- If Optimize_Alignment is set to Time, then we reset for odd
715 -- "in between sizes", for example a 17 bit record is given an
718 elsif Optimize_Alignment_Time (E)
720 and then Siz <= 8 * SSU
722 if Siz <= 2 * SSU then
724 elsif Siz <= 4 * SSU then
726 else -- Siz <= 8 * SSU then
730 -- No special alignment fiddling needed
737 -- Here we have Set Align to the proposed improved value. Make sure the
738 -- value set does not exceed Maximum_Alignment for the target.
740 if Align > Maximum_Alignment then
741 Align := Maximum_Alignment;
744 -- Further processing for record types only to reduce the alignment
745 -- set by the above processing in some specific cases. We do not
746 -- do this for atomic/VFA records, since we need max alignment there,
748 if Is_Record_Type (E) and then not Is_Atomic_Or_VFA (E) then
750 -- For records, there is generally no point in setting alignment
751 -- higher than word size since we cannot do better than move by
752 -- words in any case. Omit this if we are optimizing for time,
753 -- since conceivably we may be able to do better.
755 if Align > System_Word_Size / SSU
756 and then not Optimize_Alignment_Time (E)
758 Align := System_Word_Size / SSU;
761 -- Check components. If any component requires a higher alignment,
762 -- then we set that higher alignment in any case. Don't do this if
763 -- we have Optimize_Alignment set to Space. Note that that covers
764 -- the case of packed records, where we already set alignment to 1.
766 if not Optimize_Alignment_Space (E) then
771 Comp := First_Component (E);
772 while Present (Comp) loop
773 if Known_Alignment (Etype (Comp)) then
775 Calign : constant Uint := Alignment (Etype (Comp));
778 -- The cases to process are when the alignment of the
779 -- component type is larger than the alignment we have
780 -- so far, and either there is no component clause for
781 -- the component, or the length set by the component
782 -- clause matches the length of the component type.
786 (Unknown_Esize (Comp)
787 or else (Known_Static_Esize (Comp)
789 Esize (Comp) = Calign * SSU))
791 Align := UI_To_Int (Calign);
796 Next_Component (Comp);
802 -- Set chosen alignment, and increase Esize if necessary to match the
805 Set_Alignment (E, UI_From_Int (Align));
807 if Known_Static_Esize (E)
808 and then Esize (E) < Align * SSU
810 Set_Esize (E, UI_From_Int (Align * SSU));
812 end Set_Composite_Alignment;
814 --------------------------
815 -- Set_Discrete_RM_Size --
816 --------------------------
818 procedure Set_Discrete_RM_Size (Def_Id : Entity_Id) is
819 FST : constant Entity_Id := First_Subtype (Def_Id);
822 -- All discrete types except for the base types in standard are
823 -- constrained, so indicate this by setting Is_Constrained.
825 Set_Is_Constrained (Def_Id);
827 -- Set generic types to have an unknown size, since the representation
828 -- of a generic type is irrelevant, in view of the fact that they have
829 -- nothing to do with code.
831 if Is_Generic_Type (Root_Type (FST)) then
832 Set_RM_Size (Def_Id, Uint_0);
834 -- If the subtype statically matches the first subtype, then it is
835 -- required to have exactly the same layout. This is required by
836 -- aliasing considerations.
838 elsif Def_Id /= FST and then
839 Subtypes_Statically_Match (Def_Id, FST)
841 Set_RM_Size (Def_Id, RM_Size (FST));
842 Set_Size_Info (Def_Id, FST);
844 -- In all other cases the RM_Size is set to the minimum size. Note that
845 -- this routine is never called for subtypes for which the RM_Size is
846 -- set explicitly by an attribute clause.
849 Set_RM_Size (Def_Id, UI_From_Int (Minimum_Size (Def_Id)));
851 end Set_Discrete_RM_Size;
853 ------------------------
854 -- Set_Elem_Alignment --
855 ------------------------
857 procedure Set_Elem_Alignment (E : Entity_Id; Align : Nat := 0) is
859 -- Do not set alignment for packed array types, this is handled in the
862 if Is_Packed_Array_Impl_Type (E) then
865 -- If there is an alignment clause, then we respect it
867 elsif Has_Alignment_Clause (E) then
870 -- If the size is not set, then don't attempt to set the alignment. This
871 -- happens in the backend layout case for access-to-subprogram types.
873 elsif not Known_Static_Esize (E) then
876 -- For access types, do not set the alignment if the size is less than
877 -- the allowed minimum size. This avoids cascaded error messages.
879 elsif Is_Access_Type (E) and then Esize (E) < System_Address_Size then
883 -- We attempt to set the alignment in all the other cases
891 -- The given Esize may be larger that int'last because of a previous
892 -- error, and the call to UI_To_Int will fail, so use default.
894 if Esize (E) / SSU > Ttypes.Maximum_Alignment then
895 S := Ttypes.Maximum_Alignment;
897 -- If this is an access type and the target doesn't have strict
898 -- alignment, then cap the alignment to that of a regular access
899 -- type. This will avoid giving fat pointers twice the usual
900 -- alignment for no practical benefit since the misalignment doesn't
903 elsif Is_Access_Type (E)
904 and then not Target_Strict_Alignment
906 S := System_Address_Size / SSU;
909 S := UI_To_Int (Esize (E)) / SSU;
912 -- If the default alignment of "double" floating-point types is
913 -- specifically capped, enforce the cap.
915 if Ttypes.Target_Double_Float_Alignment > 0
917 and then Is_Floating_Point_Type (E)
919 M := Ttypes.Target_Double_Float_Alignment;
921 -- If the default alignment of "double" or larger scalar types is
922 -- specifically capped, enforce the cap.
924 elsif Ttypes.Target_Double_Scalar_Alignment > 0
926 and then Is_Scalar_Type (E)
928 M := Ttypes.Target_Double_Scalar_Alignment;
930 -- Otherwise enforce the overall alignment cap
933 M := Ttypes.Maximum_Alignment;
936 -- We calculate the alignment as the largest power-of-two multiple
937 -- of System.Storage_Unit that does not exceed the object size of
938 -- the type and the maximum allowed alignment, if none was specified.
939 -- Otherwise we only cap it to the maximum allowed alignment.
943 while 2 * A <= S and then 2 * A <= M loop
947 A := Nat'Min (Align, M);
950 -- If alignment is currently not set, then we can safely set it to
951 -- this new calculated value.
953 if Unknown_Alignment (E) then
954 Init_Alignment (E, A);
956 -- Cases where we have inherited an alignment
958 -- For constructed types, always reset the alignment, these are
959 -- generally invisible to the user anyway, and that way we are
960 -- sure that no constructed types have weird alignments.
962 elsif not Comes_From_Source (E) then
963 Init_Alignment (E, A);
965 -- If this inherited alignment is the same as the one we computed,
966 -- then obviously everything is fine, and we do not need to reset it.
968 elsif Alignment (E) = A then
972 -- Now we come to the difficult cases of subtypes for which we
973 -- have inherited an alignment different from the computed one.
974 -- We resort to the presence of alignment and size clauses to
975 -- guide our choices. Note that they can generally be present
976 -- only on the first subtype (except for Object_Size) and that
977 -- we need to look at the Rep_Item chain to correctly handle
981 FST : constant Entity_Id := First_Subtype (E);
983 function Has_Attribute_Clause
985 Id : Attribute_Id) return Boolean;
986 -- Wrapper around Get_Attribute_Definition_Clause which tests
987 -- for the presence of the specified attribute clause.
989 --------------------------
990 -- Has_Attribute_Clause --
991 --------------------------
993 function Has_Attribute_Clause
995 Id : Attribute_Id) return Boolean is
997 return Present (Get_Attribute_Definition_Clause (E, Id));
998 end Has_Attribute_Clause;
1001 -- If the alignment comes from a clause, then we respect it.
1002 -- Consider for example:
1004 -- type R is new Character;
1005 -- for R'Alignment use 1;
1006 -- for R'Size use 16;
1009 -- Here R has a specified size of 16 and a specified alignment
1010 -- of 1, and it seems right for S to inherit both values.
1012 if Has_Attribute_Clause (FST, Attribute_Alignment) then
1015 -- Now we come to the cases where we have inherited alignment
1016 -- and size, and overridden the size but not the alignment.
1018 elsif Has_Attribute_Clause (FST, Attribute_Size)
1019 or else Has_Attribute_Clause (FST, Attribute_Object_Size)
1020 or else Has_Attribute_Clause (E, Attribute_Object_Size)
1022 -- This is tricky, it might be thought that we should try to
1023 -- inherit the alignment, since that's what the RM implies,
1024 -- but that leads to complex rules and oddities. Consider
1027 -- type R is new Character;
1028 -- for R'Size use 16;
1030 -- It seems quite bogus in this case to inherit an alignment
1031 -- of 1 from the parent type Character. Furthermore, if that
1032 -- is what the programmer really wanted for some odd reason,
1033 -- then he could specify the alignment directly.
1035 -- Moreover we really don't want to inherit the alignment in
1036 -- the case of a specified Object_Size for a subtype, since
1037 -- there would be no way of overriding to give a reasonable
1038 -- value (as we don't have an Object_Alignment attribute).
1039 -- Consider for example:
1041 -- subtype R is Character;
1042 -- for R'Object_Size use 16;
1044 -- If we inherit the alignment of 1, then it will be very
1045 -- inefficient for the subtype and this cannot be fixed.
1047 -- So we make the decision that if Size (or Object_Size) is
1048 -- given and the alignment is not specified with a clause,
1049 -- we reset the alignment to the appropriate value for the
1050 -- specified size. This is a nice simple rule to implement
1053 -- There is a theoretical glitch, which is that a confirming
1054 -- size clause could now change the alignment, which, if we
1055 -- really think that confirming rep clauses should have no
1056 -- effect, could be seen as a no-no. However that's already
1057 -- implemented by Alignment_Check_For_Size_Change so we do
1058 -- not change the philosophy here.
1060 -- Historical note: in versions prior to Nov 6th, 2011, an
1061 -- odd distinction was made between inherited alignments
1062 -- larger than the computed alignment (where the larger
1063 -- alignment was inherited) and inherited alignments smaller
1064 -- than the computed alignment (where the smaller alignment
1065 -- was overridden). This was a dubious fix to get around an
1066 -- ACATS problem which seems to have disappeared anyway, and
1067 -- in any case, this peculiarity was never documented.
1069 Init_Alignment (E, A);
1071 -- If no Size (or Object_Size) was specified, then we have
1072 -- inherited the object size, so we should also inherit the
1073 -- alignment and not modify it.
1081 end Set_Elem_Alignment;