| blob | c3d2de22b65f63271cbdc3b1bd23f3aeb58e9c05 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2023, 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 along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
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 ****************************************************************************/
56 /* The "stdcall" convention is really supported on 32-bit x86/Windows only.
57 The following macro is a helper to avoid having to check for a Windows
58 specific attribute throughout this unit. */
60 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
61 #ifdef TARGET_64BIT
62 #define Has_Stdcall_Convention(E) \
63 (!TARGET_64BIT && Convention (E) == Convention_Stdcall)
64 #else
65 #define Has_Stdcall_Convention(E) (Convention (E) == Convention_Stdcall)
66 #endif
67 #else
68 #define Has_Stdcall_Convention(E) 0
69 #endif
73 /* Stack realignment is necessary for functions with foreign conventions when
74 the ABI doesn't mandate as much as what the compiler assumes - that is, up
75 to PREFERRED_STACK_BOUNDARY.
77 Such realignment can be requested with a dedicated function type attribute
78 on the targets that support it. We define FOREIGN_FORCE_REALIGN_STACK to
79 characterize the situations where the attribute should be set. We rely on
80 compiler configuration settings for 'main' to decide. */
82 #ifdef MAIN_STACK_BOUNDARY
83 #define FOREIGN_FORCE_REALIGN_STACK \
84 (MAIN_STACK_BOUNDARY < PREFERRED_STACK_BOUNDARY)
85 #else
86 #define FOREIGN_FORCE_REALIGN_STACK 0
87 #endif
89 /* The largest TYPE_ARRAY_MAX_SIZE value we set on an array type.
90 It's an artibrary limit (256 MB) above which we consider that
91 the allocation is essentially unbounded. */
93 #define TYPE_ARRAY_SIZE_LIMIT (1 << 28)
95 struct incomplete
96 {
98 tree old_type;
99 Entity_Id full_type;
100 };
102 /* These variables are used to defer recursively expanding incomplete types
103 while we are processing a record, an array or a subprogram type. */
107 /* This variable is used to delay expanding types coming from a limited with
108 clause and completed Taft Amendment types until the end of the spec. */
112 tree discriminant;
113 tree replacement;
118 /* The type of the variant. */
119 tree type;
121 /* The associated field. */
122 tree field;
124 /* The value of the qualifier. */
125 tree qual;
127 /* The type of the variant after transformation. */
128 tree new_type;
130 /* The auxiliary data. */
131 tree aux;
135 /* A map used to cache the result of annotate_value. */
137 {
140 {
142 }
146 {
148 }
150 static int
152 {
154 }
155 };
159 /* A map used to associate a dummy type with a list of subprogram entities. */
161 {
164 };
167 {
170 {
172 }
176 {
178 }
180 static int
182 {
184 }
185 };
220 tree *);
248 /* The relevant constituents of a subprogram binding to a GCC builtin. Used
249 to pass around calls performing profile compatibility checks. */
259 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
260 entity, return the equivalent GCC tree for that entity (a ..._DECL node)
261 and associate the ..._DECL node with the input GNAT defining identifier.
263 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
264 initial value (in GCC tree form). This is optional for a variable. For
265 a renamed entity, GNU_EXPR gives the object being renamed.
267 DEFINITION is true if this call is intended for a definition. This is used
268 for separate compilation where it is necessary to know whether an external
269 declaration or a definition must be created if the GCC equivalent was not
270 created previously. */
272 tree
274 {
275 /* The construct that declared the entity. */
277 /* The object that the entity renames, if any. */
279 /* The kind of the entity. */
281 /* True if this is a type. */
283 /* True if this is an artificial entity. */
285 /* True if debug info is requested for this entity. */
287 /* True if this entity is to be considered as imported. */
288 const bool imported_p
290 /* True if this entity has a foreign convention. */
292 /* For a type, contains the equivalent GNAT node to be used in gigi. */
294 /* For a subtype, contains the GNAT node to be used as cloned subtype. */
296 /* Temporary used to walk the GNAT tree. */
297 Entity_Id gnat_temp;
298 /* Contains the GCC DECL node which is equivalent to the input GNAT node.
299 This node will be associated with the GNAT node by calling at the end
300 of the `switch' statement. */
302 /* Contains the GCC type to be used for the GCC node. */
304 /* Contains the GCC size tree to be used for the GCC node. */
306 /* Contains the GCC name to be used for the GCC node. */
307 tree gnu_entity_name;
308 /* True if we have already saved gnu_decl as a GNAT association. This can
309 also be used to purposely avoid making such an association but this use
310 case ought not to be applied to types because it can break the deferral
311 mechanism implemented for access types. */
313 /* True if we incremented defer_incomplete_level. */
315 /* True if we incremented force_global. */
317 /* True if we should check to see if elaborated during processing. */
319 /* True if we made GNU_DECL and its type here. */
321 /* Size and alignment of the GCC node, if meaningful. */
323 /* Contains the list of attributes directly attached to the entity. */
326 /* Since a use of an itype is a definition, process it as such if it is in
327 the main unit, except for E_Access_Subtype because it's actually a use
328 of its base type, and for E_Class_Wide_Subtype with an Equivalent_Type
329 because it's actually a use of the latter type. */
331 && is_type
338 {
339 /* Unless it's for an anonymous access type, whose scope is irrelevant,
340 ensure that we are in a subprogram mentioned in the Scope chain of
341 this entity, our current scope is global, or we encountered a task
342 or entry (where we can't currently accurately check scoping). */
344 || !current_function_decl
346 {
349 }
354 {
367 && (current_function_decl
369 {
372 }
373 }
375 /* This abort means the itype has an incorrect scope, i.e. that its
376 scope does not correspond to the subprogram it is first used in. */
378 }
380 /* If we've already processed this entity, return what we got last time.
381 If we are defining the node, we should not have already processed it.
382 In that case, we will abort below when we try to save a new GCC tree
383 for this object. We also need to handle the case of getting a dummy
384 type when a Full_View exists but be careful so as not to trigger its
385 premature elaboration. Likewise for a cloned subtype without its own
386 freeze node, which typically happens when a generic gets instantiated
387 on an incomplete or private type. */
390 {
399 {
400 gnu_decl
405 }
414 {
415 gnu_decl
420 }
423 }
425 /* If this is a numeric or enumeral type, or an access type, a nonzero Esize
426 must be specified unless it was specified by the programmer. Exceptions
427 are for access-to-protected-subprogram types and all access subtypes, as
428 another GNAT type is used to lay out the GCC type for them, as well as
429 access-to-subprogram types if front-end unnesting is enabled. */
444 /* The RM size must be specified for all discrete and fixed-point types. */
448 /* If we get here, it means we have not yet done anything with this entity.
449 If we are not defining it, it must be a type or an entity that is defined
450 elsewhere or externally, otherwise we should have defined it already.
452 In other words, the failure of this assertion typically arises when a
453 reference to an entity (type or object) is made before its declaration,
454 either directly or by means of a freeze node which is incorrectly placed.
455 This can also happen for an entity referenced out of context, for example
456 a parameter outside of the subprogram where it is declared. GNAT_ENTITY
457 is the N_Defining_Identifier of the entity, the problematic N_Identifier
458 being the argument passed to Identifier_to_gnu in the parent frame.
460 One exception is for an entity, typically an inherited operation, which is
461 a local alias for the parent's operation. It is neither defined, since it
462 is an inherited operation, nor public, since it is declared in the current
463 compilation unit, so we test Is_Public on the Alias entity instead. */
465 || is_type
475 /* Get the name of the entity and set up the line number and filename of
476 the original definition for use in any decl we make. Make sure we do
477 not inherit another source location. */
482 /* For cases when we are not defining (i.e., we are referencing from
483 another compilation unit) public entities, show we are at global level
484 for the purpose of computing scopes. Don't do this for components or
485 discriminants since the relevant test is whether or not the record is
486 being defined. */
494 /* Handle any attributes directly attached to the entity. */
498 /* Do some common processing for types. */
500 {
501 /* Compute the equivalent type to be used in gigi. */
504 /* Machine_Attributes on types are expected to be propagated to
505 subtypes. The corresponding Gigi_Rep_Items are only attached
506 to the first subtype though, so we handle the propagation here. */
513 /* Compute a default value for the size of an elementary type. */
515 {
525 else
530 }
531 }
534 {
537 {
538 /* The GNAT record where the component was defined. */
541 /* If the entity is a discriminant of an extended tagged type used to
542 rename a discriminant of the parent type, return the latter. */
546 {
547 gnu_decl
552 }
554 /* If the entity is an inherited component (in the case of extended
555 tagged record types), just return the original entity, which must
556 be a FIELD_DECL. Likewise for discriminants. If the entity is a
557 non-stored discriminant (in the case of derived untagged record
558 types), return the stored discriminant it renames. */
561 {
562 gnu_decl
565 /* GNU_DECL contains a PLACEHOLDER_EXPR for discriminants. */
569 }
571 /* Otherwise, if we are not defining this and we have no GCC type
572 for the containing record, make one for it. Then we should
573 have made our own equivalent. */
575 {
576 /* ??? If this is in a record whose scope is a protected
577 type and we have an Original_Record_Component, use it.
578 This is a workaround for major problems in protected type
579 handling. */
583 {
584 gnu_decl
588 }
589 else
590 {
593 }
597 }
599 /* Here we have no GCC type and this is a reference rather than a
600 definition. This should never happen. Most likely the cause is
601 reference before declaration in the GNAT tree for gnat_entity. */
603 }
607 {
613 /* All references are supposed to be folded in the front-end. */
619 /* Build a CONST_DECL for debugging purposes exclusively. */
620 gnu_decl
625 }
629 /* Ignore constant definitions already marked with the error node. See
630 the N_Object_Declaration case of gnat_to_gnu for the rationale. */
634 {
637 }
639 /* Ignore deferred constant definitions without address clause since
640 they are processed fully in the front-end. If No_Initialization
641 is set, this is not a deferred constant but a constant whose value
642 is built manually. And constants that are renamings are handled
643 like variables. */
645 && !gnu_expr
649 {
653 }
655 /* If this is a use of a deferred constant without address clause,
656 get its full definition. */
660 {
661 gnu_decl
665 }
667 /* If we have a constant that we are not defining, get the expression it
668 was defined to represent. This is necessary to avoid generating dumb
669 elaboration code in simple cases, and we may throw it away later if it
670 is not a constant. But do not do it for dispatch tables because they
671 are only referenced indirectly and we need to have a consistent view
672 of the exported and of the imported declarations of the tables from
673 external units for them to be properly merged in LTO mode. Moreover
674 simply do not retrieve the expression if it is an allocator because
675 the designated type might still be dummy at this point. Note that we
676 invoke gnat_to_gnu_external and not gnat_to_gnu because the expression
677 may contain N_Expression_With_Actions nodes and thus declarations of
678 objects from other units that we need to discard. Note also that we
679 need to do it even if we are only annotating types, so as to be able
680 to validate representation clauses using constants. */
689 /* ... fall through ... */
695 {
698 /* Always create a variable for volatile objects and variables seen
699 constant but with a Linker_Section pragma. */
700 bool const_flag
712 /* We implement RM 13.3(19) for exported and imported (non-constant)
713 objects by making them volatile. */
714 bool volatile_flag
722 /* We need to translate the renamed object even though we are only
723 referencing the renaming. But it may contain a call for which
724 we'll generate a temporary to hold the return value and which
725 is part of the definition of the renaming, so discard it. */
727 {
731 else
733 }
735 /* Get the type after elaborating the renamed object. */
738 else
741 /* For a debug renaming declaration, build a debug-only entity. */
743 {
744 /* Force a non-null value to make sure the symbol is retained. */
748 integer_minus_one_node));
756 }
758 /* If this is a loop variable, its type should be the base type.
759 This is because the code for processing a loop determines whether
760 a normal loop end test can be done by comparing the bounds of the
761 loop against those of the base type, which is presumed to be the
762 size used for computation. But this is not correct when the size
763 of the subtype is smaller than the type. */
767 /* If this is a simple constant, strip the qualifiers from its type,
768 since the constant represents only its value. */
772 /* Reject non-renamed objects whose type is an unconstrained array or
773 any object whose type is a dummy type or void. */
778 {
781 force_global--;
783 }
785 /* If an alignment is specified, use it if valid. Note that exceptions
786 are objects but don't have an alignment and there is also no point in
787 setting it for an address clause, since the final type of the object
788 will be a reference type. */
795 /* Likewise, if a size is specified, use it if valid. */
797 gnu_size
802 {
803 gnu_type
809 }
811 /* If this object has self-referential size, it must be a record with
812 a default discriminant. We are supposed to allocate an object of
813 the maximum size in this case, unless it is a constant with an
814 initializing expression, in which case we can get the size from
815 that. Note that the resulting size may still be a variable, so
816 this may end up with an indirect allocation. */
819 {
821 {
825 {
826 /* If the initializing expression is itself a constant,
827 despite having a nominal type with self-referential
828 size, we can get the size directly from it. */
830 && TYPE_IS_PADDING_P
834 || DECL_READONLY_ONCE_ELAB
836 {
839 }
840 else
841 {
842 gnu_size
844 gnu_expr);
845 gnu_ada_size
847 gnu_expr);
848 }
849 }
850 }
851 /* We may have no GNU_EXPR because No_Initialization is
852 set even though there's an Expression. */
856 {
857 tree gnu_expr_type
861 }
862 else
863 {
865 /* We can be called on unconstrained arrays in this mode. */
869 }
871 /* If the size isn't constant and we are at global level, call
872 elaborate_expression_1 to make a variable for it rather than
873 calculating it each time. */
877 }
879 /* If the size is zero byte, make it one byte since some linkers have
880 troubles with zero-sized objects. If the object will have a
881 template, that will make it nonzero so don't bother. Also avoid
882 doing that for an object renaming or an object with an address
883 clause, as we would lose useful information on the view size
884 (e.g. for null array slices) and we are not allocating the object
885 here anyway. */
897 /* If this is an object with no specified size and alignment, and
898 if either it is full access or we are not optimizing alignment for
899 space and it is composite and not an exception, an Out parameter
900 or a reference to another object, and the size of its type is a
901 constant, set the alignment to the smallest one which is not
902 smaller than the size, with an appropriate cap. */
912 && !imported_p
918 /* If the object is set to have atomic components, find the component
919 type and validate it.
921 ??? Note that we ignore Has_Volatile_Components on objects; it's
922 not at all clear what to do in that case. */
924 {
933 }
935 /* If this is an array allocated with its bounds, make a type that
936 includes the template. We will either allocate it or create a
937 variable of that type, see below. */
940 {
942 gnu_type
944 gnu_type,
947 debug_info_p);
948 }
950 /* ??? If this is an object of CW type initialized to a value, try to
951 ensure that the object is sufficient aligned for this value, but
952 without pessimizing the allocation. This is a kludge necessary
953 because we don't support dynamic alignment. */
960 #ifdef MINIMUM_ATOMIC_ALIGNMENT
961 /* If the size is a constant and no alignment is specified, force
962 the alignment to be the minimum valid atomic alignment. The
963 restriction on constant size avoids problems with variable-size
964 temporaries; if the size is variable, there's no issue with
965 atomic access. Also don't do this for a constant, since it isn't
966 necessary and can interfere with constant replacement. Finally,
967 do not do it for Out parameters since that creates an
968 size inconsistency with In parameters. */
978 #endif
980 /* Do not take into account aliased adjustments or alignment promotions
981 to compute the size of the object. */
984 /* If the object is aliased, of a constrained nominal subtype and its
985 size might be zero at run time, we force at least the unit size. */
993 /* Make a new type with the desired size and alignment, if needed. */
995 {
1001 /* If the nominal subtype of the object is unconstrained and its
1002 size is not fixed, compute the Ada size from the Ada size of
1003 the subtype and/or the expression; this will make it possible
1004 for gnat_type_max_size to easily compute a maximum size. */
1008 /* If a padding record was made, declare it now since it will
1009 never be declared otherwise. This is necessary to ensure
1010 that its subtrees are properly marked. */
1014 }
1016 /* Now check if the type of the object allows atomic access. */
1020 /* If this is a renaming, avoid as much as possible to create a new
1021 object. However, in some cases, creating it is required because
1022 renaming can be applied to objects that are not names in Ada.
1023 This processing needs to be applied to the raw expression so as
1024 to make it more likely to rename the underlying object. */
1026 {
1027 /* If the renamed object had padding, strip off the reference to
1028 the inner object and reset our type. */
1031 /* Strip useless conversions around the object. */
1033 {
1036 }
1038 /* Or else, if the renamed object has an unconstrained type with
1039 default discriminant, use the padded type. */
1043 /* If this is a constant renaming stemming from a function call,
1044 treat it as a normal object whose initial value is what is being
1045 renamed. RM 3.3 says that the result of evaluating a function
1046 call is a constant object. Therefore, it can be the inner
1047 object of a constant renaming and the renaming must be fully
1048 instantiated, i.e. it cannot be a reference to (part of) an
1049 existing object. And treat other rvalues the same way. */
1053 /* Expand_Dispatching_Call can prepend a comparison of the tags
1054 before the call to "=". */
1065 /* We need to detect the case where a temporary is created to
1066 hold the return value, since we cannot safely rename it at
1067 top level because it lives only in the elaboration routine.
1068 But, at a lower level, an object initialized by a function
1069 call may be (implicitly) renamed as this temporary by the
1070 front-end and, in this case, we cannot make a copy. */
1074 /* We also need to detect the case where the front-end creates
1075 a dangling 'reference to a function call at top level and
1076 substitutes it in the renaming, for example:
1078 q__b : boolean renames r__f.e (1);
1080 can be rewritten into:
1082 q__R1s : constant q__A2s := r__f'reference;
1083 [...]
1084 q__b : boolean renames q__R1s.all.e (1);
1086 We cannot safely rename the rewritten expression since the
1087 underlying object lives only in the elaboration routine but,
1088 as above, this cannot be done at a lower level. */
1090 && (inner
1095 ;
1097 /* Otherwise, this is an lvalue being renamed, so it needs to be
1098 elaborated as a reference and substituted for the entity. But
1099 this means that we must evaluate the address of the renaming
1100 in the definition case to instantiate the SAVE_EXPRs. */
1101 else
1102 {
1108 gnu_expr
1112 /* No DECL_EXPR might be created so the expression needs to be
1113 marked manually because it will likely be shared. */
1117 /* This assertion will fail if the renamed object isn't aligned
1118 enough as to make it possible to honor the alignment set on
1119 the renaming. */
1121 {
1122 const unsigned int ralign
1127 }
1129 /* The expression might not be a DECL so save it manually. */
1135 /* If this is only a reference to the entity, we are done. */
1139 /* Otherwise, emit the initialization statement, if any. */
1143 /* If it needs to be materialized for debugging purposes, build
1144 the entity as indirect reference to the renamed object. */
1146 {
1147 /* If this is an array allocated with its bounds, we make
1148 its type a thin reference, the reference counterpart of
1149 a thin pointer, exactly as we would have done in the
1150 non-renaming case below. */
1153 {
1154 tree gnu_array
1157 }
1170 }
1172 /* Otherwise, instantiate the SAVE_EXPRs if needed. */
1177 }
1178 }
1180 /* If we are defining an aliased object whose nominal subtype is
1181 unconstrained, the object is a record that contains both the
1182 template and the object. If there is an initializer, it will
1183 have already been converted to the right type, but we need to
1184 create the template if there is no initializer. */
1186 && !gnu_expr
1189 /* Beware that padding might have been introduced above. */
1192 == RECORD_TYPE
1193 && TYPE_CONTAINS_TEMPLATE_P
1195 {
1196 tree template_field
1204 NULL_TREE);
1207 }
1209 /* Convert the expression to the type of the object if need be. */
1213 /* If this is a pointer that doesn't have an initializing expression,
1214 initialize it to NULL, unless the object is declared imported as
1215 per RM B.1(24). */
1218 && !gnu_expr
1222 /* If we are defining the object and it has an Address clause, we must
1223 either get the address expression from the saved GCC tree for the
1224 object if it has a Freeze node, or elaborate the address expression
1225 here since the front-end has guaranteed that the elaboration has no
1226 effects in this case. */
1228 {
1237 /* Convert the type of the object to a reference type that can
1238 alias everything as per RM 13.3(19). */
1241 gnu_type
1245 const_flag
1251 /* If this is an aliased object with an unconstrained array nominal
1252 subtype, then it can overlay only another aliased object with an
1253 unconstrained array nominal subtype and compatible template. */
1256 {
1260 /* This is the pattern built for a regular object. */
1265 /* This is the pattern built for an overaligned object. */
1268 == PLUS_EXPR
1271 gnu_address
1276 /* We make an exception for an absolute address but we warn
1277 that there is a descriptor at the start of the object. */
1279 {
1282 gnat_entity);
1285 }
1287 else
1288 {
1291 gnat_entity);
1294 }
1295 }
1297 /* If we don't have an initializing expression for the underlying
1298 variable, the initializing expression for the pointer is the
1299 specified address. Otherwise, we have to make a COMPOUND_EXPR
1300 to assign both the address and the initial value. */
1303 else
1304 gnu_expr
1308 NULL_TREE,
1309 gnu_address),
1310 gnu_expr),
1311 gnu_address);
1312 }
1314 /* If it has an address clause and we are not defining it, mark it
1315 as an indirect object. Likewise for Stdcall objects that are
1316 imported. */
1319 {
1320 /* Convert the type of the object to a reference type that can
1321 alias everything as per RM 13.3(19). */
1324 gnu_type
1331 /* No point in taking the address of an initializing expression
1332 that isn't going to be used. */
1335 /* If it has an address clause whose value is known at compile
1336 time, make the object a CONST_DECL. This will avoid a
1337 useless dereference. */
1339 {
1340 Node_Id gnat_address
1344 {
1347 }
1348 }
1349 }
1351 /* If we are at top level and this object is of variable size,
1352 make the actual type a hidden pointer to the real type and
1353 make the initializer be a memory allocation and initialization.
1354 Likewise for objects we aren't defining (presumed to be
1355 external references from other packages), but there we do
1356 not set up an initialization.
1358 If the object's size overflows, make an allocator too, so that
1359 Storage_Error gets raised. Note that we will never free
1360 such memory, so we presume it never will get allocated. */
1363 || !definition
1365 || (gnu_size
1367 size_binop
1369 bitsize_unit_node)),
1371 || !definition
1373 {
1382 /* In case this was a aliased object whose nominal subtype is
1383 unconstrained, the pointer above will be a thin pointer and
1384 build_allocator will automatically make the template.
1386 If we have a template initializer only (that we made above),
1387 pretend there is none and rely on what build_allocator creates
1388 again anyway. Otherwise (if we have a full initializer), get
1389 the data part and feed that to build_allocator.
1391 If we are elaborating a mutable object, tell build_allocator to
1392 ignore a possibly simpler size from the initializer, if any, as
1393 we must allocate the maximum possible size in this case. */
1395 {
1400 {
1401 gnu_alloc_type
1407 else
1408 gnu_expr
1409 = build_component_ref
1413 }
1418 gnat_entity);
1420 gnu_expr
1423 }
1424 else
1426 }
1428 /* If this object would go into the stack and has an alignment larger
1429 than the largest stack alignment the back-end can honor, resort to
1430 a variable of "aligning type". */
1433 && !imported_p
1434 && !static_flag
1436 {
1437 /* Create the new variable. No need for extra room before the
1438 aligned field as this is in automatic storage. */
1439 tree gnu_new_type
1443 tree gnu_new_var
1448 gnat_entity);
1450 /* Initialize the aligned field if we have an initializer. */
1452 add_stmt_with_node
1454 build_component_ref
1457 gnu_expr),
1458 gnat_entity);
1460 /* And setup this entity as a reference to the aligned field. */
1462 gnu_expr
1463 = build_unary_op
1473 }
1475 /* If this is an aggregate constant initialized to a constant, force it
1476 to be statically allocated. This saves an initialization copy. */
1478 && const_flag
1479 && gnu_expr
1488 /* If this is an array allocated with its bounds, we make its type a
1489 thin reference, i.e. the reference counterpart of a thin pointer,
1490 so that it points to the array part. This is aimed at making it
1491 easier for the debugger to decode the object. Note that we have
1492 to do it this late because of the couple of allocation adjustments
1493 that might be made above. */
1496 {
1497 /* In case the object with the template has already been allocated
1498 just above, we have nothing to do here. */
1500 {
1501 /* This variable is a GNAT encoding used by Workbench: let it
1502 go through the debugging information but mark it as
1503 artificial: users are not interested in it. */
1504 tree gnu_unc_var
1520 }
1523 gnu_type
1525 }
1527 /* Convert the expression to the type of the object if need be. */
1531 /* If this name is external or a name was specified, use it, but don't
1532 use the Interface_Name with an address clause (see cd30005). */
1538 /* Deal with a pragma Linker_Section on a constant or variable. */
1544 /* Now create the variable or the constant and set various flags. */
1545 gnu_decl
1551 gnat_entity);
1556 /* If we are defining an Out parameter and optimization isn't enabled,
1557 create a fake PARM_DECL for debugging purposes and make it point to
1558 the VAR_DECL. Suppress debug info for the latter but make sure it
1559 will live in memory so that it can be accessed from within the
1560 debugger through the PARM_DECL. */
1562 && definition
1563 && debug_info_p
1564 && !optimize
1566 {
1573 }
1575 /* If this is a loop parameter, set the corresponding flag. */
1579 /* If this is a constant and we are defining it or it generates a real
1580 symbol at the object level and we are referencing it, we may want
1581 or need to have a true variable to represent it:
1582 - if the constant is public and not overlaid on something else,
1583 - if its address is taken,
1584 - if it is aliased,
1585 - if optimization isn't enabled, for debugging purposes. */
1592 {
1593 tree gnu_corr_var
1602 }
1604 /* If this is a constant, even if we don't need a true variable, we
1605 may need to avoid returning the initializer in every case. That
1606 can happen for the address of a (constant) constructor because,
1607 upon dereferencing it, the constructor will be reinjected in the
1608 tree, which may not be valid in every case; see lvalue_required_p
1609 for more details. */
1613 /* If this is a local variable with non-BLKmode and aggregate type,
1614 and optimization isn't enabled, then force it in memory so that
1615 a register won't be allocated to it with possible subparts left
1616 uninitialized and reaching the register allocator. */
1626 /* Back-annotate Esize and Alignment of the object if not already
1627 known. Note that we pick the values of the type, not those of
1628 the object, to shield ourselves from low-level platform-dependent
1629 adjustments like alignment promotion. This is both consistent with
1630 all the treatment above, where alignment and size are set on the
1631 type of the object and not on the object directly, and makes it
1632 possible to support all confirming representation clauses. */
1634 used_by_ref);
1635 }
1639 /* Return a TYPE_DECL for "void" that we previously made. */
1644 /* A special case: for the types Character and Wide_Character in
1645 Standard, we do not list all the literals. So if the literals
1646 are not specified, make this an integer type. */
1648 {
1651 else
1655 /* Set TYPE_STRING_FLAG for Character and Wide_Character types.
1656 This is needed by the DWARF-2 back-end to distinguish between
1657 unsigned integer types and character types. */
1660 /* This flag is needed by the call just below. */
1664 }
1665 else
1666 {
1667 /* We have a list of enumeral constants in First_Literal. We make a
1668 CONST_DECL for each one and build into GNU_LITERAL_LIST the list
1669 to be placed into TYPE_FIELDS. Each node is itself a TREE_LIST
1670 whose TREE_VALUE is the literal name and whose TREE_PURPOSE is the
1671 value of the literal. But when we have a regular boolean type, we
1672 simplify this a little by using a BOOLEAN_TYPE. */
1677 Entity_Id gnat_literal;
1679 /* Boolean types with foreign convention have precision 1. */
1694 {
1695 tree gnu_value
1697 /* Do not generate debug info for individual enumerators. */
1698 tree gnu_literal
1704 gnu_list
1706 }
1711 /* Note that the bounds are updated at the end of this function
1712 to avoid an infinite recursion since they refer to the type. */
1714 }
1718 /* For integer types, just make a signed type the appropriate number
1719 of bits. */
1725 {
1726 /* Small_Value is the scale factor. */
1732 /* When encoded as 1/2**N or 1/10**N, describe the scale factor as a
1733 binary or decimal scale: it is easier to read for humans. */
1737 {
1738 tree base
1740 tree exponent
1743 scale_factor
1745 integer_one_node,
1748 }
1750 /* Use the arbitrary scale factor description. Note that we support
1751 a Small_Value whose magnitude is larger than 64-bit even on 32-bit
1752 platforms, so we unconditionally use a (dummy) 128-bit type. */
1753 else
1754 {
1761 scale_factor
1763 }
1767 }
1771 {
1772 /* Packed Array Impl. Types are supposed to be subtypes only. */
1775 /* For modular types, make the unsigned type of the proper number
1776 of bits and then set up the modulus, if required. */
1779 /* Get the modulus in this type. If the modulus overflows, assume
1780 that this is because it was equal to 2**Esize. Note that there
1781 is no overflow checking done on unsigned types, so we detect the
1782 overflow by looking for a modulus of zero, which is invalid. */
1785 /* If the modulus is not 2**Esize, then this also means that the upper
1786 bound of the type, i.e. modulus - 1, is not maximal, so we create an
1787 extra subtype to carry it and set the modulus on the base type. */
1789 {
1795 gnu_type
1797 gnu_high);
1798 }
1799 }
1811 /* For integral subtypes, we make a new INTEGER_TYPE. Note that we do
1812 not want to call create_range_type since we would like each subtype
1813 node to be distinct. ??? Historically this was in preparation for
1814 when memory aliasing is implemented, but that's obsolete now given
1815 the call to relate_alias_sets below.
1817 The TREE_TYPE field of the INTEGER_TYPE points to the base type;
1818 this fact is used by the arithmetic conversion functions.
1820 We elaborate the Ancestor_Subtype if it is not in the current unit
1821 and one of our bounds is non-static. We do this to ensure consistent
1822 naming in the case where several subtypes share the same bounds, by
1823 elaborating the first such subtype first, thus using its name. */
1832 /* Set the precision to the Esize except for bit-packed arrays. */
1836 /* Boolean types with foreign convention have precision 1. */
1838 {
1844 }
1845 /* First subtypes of Character are treated as Character; otherwise
1846 this should be an unsigned type if the base type is unsigned or
1847 if the lower bound is constant and non-negative or if the type
1848 is biased. However, even if the lower bound is constant and
1849 non-negative, we use a signed type for a subtype with the same
1850 size as its signed base type, because this eliminates useless
1851 conversions to it and gives more leeway to the optimizer; but
1852 this means that we will need to explicitly test for this case
1853 when we change the representation based on the RM size. */
1865 else
1869 SET_TYPE_RM_MIN_VALUE
1872 debug_info_p));
1874 SET_TYPE_RM_MAX_VALUE
1877 debug_info_p));
1883 /* Do the same processing for Character subtypes as for types. */
1886 {
1891 }
1893 /* Inherit our alias set from what we're a subtype of. Subtypes
1894 are not different types and a pointer can designate any instance
1895 within a subtype hierarchy. */
1898 /* One of the above calls might have caused us to be elaborated,
1899 so don't blow up if so. */
1901 {
1904 }
1906 /* Attach the TYPE_STUB_DECL in case we have a parallel type. */
1910 discrete_type:
1912 /* We have to handle clauses that under-align the type specially. */
1915 && Present
1918 {
1922 }
1924 /* If the type we are dealing with represents a bit-packed array,
1925 we need to have the bits left justified on big-endian targets
1926 and right justified on little-endian targets. We also need to
1927 ensure that when the value is read (e.g. for comparison of two
1928 such values), we only get the good bits, since the unused bits
1929 are uninitialized. Both goals are accomplished by wrapping up
1930 the modular type in an enclosing record type. */
1932 {
1938 /* Make the original array type a parallel/debug type. */
1940 {
1941 tree gnu_name
1943 gnat_entity);
1946 }
1948 /* Set the RM size before wrapping up the original type. */
1952 /* Create a stripped-down declaration, mainly for debugging. */
1954 gnat_entity);
1956 /* Now save it and build the enclosing record type. */
1966 /* Propagate the alignment of the modular type to the record type,
1967 unless there is an alignment clause that under-aligns the type.
1968 This means that bit-packed arrays are given "ceil" alignment for
1969 their size by default, which may seem counter-intuitive but makes
1970 it possible to overlay them on modular types easily. */
1974 /* Propagate the reverse storage order flag to the record type so
1975 that the required byte swapping is performed when retrieving the
1976 enclosed modular value. */
1982 /* Don't declare the field as addressable since we won't be taking
1983 its address and this would prevent create_field_decl from making
1984 a bitfield. */
1985 gnu_field
1989 /* We will output additional debug info manually below. */
1993 /* Make the original array type a parallel/debug type. Note that
1994 gnat_get_array_descr_info needs a TYPE_IMPL_PACKED_ARRAY_P type
1995 so we use an intermediate step for standard DWARF. */
1997 {
2002 }
2003 }
2005 /* If the type we are dealing with has got a smaller alignment than the
2006 natural one, we need to wrap it up in a record type and misalign the
2007 latter; we reuse the padding machinery for this purpose. */
2009 {
2012 /* Set the RM size before wrapping the type. */
2015 /* Create a stripped-down declaration, mainly for debugging. */
2017 gnat_entity);
2019 gnu_type
2025 }
2030 /* The type of the Low and High bounds can be our type if this is
2031 a type from Standard, so set them at the end of the function. */
2042 /* See the E_Signed_Integer_Subtype case for the rationale. */
2059 SET_TYPE_RM_MIN_VALUE
2062 debug_info_p));
2064 SET_TYPE_RM_MAX_VALUE
2067 debug_info_p));
2069 /* Inherit our alias set from what we're a subtype of, as for
2070 integer subtypes. */
2073 /* One of the above calls might have caused us to be elaborated,
2074 so don't blow up if so. */
2078 /* Array Types and Subtypes
2080 In GNAT unconstrained array types are represented by E_Array_Type and
2081 constrained array types are represented by E_Array_Subtype. They are
2082 translated into UNCONSTRAINED_ARRAY_TYPE and ARRAY_TYPE respectively.
2083 But there are no actual objects of an unconstrained array type; all we
2084 have are pointers to that type. In addition to the type node itself,
2085 4 other types associated with it are built in the process:
2087 1. the array type (suffix XUA) containing the actual data,
2089 2. the template type (suffix XUB) containng the bounds,
2091 3. the fat pointer type (suffix XUP) representing a pointer or a
2092 reference to the unconstrained array type:
2093 XUP = struct { XUA *, XUB * }
2095 4. the object record type (suffix XUT) containing bounds and data:
2096 XUT = struct { XUB, XUA }
2098 The bounds of the array type XUA (de)reference the XUB * field of a
2099 PLACEHOLDER_EXPR for the fat pointer type XUP, so the array type XUA
2100 is to be interpreted in the context of the fat pointer type XUB for
2101 debug info purposes. */
2104 {
2106 const bool convention_fortran_p
2115 Entity_Id gnat_index;
2119 /* Create the type for the component now, as it simplifies breaking
2120 type reference loops. */
2121 comp_type
2124 {
2125 /* As a side effect, the type may have been translated. */
2128 }
2130 /* We complete an existing dummy fat pointer type in place. This both
2131 avoids further complex adjustments in update_pointer_to and yields
2132 better debugging information in DWARF by leveraging the support for
2133 incomplete declarations of "tagged" types in the DWARF back-end. */
2136 {
2139 gnu_ptr_template =
2143 /* Save the contents of the dummy type for update_pointer_to. */
2149 }
2150 else
2151 {
2155 }
2157 /* Make a node for the array. If we are not defining the array
2158 suppress expanding incomplete types. */
2161 /* The component may refer to this type, so defer completion of any
2162 incomplete types. */
2164 {
2165 defer_incomplete_level++;
2167 }
2169 /* Build the fat pointer type. Use a "void *" object instead of
2170 a pointer to the array type since we don't have the array type
2171 yet (it will reference the fat pointer via the bounds). Note
2172 that we reuse the existing fields of a dummy type because for:
2174 type Arr is array (Positive range <>) of Element_Type;
2175 type Array_Ref is access Arr;
2176 Var : Array_Ref := Null;
2178 in a declarative part, Arr will be frozen only after Var, which
2179 means that the fields used in the CONSTRUCTOR built for Null are
2180 those of the dummy type, which in turn means that COMPONENT_REFs
2181 of Var may be built with these fields. Now if COMPONENT_REFs of
2182 Var are also built later with the fields of the final type, the
2183 aliasing machinery may consider that the accesses are distinct
2184 if the FIELD_DECLs are distinct as objects. */
2186 {
2195 }
2196 else
2197 {
2198 /* We make the fields addressable for the sake of compatibility
2199 with languages for which the regular fields are addressable. */
2200 tem
2210 }
2212 /* If the GNAT encodings are used, give the fat pointer type a name.
2213 If this is a packed type implemented specially, tell the debugger
2214 how to interpret the underlying bits by fetching the name of the
2215 implementation type. But, in any case, mark it as artificial so
2216 the debugger can skip it. */
2217 const Entity_Id gnat_name
2219 ? PAT
2221 tree xup_name
2226 gnat_entity);
2228 /* Build a reference to the template from a PLACEHOLDER_EXPR that
2229 is the fat pointer. This will be used to access the individual
2230 fields once we build them. */
2234 gnu_template_reference
2239 /* Now create the GCC type for each index and add the fields for that
2240 index to the template. */
2246 {
2248 const bool is_flb
2258 /* Update the maximum size of the array in elements. */
2260 gnu_max_size
2263 /* Now build the self-referential bounds of the index type. */
2267 /* Make the FIELD_DECLs for the low and high bounds of this
2268 type and then make extractions of these fields from the
2269 template. */
2272 gnu_index_type,
2275 /* Mark the field specifically for INSTANTIATE_LOAD_IN_EXPR. */
2282 gnu_index_type,
2285 /* Mark the field specifically for INSTANTIATE_LOAD_IN_EXPR. */
2292 /* We can't use build_component_ref here since the template type
2293 isn't complete yet. */
2295 {
2298 NULL_TREE);
2300 }
2304 NULL_TREE);
2310 /* Compute the size of this dimension. See the E_Array_Subtype
2311 case below for the rationale. */
2317 else
2318 gnu_high
2322 gnu_max,
2327 /* Make a range type with the new range in the Ada base type.
2328 Then make an index type with the size range in sizetype. */
2332 gnu_orig_min,
2333 gnu_orig_max),
2334 gnat_entity);
2338 }
2340 /* Install all the fields into the template. */
2345 gnu_template_fields
2348 debug_info_p);
2351 /* If Component_Size is not already specified, annotate it with the
2352 size of the component. */
2357 /* Compute the maximum size of the array in units. */
2359 gnu_max_size
2362 /* Now build the array type. */
2365 {
2373 }
2375 /* If this is a packed type implemented specially, then process the
2376 implementation type so it is elaborated in the proper scope. */
2380 /* Otherwise, if an alignment is specified, use it if valid and, if
2381 the alignment was requested with an explicit clause, state so. */
2383 {
2386 gnat_entity,
2390 }
2392 /* Tag top-level ARRAY_TYPE nodes for packed arrays and their
2393 implementation types as such so that the debug information back-end
2394 can output the appropriate description for them. */
2407 /* Adjust the type of the pointer-to-array field of the fat pointer
2408 and preserve its existing alias set, if any. Note that calling
2409 again record_component_aliases on the fat pointer is not enough
2410 because this may leave dangling references to the existing alias
2411 set from types containing a fat pointer component. If this is
2412 a packed type implemented specially, then use a ref-all pointer
2413 type since the implementation type may vary between constrained
2414 subtypes and unconstrained base type. */
2418 else
2423 /* If the maximum size doesn't overflow, use it. */
2430 /* See the above description for the rationale. */
2436 /* Create the type to be designated by thin pointers: a record type for
2437 the array and its template. We used to shift the fields to have the
2438 template at a negative offset, but this was somewhat of a kludge; we
2439 now shift thin pointer values explicitly but only those which have a
2440 TYPE_UNCONSTRAINED_ARRAY attached to the designated RECORD_TYPE.
2441 If the GNAT encodings are used, give it a name. */
2442 tree xut_name
2447 debug_info_p);
2452 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
2453 corresponding fat pointer. */
2459 }
2467 /* This is the actual data type for array variables. Multidimensional
2468 arrays are implemented as arrays of arrays. Note that arrays which
2469 have sparse enumeration subtypes as index components create sparse
2470 arrays, which is obviously space inefficient but so much easier to
2471 code for now.
2473 Also note that the subtype never refers to the unconstrained array
2474 type, which is somewhat at variance with Ada semantics.
2476 First check to see if this is simply a renaming of the array type.
2477 If so, the result is the array type. */
2481 ;
2482 else
2483 {
2486 const bool convention_fortran_p
2496 /* First create the GCC type for each index and find out whether
2497 special types are needed for debugging information. */
2500 gnat_base_index
2506 {
2512 tree gnu_base_index_type
2518 /* We try to create subtypes for discriminants used as bounds
2519 that are more restrictive than those declared, by using the
2520 bounds of the index type of the base array type. This will
2521 make it possible to calculate the maximum size of the record
2522 type more conservatively. This may have already been done by
2523 the front-end (Exp_Ch3.Adjust_Discriminants), in which case
2524 there will be a conversion that needs to be removed first. */
2529 {
2533 gnu_base_orig_min,
2534 gnu_base_orig_max);
2535 }
2541 {
2545 gnu_base_orig_min,
2546 gnu_base_orig_max);
2547 }
2549 /* Update the maximum size of the array in elements. Here we
2550 see if any constraint on the index type of the base type
2551 can be used in the case of self-referential bounds on the
2552 index type of the array type. We look for a non-"infinite"
2553 and non-self-referential bound from any type involved and
2554 handle each bound separately. */
2556 {
2559 else
2566 {
2571 }
2579 else
2586 {
2591 }
2597 gnu_max_size
2599 }
2601 /* Convert the bounds to the base type for consistency below. */
2609 /* See if the base array type is already flat. If it is, we
2610 are probably compiling an ACATS test but it will cause the
2611 code below to malfunction if we don't handle it specially. */
2615 {
2619 }
2621 /* Similarly, if one of the values overflows in sizetype and the
2622 range is null, use 1..0 for the sizetype bounds. */
2627 {
2631 }
2633 /* If the minimum and maximum values both overflow in sizetype,
2634 but the difference in the original type does not overflow in
2635 sizetype, ignore the overflow indication. */
2639 && !TREE_OVERFLOW
2642 gnu_index_base_type,
2643 gnu_orig_max,
2644 gnu_orig_min))))
2645 {
2649 }
2651 /* Compute the size of this dimension in the general case. We
2652 need to provide GCC with an upper bound to use but have to
2653 deal with the "superflat" case. There are three ways to do
2654 this. If we can prove that the array can never be superflat,
2655 we can just use the high bound of the index type. */
2658 /* Bit-Packed Array Impl. Types are never superflat. */
2660 && Is_Bit_Packed_Array
2664 /* Otherwise, if the high bound is constant but the low bound is
2665 not, we use the expression (hb >= lb) ? lb : hb + 1 for the
2666 lower bound. Note that the comparison must be done in the
2667 original type to avoid any overflow during the conversion. */
2670 {
2672 gnu_min
2675 boolean_type_node,
2676 gnu_orig_max,
2677 gnu_orig_min),
2678 gnu_min,
2680 size_one_node));
2681 }
2683 /* Finally we use (hb >= lb) ? hb : lb - 1 for the upper bound
2684 in all the other cases. Note that we use int_const_binop for
2685 the shift by 1 if the bound is constant to avoid any unwanted
2686 overflow. */
2687 else
2688 gnu_high
2691 boolean_type_node,
2692 gnu_orig_max,
2693 gnu_orig_min),
2694 gnu_max,
2697 size_one_node)
2699 size_one_node));
2701 /* Reuse the index type for the range type. Then make an index
2702 type with the size range in sizetype. */
2705 gnat_entity);
2707 /* Record whether the range is known to be null at compile time
2708 to disambiguate it from too large ranges. */
2714 /* We need special types for debugging information to point to
2715 the index types if they have variable bounds, are not integer
2716 types, are biased or are wider than sizetype. These are GNAT
2717 encodings, so we have to include them only when all encodings
2718 are requested. */
2728 }
2730 /* Then flatten: create the array of arrays. For an array type
2731 used to implement a packed array, get the component type from
2732 the original array type since the representation clauses that
2733 can affect it are on the latter. */
2736 {
2741 /* One of the above calls might have caused us to be elaborated,
2742 so don't blow up if so. */
2744 {
2747 }
2748 }
2749 else
2750 {
2752 debug_info_p);
2754 /* One of the above calls might have caused us to be elaborated,
2755 so don't blow up if so. */
2757 {
2760 }
2761 }
2763 /* Compute the maximum size of the array in units. */
2765 gnu_max_size
2768 /* Now build the array type. */
2770 {
2780 /* Clear the TREE_OVERFLOW flag, if any, for null arrays. */
2782 {
2785 }
2787 /* Kludge to clear the TREE_OVERFLOW flag for the sake of LTO
2788 on maximally-sized array types designed by access types. */
2798 {
2801 }
2802 }
2804 /* Attach the TYPE_STUB_DECL in case we have a parallel type. */
2808 /* If this is a multi-dimensional array and we are at global level,
2809 we need to make a variable corresponding to the stride of the
2810 inner dimensions. */
2812 {
2813 tree gnu_arr_type;
2818 {
2828 /* ??? For now, store the size as a multiple of the
2829 alignment of the element type in bytes so that we
2830 can see the alignment from the tree. */
2838 /* ??? create_type_decl is not invoked on the inner types so
2839 the MULT_EXPR node built above will never be marked. */
2841 }
2842 }
2844 /* Set the TYPE_PACKED flag on packed array types and also on their
2845 implementation types, so that the DWARF back-end can output the
2846 appropriate description for them. */
2856 /* If the maximum size doesn't overflow, use it. */
2863 /* If we need to write out a record type giving the names of the
2864 bounds for debugging purposes, do it now and make the record
2865 type a parallel type. This is not needed for a packed array
2866 since the bounds are conveyed by the original array type. */
2868 && debug_info_p
2870 {
2873 tree gnu_field;
2879 {
2883 /* Make sure to reference the types themselves, and not just
2884 their names, as the debugger may fall back on them. */
2890 }
2894 }
2896 /* If this is a packed array type, make the original array type a
2897 parallel/debug type. Otherwise, if GNAT encodings are used, do
2898 it for the base array type if it is not artificial to make sure
2899 that it is kept in the debug info. */
2901 {
2903 {
2904 tree gnu_name
2906 gnat_entity);
2909 }
2912 {
2913 tree gnu_base_decl
2920 }
2921 }
2923 /* Set our alias set to that of our base type. This gives all
2924 array subtypes the same alias set. */
2927 /* If this is a packed type implemented specially, then replace our
2928 type with the implementation type. */
2930 {
2931 /* First finish the type we had been making so that we output
2932 debugging information for it. */
2935 {
2936 const int quals
2937 = TYPE_QUAL_VOLATILE
2940 }
2941 /* Make it artificial only if the base type was artificial too.
2942 That's sort of "morally" true and will make it possible for
2943 the debugger to look it up by name in DWARF, which is needed
2944 in order to decode the packed array type. */
2945 tree gnu_tmp_decl
2949 gnat_entity);
2950 /* Save it as our equivalent in case the call below elaborates
2951 this type again. */
2957 /* Set the ___XP suffix for GNAT encodings. */
2967 /* We need to attach the index type to the type we just made so
2968 that the actual bounds can later be put into a template. */
2973 {
2975 {
2976 /* The TYPE_ACTUAL_BOUNDS field is overloaded with the
2977 TYPE_MODULUS for modular types so we make an extra
2978 subtype if necessary. */
2980 gnu_inner
2987 /* Check for other cases of overloading. */
2989 }
2994 SET_TYPE_ACTUAL_BOUNDS
3001 SET_TYPE_ACTUAL_BOUNDS
3007 }
3008 }
3010 /* Otherwise, if an alignment is specified, use it if valid and, if
3011 the alignment was requested with an explicit clause, state so. */
3013 {
3016 gnat_entity,
3020 }
3021 }
3025 /* Create the type for a string literal. */
3026 {
3027 Entity_Id gnat_full_type
3032 tree gnu_string_array_type
3034 tree gnu_string_index_type
3037 tree gnu_lower_bound
3040 tree gnu_length
3042 gnu_string_index_type);
3043 tree gnu_upper_bound
3045 gnu_lower_bound,
3048 integer_one_node)));
3049 tree gnu_index_type
3053 gnu_lower_bound,
3054 gnu_upper_bound),
3055 gnat_entity);
3057 gnu_type
3060 gnu_index_type);
3064 }
3067 /* Record Types and Subtypes
3069 A record type definition is transformed into the equivalent of a C
3070 struct definition. The fields that are the discriminants which are
3071 found in the Full_Type_Declaration node and the elements of the
3072 Component_List found in the Record_Type_Definition node. The
3073 Component_List can be a recursive structure since each Variant of
3074 the Variant_Part of the Component_List has a Component_List.
3076 Processing of a record type definition comprises starting the list of
3077 field declarations here from the discriminants and the calling the
3078 function components_to_record to add the rest of the fields from the
3079 component list and return the gnu type node. The function
3080 components_to_record will call itself recursively as it traverses
3081 the tree. */
3084 {
3088 {
3089 const Node_Id first_component
3091 tree gnu_component_type
3095 }
3097 Node_Id gnat_constr;
3100 tree gnu_get_parent;
3101 /* Set PACKED in keeping with gnat_to_gnu_field. */
3102 const int packed
3110 const bool is_extension
3113 const bool has_rep
3114 = is_extension
3120 /* See if all fields have a rep clause. Stop when we find one
3121 that doesn't. */
3130 {
3133 }
3135 /* If this is a record extension, go a level further to find the
3136 record definition. Also, verify we have a Parent_Subtype. */
3138 {
3145 }
3147 /* Make a node for the record type. */
3154 /* If the record type has discriminants, pointers to it may also point
3155 to constrained subtypes of it, so mark it as may_alias for LTO. */
3157 prepend_one_attribute
3160 gnat_entity);
3164 /* Some component may refer to this type, so defer completion of any
3165 incomplete types. */
3167 {
3168 defer_incomplete_level++;
3170 }
3172 /* If both a size and rep clause were specified, put the size on
3173 the record type now so that it can get the proper layout. */
3178 /* Always set the alignment on the record type here so that it can
3179 get the proper layout. */
3184 else
3185 {
3188 /* If a type needs strict alignment, then its type size will also
3189 be the RM size (see below). Cap the alignment if needed, lest
3190 it may cause this type size to become too large. */
3192 {
3197 }
3199 /* Similarly if an Object_Size clause has been specified. */
3201 {
3206 }
3207 }
3209 /* If we have a Parent_Subtype, make a field for the parent. If
3210 this record has rep clauses, force the position to zero. */
3212 {
3215 tree gnu_parent;
3218 /* A major complexity here is that the parent subtype will
3219 reference our discriminants in its Stored_Constraint list.
3220 But those must reference the parent component of this record
3221 which is precisely of the parent subtype we have not built yet!
3222 To break the circle we first build a dummy COMPONENT_REF which
3223 represents the "get to the parent" operation and initialize
3224 each of those discriminants to a COMPONENT_REF of the above
3225 dummy parent referencing the corresponding discriminant of the
3226 base type of the parent subtype. */
3231 gnu_dummy_parent_type),
3232 NULL_TREE);
3239 {
3240 tree gnu_field
3243 save_gnu_tree
3248 }
3250 /* Then we build the parent subtype. If it has discriminants but
3251 the type itself has unknown discriminants, this means that it
3252 doesn't contain information about how the discriminants are
3253 derived from those of the ancestor type, so it cannot be used
3254 directly. Instead it is built by cloning the parent subtype
3255 of the underlying record view of the type, for which the above
3256 derivation of discriminants has been made explicit. */
3259 {
3262 /* If we are defining the type, the underlying record
3263 view must already have been elaborated at this point.
3264 Otherwise do it now as its parent subtype cannot be
3265 technically elaborated on its own. */
3268 else
3273 /* Substitute the "get to the parent" of the type for that
3274 of its underlying record view in the cloned type. */
3279 {
3281 tree gnu_ref
3284 gnu_parent
3286 }
3287 }
3288 else
3291 /* The parent field needs strict alignment so, if it is to
3292 be created with a component clause below, then we need
3293 to apply the same adjustment as in gnat_to_gnu_field. */
3295 {
3296 /* ??? For historical reasons, we do it on strict-alignment
3297 platforms only, where it is really required. This means
3298 that a confirming representation clause will change the
3299 behavior of the compiler on the other platforms. */
3302 else
3303 parent_packed
3305 }
3307 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
3308 initially built. The discriminants must reference the fields
3309 of the parent subtype and not those of its base type for the
3310 placeholder machinery to properly work. */
3312 {
3313 /* The actual parent subtype is the full view. */
3315 {
3318 else
3320 }
3326 {
3327 Entity_Id field;
3336 }
3337 }
3339 /* The "get to the parent" COMPONENT_REF must be given its
3340 proper type... */
3343 /* ...and reference the _Parent field of this record. */
3344 gnu_field
3347 has_rep
3349 has_rep
3355 }
3357 /* Make the fields for the discriminants and put them into the record
3358 unless it's an Unchecked_Union. */
3363 {
3364 /* If this is a record extension and this discriminant is the
3365 renaming of another discriminant, we've handled it above. */
3370 gnu_field
3372 debug_info_p);
3374 /* Make an expression using a PLACEHOLDER_EXPR from the
3375 FIELD_DECL node just created and link that with the
3376 corresponding GNAT defining identifier. */
3384 {
3387 }
3388 }
3390 /* If we have a derived untagged type that renames discriminants in
3391 the parent type, the (stored) discriminants are just a copy of the
3392 discriminants of the parent type. This means that any constraints
3393 added by the renaming in the derivation are disregarded as far as
3394 the layout of the derived type is concerned. To rescue them, we
3395 change the type of the (stored) discriminants to a subtype with
3396 the bounds of the type of the visible discriminants. */
3398 && !is_extension
3404 /* Ignore access discriminants. */
3407 {
3410 tree gnu_ref
3414 /* GNU_REF must be an expression using a PLACEHOLDER_EXPR built
3415 just above for one of the stored discriminants. */
3423 }
3425 /* If this is a derived type with discriminants and these discriminants
3426 affect the initial shape it has inherited, factor them in. */
3428 && !is_extension
3436 {
3437 tree gnu_parent_type
3446 /* Set the layout of the type to match that of the parent type,
3447 doing required substitutions. Note that, if we do not use the
3448 GNAT encodings, we don't need debug info for the inner record
3449 types, as they will be part of the embedding variant record's
3450 debug info. */
3451 copy_and_substitute_in_layout
3453 gnu_subst_list,
3455 }
3456 else
3457 {
3458 /* Add the fields into the record type and finish it up. */
3465 NULL);
3467 /* Empty classes have the size of a storage unit in C++. */
3470 {
3474 }
3476 /* If the type needs strict alignment, then no object of the type
3477 may have a size smaller than the natural size, which means that
3478 the RM size of the type is equal to the type size. */
3482 /* If there are entities in the chain corresponding to components
3483 that we did not elaborate, ensure we elaborate their types if
3484 they are itypes. */
3493 }
3495 /* Fill in locations of fields. */
3497 }
3501 /* If an equivalent type is present, that is what we should use.
3502 Otherwise, fall through to handle this like a record subtype
3503 since it may have constraints. */
3505 {
3509 }
3511 /* ... fall through ... */
3518 /* Otherwise, first ensure the base type is elaborated. Then, if we are
3519 changing the type, make a new type with each field having the type of
3520 the field in the new subtype but the position computed by transforming
3521 every discriminant reference according to the constraints. We don't
3522 see any difference between private and non-private type here since
3523 derivations from types should have been deferred until the completion
3524 of the private type. */
3525 else
3526 {
3529 /* Some component may refer to this type, so defer completion of any
3530 incomplete types. We also need to do it for the special subtypes
3531 designated by access subtypes in case they are recursive, see the
3532 E_Access_Subtype case below. */
3537 {
3538 defer_incomplete_level++;
3540 }
3542 tree gnu_base_type
3546 {
3549 }
3551 /* When the subtype has discriminants and these discriminants affect
3552 the initial shape it has inherited, factor them in. But for an
3553 Unchecked_Union (it must be an itype), just return the type. */
3558 {
3561 tree gnu_unpad_base_type;
3570 /* Set the size, alignment and alias set of the type to match
3571 those of the base type, doing required substitutions. */
3573 gnu_subst_list);
3577 else
3580 /* Set the layout of the type to match that of the base type,
3581 doing required substitutions. We will output debug info
3582 manually below so pass false as last argument. */
3587 /* Fill in locations of fields. */
3590 /* If debugging information is being written for the type and if
3591 we are asked to output GNAT encodings, write a record that
3592 shows what we are a subtype of and also make a variable that
3593 indicates our size, if still variable. */
3596 {
3598 tree gnu_unpad_base_name
3606 build_reference_type
3608 gnu_subtype_marker,
3624 }
3626 /* Or else, if the subtype is artificial and GNAT encodings are
3627 not used, use the base record type as the debug type. */
3629 && artificial_p
3632 }
3634 /* Otherwise, go down all the components in the new type and make
3635 them equivalent to those in the base type. */
3636 else
3637 {
3647 gnat_to_gnu_field_decl
3650 }
3651 }
3656 /* Use the special descriptor type for dispatch tables if needed,
3657 that is to say for the Prim_Ptr of a-tags.ads and its clones.
3658 Note that we are only required to do so for static tables in
3659 order to be compatible with the C++ ABI, but Ada 2005 allows
3660 to extend library level tagged types at the local level so
3661 we do it in the non-static case as well. */
3664 {
3668 }
3670 /* ... fall through ... */
3677 {
3678 /* The designated type and its equivalent type for gigi. */
3681 /* Whether it comes from a limited with. */
3682 const bool is_from_limited_with
3685 /* Whether it is a completed Taft Amendment type. Such a type is to
3686 be treated as coming from a limited with clause if it is not in
3687 the main unit, i.e. we break potential circularities here in case
3688 the body of an external unit is loaded for inter-unit inlining. */
3689 const bool is_completed_taft_type
3693 /* The "full view" of the designated type. If this is an incomplete
3694 entity from a limited with, treat its non-limited view as the full
3695 view. Otherwise, if this is an incomplete or private type, use the
3696 full view. In the former case, we might point to a private type,
3697 in which case, we need its full view. Also, we want to look at the
3698 actual type used for the representation, so this takes a total of
3699 three steps. */
3700 Entity_Id gnat_desig_full_direct_first
3701 = (is_from_limited_with
3705 Entity_Id gnat_desig_full_direct
3706 = ((is_from_limited_with
3711 Entity_Id gnat_desig_full
3713 /* The type actually used to represent the designated type, either
3714 gnat_desig_full or gnat_desig_equiv. */
3715 Entity_Id gnat_desig_rep;
3716 /* We want to know if we'll be seeing the freeze node for any
3717 incomplete type we may be pointing to. */
3718 const bool in_main_unit
3722 /* True if we make a dummy type here. */
3724 /* The mode to be used for the pointer type. */
3725 scalar_int_mode p_mode;
3726 /* The GCC type used for the designated type. */
3733 /* If either the designated type or its full view is an unconstrained
3734 array subtype, replace it with the type it's a subtype of. This
3735 avoids problems with multiple copies of unconstrained array types.
3736 Likewise, if the designated type is a subtype of an incomplete
3737 record type, use the parent type to avoid order of elaboration
3738 issues. This can lose some code efficiency, but there is no
3739 alternative. */
3750 /* Set the type that's the representation of the designated type. */
3751 gnat_desig_rep
3754 /* If we already know what the full type is, use it. */
3758 /* Get the type of the thing we are to point to and build a pointer to
3759 it. If it is a reference to an incomplete or private type with a
3760 full view that is a record, an array or an access, make a dummy type
3761 and get the actual type later when we have verified it is safe. */
3768 /* Likewise if this is a reference to a record, an array or a
3769 subprogram type and we are to defer elaborating incomplete
3770 types. We do this because this access type may be the full
3771 view of a private type. */
3778 /* If this is a reference from a limited_with type back to our
3779 main unit and there's a freeze node for it, either we have
3780 already processed the declaration and made the dummy type,
3781 in which case we just reuse the latter, or we have not yet,
3782 in which case we make the dummy type and it will be reused
3783 when the declaration is finally processed. In both cases,
3784 the pointer eventually created below will be automatically
3785 adjusted when the freeze node is processed. */
3786 || (in_main_unit
3787 && is_from_limited_with
3789 {
3792 }
3794 /* Otherwise handle the case of a pointer to itself. */
3796 {
3797 gnu_type
3801 }
3803 /* If expansion is disabled, the equivalent type of a concurrent type
3804 is absent, so we use the void pointer type. */
3808 /* If the ultimately designated type is an incomplete type with no full
3809 view, we use the void pointer type in LTO mode to avoid emitting a
3810 dummy type in the GIMPLE IR. We cannot do that in regular mode as
3811 the name of the dummy type in used by GDB for a global lookup. */
3817 /* Finally, handle the default case where we can just elaborate our
3818 designated type. */
3819 else
3822 /* It is possible that a call to gnat_to_gnu_type above resolved our
3823 type. If so, just return it. */
3825 {
3828 }
3830 /* Access-to-unconstrained-array types need a special treatment. */
3832 {
3833 /* If the processing above got something that has a pointer, then
3834 we are done. This could have happened either because the type
3835 was elaborated or because somebody else executed the code. */
3840 }
3842 /* If we haven't done it yet, build the pointer type the usual way. */
3844 {
3845 /* Modify the designated type if we are pointing only to constant
3846 objects, but don't do it for a dummy type. */
3849 gnu_desig_type
3852 gnu_type
3855 }
3857 /* If the designated type is not declared in the main unit and we made
3858 a dummy node for it, save our definition, elaborate the actual type
3859 and replace the dummy type we made with the actual one. But if we
3860 are to defer actually looking up the actual type, make an entry in
3861 the deferred list instead. If this is from a limited with, we may
3862 have to defer until the end of the current unit. */
3864 {
3866 gnu_type
3872 gnat_entity);
3879 && !is_from_limited_with
3881 {
3884 }
3885 else
3886 {
3896 }
3897 }
3898 }
3903 /* If we are just annotating types and have no equivalent record type,
3904 just use the void pointer type. */
3908 /* The run-time representation is the equivalent type. */
3909 else
3910 {
3913 }
3915 /* The designated subtype must be elaborated as well, if it does
3916 not have its own freeze node. */
3931 /* We treat this as identical to its base type; any constraint is
3932 meaningful only to the front-end. */
3936 /* The designated subtype must be elaborated as well, if it does
3937 not have its own freeze node. */
3942 {
3943 tree gnu_design_base_type
3948 /* If we are to defer elaborating incomplete types, make a dummy
3949 type node and elaborate it later. */
3951 {
3954 p->old_type
3959 }
3961 /* Otherwise elaborate the designated subtype only if its base type
3962 has already been elaborated. */
3966 }
3969 /* Subprogram Entities
3971 The following access functions are defined for subprograms:
3973 Etype Return type or Standard_Void_Type.
3974 First_Formal The first formal parameter.
3975 Is_Imported Indicates that the subprogram has appeared in
3976 an INTERFACE or IMPORT pragma. For now we
3977 assume that the external language is C.
3978 Is_Exported Likewise but for an EXPORT pragma.
3979 Is_Inlined True if the subprogram is to be inlined.
3981 Each parameter is first checked by calling must_pass_by_ref on its
3982 type to determine if it is passed by reference. For parameters which
3983 are copied in, if they are Ada In Out or Out parameters, their return
3984 value becomes part of a record which becomes the return type of the
3985 function (C function - note that this applies only to Ada procedures
3986 so there is no Ada return type). Additional code to store back the
3987 parameters will be generated on the caller side. This transformation
3988 is done here, not in the front-end.
3990 The intended result of the transformation can be seen from the
3991 equivalent source rewritings that follow:
3993 struct temp {int a,b};
3994 procedure P (A,B: In Out ...) is temp P (int A,B)
3995 begin {
3996 .. ..
3997 end P; return {A,B};
3998 }
4000 temp t;
4001 P(X,Y); t = P(X,Y);
4002 X = t.a , Y = t.b;
4004 For subprogram types we need to perform mainly the same conversions to
4005 GCC form that are needed for procedures and function declarations. The
4006 only difference is that at the end, we make a type declaration instead
4007 of a function declaration. */
4012 {
4013 tree gnu_ext_name
4015 const enum inline_status_t inline_status
4017 /* Subprograms marked both Intrinsic and Always_Inline need not
4018 have a body of their own. */
4019 const bool extern_flag
4021 || imported_p
4024 tree gnu_param_list;
4026 /* A parameter may refer to this type, so defer completion of any
4027 incomplete types. */
4029 {
4030 defer_incomplete_level++;
4032 }
4034 /* If the subprogram has an alias, it is probably inherited, so
4035 we can use the original one. If the original "subprogram"
4036 is actually an enumeration literal, it may be the first use
4037 of its type, so we must elaborate that type now. */
4039 {
4047 /* Elaborate any itypes in the parameters of this entity. */
4054 /* Materialize renamed subprograms in the debugging information
4055 when the renamed object is known at compile time; we consider
4056 such renamings as imported declarations.
4058 Because the parameters in generic instantiations are generally
4059 materialized as renamings, we often end up having both the
4060 renamed subprogram and the renaming in the same context and with
4061 the same name; in this case, renaming is both useless debug-wise
4062 and potentially harmful as name resolution in the debugger could
4063 return twice the same entity! So avoid this case. */
4065 && !artificial_p
4072 {
4077 }
4080 }
4082 /* Get the GCC tree for the (underlying) subprogram type. If the
4083 entity is an actual subprogram, also get the parameter list. */
4084 gnu_type
4088 {
4093 }
4095 /* Deal with platform-specific calling conventions. */
4097 prepend_one_attribute
4100 gnat_entity);
4102 /* If we should request stack realignment for a foreign convention
4103 subprogram, do so. Note that this applies to task entry points
4104 in particular. */
4106 prepend_one_attribute
4109 gnat_entity);
4111 /* Deal with a pragma Linker_Section on a subprogram. */
4117 /* If we are defining the subprogram and it has an Address clause
4118 we must get the address expression from the saved GCC tree for the
4119 subprogram if it has a Freeze_Node. Otherwise, we elaborate
4120 the address expression here since the front-end has guaranteed
4121 in that case that the elaboration has no effects. If there is
4122 an Address clause and we are not defining the object, just
4123 make it a constant. */
4125 {
4129 gnu_address
4136 /* Convert the type of the object to a reference type that can
4137 alias everything as per RM 13.3(19). */
4138 gnu_type
4143 gnu_decl
4149 }
4151 /* If this is a mere subprogram type, just create the declaration. */
4153 {
4156 gnu_decl
4159 }
4161 /* Otherwise create the subprogram declaration with the external name,
4162 the type and the parameter list. However, if this a reference to
4163 the allocation routines, reuse the canonical declaration nodes as
4164 they come with special properties. */
4165 else
4166 {
4171 else
4172 gnu_decl
4178 gnat_entity);
4179 }
4180 }
4191 {
4192 const bool is_from_limited_with
4194 /* Get the "full view" of this entity. If this is an incomplete
4195 entity from a limited with, treat its non-limited view as the
4196 full view. Otherwise, use either the full view or the underlying
4197 full view, whichever is present. This is used in all the tests
4198 below. */
4199 const Entity_Id full_view
4200 = is_from_limited_with
4208 /* If this is an incomplete type with no full view, it must be a Taft
4209 Amendment type or an incomplete type coming from a limited context,
4210 in which cases we return a dummy type. Otherwise, we just get the
4211 type from its Etype. */
4213 {
4215 {
4218 }
4219 else
4220 {
4221 gnu_decl
4224 }
4225 }
4227 /* Or else, if we already made a type for the full view, reuse it. */
4231 /* Or else, if we are not defining the type or there is no freeze
4232 node on it, get the type for the full view. Likewise if this is
4233 a limited_with'ed type not declared in the main unit, which can
4234 happen for incomplete formal types instantiated on a type coming
4235 from a limited_with clause. */
4238 || (is_from_limited_with
4240 {
4243 }
4245 /* Otherwise, make a dummy type entry which will be replaced later.
4246 Save it as the full declaration's type so we can do any needed
4247 updates when we see it. */
4248 else
4249 {
4255 }
4256 }
4260 /* Class-wide types are always transformed into their root type. */
4269 /* If we are just annotating types and have no equivalent record type,
4270 just return void_type, except for root types that have discriminants
4271 because the discriminants will very likely be used in the declarative
4272 part of the associated body so they need to be translated. */
4274 {
4278 {
4280 Entity_Id gnat_field;
4282 /* This is a minimal version of the E_Record_Type handling. */
4289 {
4290 tree gnu_field
4302 }
4306 }
4307 else
4309 }
4311 /* Concurrent types are always transformed into their record type. */
4312 else
4323 /* Nothing at all to do here, so just return an ERROR_MARK and claim
4324 we've already saved it, so we don't try to. */
4330 /* This is a SPARK annotation that only reaches here when compiling in
4331 ASIS mode. */
4339 }
4341 /* If this is the clone of a subtype, just reuse the cloned subtype; another
4342 approach would be to set the cloned subtype as the DECL_ORIGINAL_TYPE of
4343 the entity, which would generate a DW_TAG_typedef in the debug info, but
4344 at the cost of the duplication of the GCC type and, more annoyingly, of
4345 the need to update the copy if the cloned subtype is not complete yet. */
4347 {
4352 {
4359 }
4360 }
4362 /* If we had a case where we evaluated another type and it might have
4363 defined this one, handle it here. */
4365 {
4368 }
4370 /* If we are processing a type and there is either no DECL for it or
4371 we just made one, do some common processing for the type, such as
4372 handling alignment and possible padding. */
4374 {
4379 /* Process the attributes, if not already done. Note that the type is
4380 already defined so we cannot pass true for IN_PLACE here. */
4383 /* See if a size was specified, by means of either an Object_Size or
4384 a regular Size clause, and validate it if so.
4386 ??? Don't set the size for a String_Literal since it is either
4387 confirming or we don't handle it properly (if the low bound is
4388 non-constant). */
4390 {
4395 gnu_size
4399 /* ??? The test on Has_Size_Clause must be removed when "unknown" is
4400 no longer represented as Uint_0 (i.e. Use_New_Unknown_Rep). */
4403 gnu_size
4407 }
4409 /* If a size was specified, see if we can make a new type of that size
4410 by rearranging the type, for example from a fat to a thin pointer. */
4412 {
4413 gnu_type
4420 }
4422 /* If the alignment has not already been processed and this is not
4423 an unconstrained array type, see if an alignment is specified.
4424 If not, we pick a default alignment for atomic objects. */
4426 ;
4428 {
4432 /* Warn on suspiciously large alignments. This should catch
4433 errors about the (alignment,byte)/(size,bit) discrepancy. */
4435 {
4436 tree size;
4438 /* If a size was specified, take it into account. Otherwise
4439 use the RM size for records or unions as the type size has
4440 already been adjusted to the alignment. */
4446 else
4449 /* Consider an alignment as suspicious if the alignment/size
4450 ratio is greater or equal to the byte/bit ratio. */
4455 gnat_entity);
4456 }
4457 }
4468 /* See if we need to pad the type. If we did and built a new type,
4469 then create a stripped-down declaration for the original type,
4470 mainly for debugging, unless there was already one. */
4472 {
4480 gnat_entity);
4481 }
4483 /* Now set the RM size of the type. We cannot do it before padding
4484 because we need to accept arbitrary RM sizes on integral types. */
4488 /* Back-annotate the alignment of the type if not already set. */
4490 {
4494 /* If the default alignment of "double" or larger scalar types is
4495 specifically capped and this is not an array with an alignment
4496 clause on the component type, return the cap. */
4498 is_capped_double
4501 is_capped_double
4503 else
4508 else
4512 }
4514 /* Likewise for the size, if any. */
4516 {
4519 /* If the size is self-referential, annotate the maximum value
4520 after saturating it, if need be, to avoid a No_Uint value.
4521 But do not do it for cases where Analyze_Object_Declaration
4522 in Sem_Ch3 would build a default subtype for objects. */
4526 {
4527 const unsigned int align
4530 }
4532 /* If we are just annotating types and the type is tagged, the tag
4533 and the parent components are not generated by the front-end so
4534 alignment and sizes must be adjusted. */
4536 {
4538 const Entity_Id gnat_parent
4540 /* The following test for Known_Alignment preserves the old behavior,
4541 but is probably wrong. */
4542 const unsigned int inherited_align
4543 = derived_p
4548 const unsigned int align
4553 /* If there is neither size clause nor representation clause, the
4554 sizes need to be adjusted. */
4559 {
4560 tree offset
4561 = derived_p
4565 offset
4568 }
4573 /* Tagged types are Strict_Alignment so RM_Size = Esize. */
4576 }
4578 /* Otherwise no adjustment is needed. */
4579 else
4581 }
4583 /* Likewise for the RM size, if any. */
4588 /* If we are at global level, GCC applied variable_size to the size but
4589 this has done nothing. So, if it's not constant or self-referential,
4590 call elaborate_expression_1 to make a variable for it rather than
4591 calculating it each time. */
4596 {
4603 /* ??? For now, store the size as a multiple of the alignment in
4604 bytes so that we can see the alignment from the tree. */
4610 /* ??? gnu_type may come from an existing type so the MULT_EXPR node
4611 may not be marked by the call to create_type_decl below. */
4614 /* For a record type, deal with the variant part, if any, and handle
4615 the Ada size as well. */
4617 {
4622 {
4626 /* If the position of the variant part is constant, subtract
4627 it from the size of the type of the parent to get the new
4628 size. This manual CSE reduces the data size. */
4630 {
4638 }
4639 else
4640 {
4646 /* ??? For now, store the size as a multiple of the
4647 alignment in bytes so that we can see the alignment
4648 from the tree. */
4655 /* ??? For now, store the offset as a multiple of the
4656 alignment in bytes so that we can see the alignment
4657 from the tree. */
4661 DECL_OFFSET_ALIGN
4663 }
4667 }
4671 else
4672 ada_size
4676 }
4677 }
4679 /* Similarly, if this is a record type or subtype at global level, call
4680 elaborate_expression_2 on any field position. Skip any fields that
4681 we haven't made trees for to avoid problems with class-wide types. */
4686 {
4689 /* ??? For now, store the offset as a multiple of the alignment
4690 in bytes so that we can see the alignment from the tree. */
4693 {
4700 /* ??? The context of gnu_field is not necessarily gnu_type
4701 so the MULT_EXPR node built above may not be marked by
4702 the call to create_type_decl below. */
4704 }
4705 }
4707 /* Now check if the type allows atomic access. */
4711 /* If this is not an unconstrained array type, set some flags. */
4713 {
4716 /* Record the property that objects of tagged types are guaranteed to
4717 be properly aligned. This is necessary because conversions to the
4718 class-wide type are translated into conversions to the root type,
4719 which can be less aligned than some of its derived types. */
4724 /* Record whether the type is passed by reference. */
4728 /* Record whether an alignment clause was specified. At this point
4729 scalar types with a non-confirming clause have been wrapped into
4730 a record type, so only scalar types with a confirming clause are
4731 left untouched; we do not set the flag on them except if they are
4732 types whose default alignment is specifically capped in order not
4733 to lose the specified alignment. */
4744 /* Record whether a pragma Universal_Aliasing was specified. */
4748 /* If it is passed by reference, force BLKmode to ensure that
4749 objects of this type will always be put in memory. */
4752 }
4754 /* If this is a derived type, relate its alias set to that of its parent
4755 to avoid troubles when a call to an inherited primitive is inlined in
4756 a context where a derived object is accessed. The inlined code works
4757 on the parent view so the resulting code may access the same object
4758 using both the parent and the derived alias sets, which thus have to
4759 conflict. As the same issue arises with component references, the
4760 parent alias set also has to conflict with composite types enclosing
4761 derived components. For instance, if we have:
4763 type D is new T;
4764 type R is record
4765 Component : D;
4766 end record;
4768 we want T to conflict with both D and R, in addition to R being a
4769 superset of D by record/component construction.
4771 One way to achieve this is to perform an alias set copy from the
4772 parent to the derived type. This is not quite appropriate, though,
4773 as we don't want separate derived types to conflict with each other:
4775 type I1 is new Integer;
4776 type I2 is new Integer;
4778 We want I1 and I2 to both conflict with Integer but we do not want
4779 I1 to conflict with I2, and an alias set copy on derivation would
4780 have that effect.
4782 The option chosen is to make the alias set of the derived type a
4783 superset of that of its parent type. It trivially fulfills the
4784 simple requirement for the Integer derivation example above, and
4785 the component case as well by superset transitivity:
4787 superset superset
4788 R ----------> D ----------> T
4790 However, for composite types, conversions between derived types are
4791 translated into VIEW_CONVERT_EXPRs so a sequence like:
4793 type Comp1 is new Comp;
4794 type Comp2 is new Comp;
4795 procedure Proc (C : Comp1);
4797 C : Comp2;
4798 Proc (Comp1 (C));
4800 is translated into:
4802 C : Comp2;
4803 Proc ((Comp1 &) &VIEW_CONVERT_EXPR <Comp1> (C));
4805 and gimplified into:
4807 C : Comp2;
4808 Comp1 *C.0;
4809 C.0 = (Comp1 *) &C;
4810 Proc (C.0);
4812 i.e. generates code involving type punning. Therefore, Comp1 needs
4813 to conflict with Comp2 and an alias set copy is required.
4815 The language rules ensure the parent type is already frozen here. */
4819 {
4821 /* For constrained packed array subtypes, the implementation type is
4822 used instead of the nominal type. */
4830 }
4832 /* Finally get to the appropriate variant, except for the implementation
4833 type of a packed array because the GNU type might be further adjusted
4834 when the original array type is itself processed. */
4837 {
4838 const int quals
4839 = TYPE_QUAL_VOLATILE
4841 /* This is required by free_lang_data_in_type to disable the ODR. */
4846 }
4848 /* If we already made a decl, just set the type, otherwise create it. */
4850 {
4853 }
4854 else
4857 }
4859 /* If we haven't already, associate the ..._DECL node that we just made with
4860 the input GNAT entity node. */
4864 /* Now we are sure gnat_entity has a corresponding ..._DECL node,
4865 eliminate as many deferred computations as possible. */
4868 /* If this is an enumeration or floating-point type, we were not able to set
4869 the bounds since they refer to the type. These are always static. */
4872 {
4876 /* If this is a padded type, we need to use the underlying type. */
4880 /* If this is a floating point type and we haven't set a floating
4881 point type yet, use this in the evaluation of the bounds. */
4889 {
4890 /* Enumeration types have specific RM bounds. */
4893 }
4894 else
4895 {
4896 /* Floating-point types don't have specific RM bounds. */
4899 }
4900 }
4902 /* If we deferred processing of incomplete types, re-enable it. If there
4903 were no other disables and we have deferred types to process, do so. */
4907 {
4910 /* We are back to level 0 for the deferring of incomplete types.
4911 But processing these incomplete types below may itself require
4912 deferring, so preserve what we have and restart from scratch. */
4917 {
4924 }
4925 }
4927 /* If we are not defining this type, see if it's on one of the lists of
4928 incomplete types. If so, handle the list entry now. */
4930 {
4935 {
4939 }
4945 {
4951 }
4952 }
4955 force_global--;
4957 /* If this is a packed array type whose original array type is itself
4958 an itype without freeze node, make sure the latter is processed. */
4966 }
4968 /* Similar, but if the returned value is a COMPONENT_REF, return the
4969 FIELD_DECL. */
4971 tree
4973 {
4980 }
4982 /* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
4983 the GCC type corresponding to that entity. */
4985 tree
4987 {
4988 tree gnu_decl;
4990 /* The back end never attempts to annotate generic types. */
4998 }
5000 /* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
5001 the unpadded version of the GCC type corresponding to that entity. */
5003 tree
5005 {
5012 }
5014 /* Return whether the E_Subprogram_Type/E_Function/E_Procedure GNAT_ENTITY is
5015 a C++ imported method or equivalent.
5017 We use the predicate to find out whether we need to use METHOD_TYPE instead
5018 of FUNCTION_TYPE for GNAT_ENTITY for the sake compatibility with C++. This
5019 in turn determines whether the "thiscall" calling convention is used by the
5020 back-end for GNAT_ENTITY on 32-bit x86/Windows. */
5022 static bool
5024 {
5025 /* A constructor is a method on the C++ side. We deal with it now because
5026 it is declared without the 'this' parameter in the sources and, although
5027 the front-end will create a version with the 'this' parameter for code
5028 generation purposes, we want to return true for both versions. */
5032 /* Check that the subprogram has C++ convention. */
5036 /* And that the type of the first parameter (indirectly) has it too, but
5037 we make an exception for Interfaces because they need not be imported. */
5047 /* This is the main case: a C++ virtual method imported as a primitive
5048 operation of a tagged type. */
5052 /* This is set on the E_Subprogram_Type built for a dispatching call. */
5056 /* A thunk needs to be handled like its associated primitive operation. */
5060 /* Now on to the annoying case: a C++ non-virtual method, imported either
5061 as a non-primitive operation of a tagged type or as a primitive operation
5062 of an untagged type. We cannot reliably differentiate these cases from
5063 their static member or regular function equivalents in Ada, so we ask
5064 the C++ side through the mangled name of the function, as the implicit
5065 'this' parameter is not encoded in the mangled name of a method. */
5067 {
5075 DMGL_GNU_V3
5076 | DMGL_TYPES
5077 | DMGL_PARAMS
5083 /* We need to release MEM once we have a successful demangling. */
5090 {
5091 /* Make sure there is at least one parameter in C++ too. */
5093 {
5096 n_ada_args++;
5102 n_cpp_args++;
5108 }
5109 else
5111 }
5116 }
5119 }
5121 /* Return the inlining status of the GNAT subprogram SUBPROG. */
5123 static enum inline_status_t
5125 {
5133 {
5134 tree gnu_type;
5136 /* This is a kludge to work around a pass ordering issue: for small
5137 record types with many components, i.e. typically bitfields, the
5138 initialization routine can contain many assignments that will be
5139 merged by the GIMPLE store merging pass. But this pass runs very
5140 late in the pipeline, in particular after the inlining decisions
5141 are made, so the inlining heuristics cannot take its outcome into
5142 account. Therefore, we optimistically override the heuristics for
5143 the initialization routine in this case. */
5145 && flag_store_merging
5153 /* If this is an expression function and we're not optimizing for size,
5154 override the heuristics, unless -gnatd.8 is specified. */
5156 && !optimize_size
5161 }
5164 }
5166 /* Finalize the processing of From_Limited_With incomplete types. */
5168 void
5170 {
5177 {
5181 {
5186 }
5189 }
5190 }
5192 /* Return the cloned subtype to be used for GNAT_ENTITY, if the latter is a
5193 kind of subtype that needs to be considered as a clone by Gigi, otherwise
5194 return Empty. */
5196 static Entity_Id
5198 {
5199 Node_Id gnat_decl;
5202 {
5207 /* ... fall through ... */
5210 /* If Cloned_Subtype is Present, this means that this record subtype has
5211 the same layout as that of the specified (sub)type, and also that the
5212 front-end guarantees that the component list is shared. */
5226 /* We return true for the subtypes generated for the actuals of formal
5227 private types in instantiations, so that these actuals are the types
5228 of the instantiated objects in the debug info. */
5236 /* Likewise for the full view of such subtypes when they are private. */
5238 {
5247 }
5252 }
5255 }
5257 /* Return the equivalent type to be used for GNAT_ENTITY, if it's a kind
5258 of type (such E_Task_Type) that has a different type which Gigi uses
5259 for its representation. If the type does not have a special type for
5260 its representation, return GNAT_ENTITY. */
5262 Entity_Id
5264 {
5271 {
5306 }
5309 }
5311 /* Return a GCC tree for a type corresponding to the component type of the
5312 array type or subtype GNAT_ARRAY. DEFINITION is true if this component
5313 is for an array being defined. DEBUG_INFO_P is true if we need to write
5314 debug information for other types that we may create in the process. */
5316 static tree
5319 {
5323 tree gnu_comp_size;
5327 /* If an alignment is specified, use it as a cap on the component type
5328 so that it can be honored for the whole type, but ignore it for the
5329 original type of packed array types. */
5333 else
5336 /* Try to get a packable form of the component if needed. */
5338 && !is_bit_packed
5344 {
5347 }
5348 else
5351 /* Get and validate any specified Component_Size. */
5352 gnu_comp_size
5357 /* If the component type is a RECORD_TYPE that has a self-referential size,
5358 then use the maximum size for the component size. */
5364 /* If the array has aliased components and the component size is zero, force
5365 the unit size to ensure that the components have distinct addresses. */
5371 /* Honor the component size. This is not needed for bit-packed arrays. */
5373 {
5380 else
5383 /* We need to make sure that the size is a multiple of the alignment.
5384 But we do not misalign the component type because of the alignment
5385 of the array type here; this either must have been done earlier in
5386 the packed case or should be rejected in the non-packed case. */
5388 {
5393 }
5394 else
5400 /* If a padding record was made, declare it now since it will never be
5401 declared otherwise. This is necessary to ensure that its subtrees
5402 are properly marked. */
5405 gnat_array);
5406 }
5408 /* This is a very special case where the array has aliased components and the
5409 component size might be zero at run time. As explained above, we force at
5410 least the unit size but we don't want to build a distinct padding type for
5411 each invocation (they are not canonicalized if they have variable size) so
5412 we cache this special padding type as TYPE_PADDING_FOR_COMPONENT. */
5416 {
5419 else
5420 {
5421 gnu_comp_size
5428 gnat_array);
5429 }
5430 }
5432 /* Now check if the type of the component allows atomic access. */
5436 /* If the component type is a padded type made for a non-bit-packed array
5437 of scalars with reverse storage order, we need to propagate the reverse
5438 storage order to the padding type since it is the innermost enclosing
5439 aggregate type around the scalar. */
5441 && !is_bit_packed
5447 {
5448 const int quals
5449 = TYPE_QUAL_VOLATILE
5452 }
5455 }
5457 /* Return whether TYPE requires that formal parameters of TYPE be initialized
5458 when they are Out parameters passed by copy.
5460 This just implements the set of conditions listed in RM 6.4.1(12). */
5462 static bool
5464 {
5481 {
5489 }
5492 }
5494 /* Return a GCC tree for a parameter corresponding to GNAT_PARAM, to be placed
5495 in the parameter list of GNAT_SUBPROG. GNU_PARAM_TYPE is the GCC tree for
5496 the type of the parameter. FIRST is true if this is the first parameter in
5497 the list of GNAT_SUBPROG. Also set CICO to true if the parameter must use
5498 the copy-in copy-out implementation mechanism.
5500 The returned tree is a PARM_DECL, except for the cases where no parameter
5501 needs to be actually passed to the subprogram; the type of this "shadow"
5502 parameter is then returned instead. */
5504 static tree
5507 {
5512 /* The parameter can be indirectly modified if its address is taken. */
5519 tree gnu_param;
5521 /* Make sure to use the proper SLOC for vector ABI warnings. */
5525 /* Builtins are expanded inline and there is no real call sequence involved.
5526 So the type expected by the underlying expander is always the type of the
5527 argument "as is". */
5532 /* Handle the first parameter of a valued procedure specially: it's a copy
5533 mechanism for which the parameter is never allocated. */
5535 {
5539 }
5541 /* Or else, see if a Mechanism was supplied that forced this parameter
5542 to be passed one way or another. */
5544 forced_by_ref
5546 && !foreign
5550 /* Positive mechanism means by copy for sufficiently small parameters. */
5552 {
5557 else
5559 }
5561 /* Otherwise, it's an unsupported mechanism so error out. */
5562 else
5563 {
5566 }
5568 /* Either for foreign conventions, or if the underlying type is not passed
5569 by reference and is as large and aligned as the original type, strip off
5570 a possible padding type. */
5572 {
5583 }
5585 /* For foreign conventions, pass arrays as pointers to the element type.
5586 First check for unconstrained array and get the underlying array. */
5588 gnu_param_type
5591 /* Arrays are passed as pointers to element type for foreign conventions. */
5593 {
5594 /* Strip off any multi-dimensional entries, then strip
5595 off the last array to get the component type. */
5603 }
5605 /* Fat pointers are passed as thin pointers for foreign conventions. */
5607 gnu_param_type
5610 /* Use a pointer type for the "this" pointer of C++ constructors. */
5612 {
5616 }
5618 /* If we were requested or muss pass by reference, do so.
5619 If we were requested to pass by copy, do so.
5620 Otherwise, for foreign conventions, pass In Out or Out parameters
5621 or aggregates by reference. For COBOL and Fortran, pass all
5622 integer and FP types that way too. For Convention Ada, use
5623 the standard Ada default. */
5627 && ((foreign
5629 || (foreign
5634 || (!foreign
5636 {
5637 /* We take advantage of 6.2(12) by considering that references built for
5638 parameters whose type isn't by-ref and for which the mechanism hasn't
5639 been forced to by-ref allow only a restricted form of aliasing. */
5640 restricted_aliasing_p
5644 }
5646 /* Pass In Out or Out parameters using copy-in copy-out mechanism. */
5655 /* If this is an Out parameter that isn't passed by reference and whose
5656 type doesn't require the initialization of formals, we don't make a
5657 PARM_DECL for it. Instead, it will be a VAR_DECL created when we
5658 process the procedure, so just return its type here. Likewise for
5659 the _Init parameter of an initialization procedure or the special
5660 parameter of a valued procedure, never pass them in. */
5662 && !by_ref
5663 && !by_component_ptr
5667 {
5670 }
5684 /* If no Mechanism was specified, indicate what we're using, then
5685 back-annotate it. */
5691 }
5693 /* Associate GNAT_SUBPROG with GNU_TYPE, which must be a dummy type, so that
5694 GNAT_SUBPROG is updated when GNU_TYPE is completed.
5696 Ada 2012 (AI05-019) says that freezing a subprogram does not always freeze
5697 the corresponding profile, which means that, by the time the freeze node
5698 of the subprogram is encountered, types involved in its profile may still
5699 be not yet frozen. That's why we need to update GNAT_SUBPROG when we see
5700 the freeze node of types involved in its profile, either types of formal
5701 parameters or the return type. */
5703 static void
5705 {
5713 {
5718 }
5720 /* Even if there is already a slot for GNU_TYPE, we need to set the flag
5721 because the vector might have been just emptied by update_profiles_with.
5722 This can happen when there are 2 freeze nodes associated with different
5723 views of the same type; the type will be really complete only after the
5724 second freeze node is encountered. */
5729 /* Make sure GNAT_SUBPROG is not associated twice with the same dummy type,
5730 since this would mean updating twice its profile. */
5732 {
5736 /* Entity_Id is a simple integer so we can implement a stable order on
5737 the vector with an ordered insertion scheme and binary search. */
5739 {
5746 else
5748 }
5750 /* l == u and therefore is the insertion point. */
5752 }
5753 else
5757 }
5759 /* Update the GCC tree previously built for the profile of GNAT_SUBPROG. */
5761 static void
5763 {
5764 tree gnu_param_list;
5769 {
5770 /* Builtins cannot have their address taken so we can reset them. */
5775 }
5781 /* If GNAT_SUBPROG is an actual subprogram, GNU_SUBPROG is a FUNCTION_DECL
5782 and needs to be adjusted too. */
5784 {
5786 tree gnu_ext_name
5791 }
5792 }
5794 /* Update the GCC trees previously built for the profiles involving GNU_TYPE,
5795 a dummy type which appears in profiles. */
5797 void
5799 {
5807 /* The flag needs to be reset before calling update_profile, in case
5808 associate_subprog_with_dummy_type is again invoked on GNU_TYPE. */
5817 }
5819 /* Return the GCC tree for GNAT_TYPE present in the profile of a subprogram.
5821 Ada 2012 (AI05-0151) says that incomplete types coming from a limited
5822 context may now appear as parameter and result types. As a consequence,
5823 we may need to defer their translation until after a freeze node is seen
5824 or to the end of the current unit. We also aim at handling temporarily
5825 incomplete types created by the usual delayed elaboration scheme. */
5827 static tree
5829 {
5830 /* This is the same logic as the E_Access_Type case of gnat_to_gnu_entity
5831 so the rationale is exposed in that place. These processings probably
5832 ought to be merged at some point. */
5834 const bool is_from_limited_with
5837 Entity_Id gnat_full_direct_first
5838 = (is_from_limited_with
5842 Entity_Id gnat_full_direct
5843 = ((is_from_limited_with
5851 tree gnu_type;
5857 && ((!in_main_unit
5864 {
5868 {
5875 }
5876 }
5881 else
5884 /* Access-to-unconstrained-array types need a special treatment. */
5886 {
5889 }
5892 }
5894 /* Return true if TYPE contains only integral data, recursively if need be. */
5896 static bool
5898 {
5900 {
5915 }
5918 }
5920 /* Return a GCC tree for a subprogram type corresponding to GNAT_SUBPROG.
5921 DEFINITION is true if this is for a subprogram being defined. DEBUG_INFO_P
5922 is true if we need to write debug information for other types that we may
5923 create in the process. Also set PARAM_LIST to the list of parameters.
5924 If GNAT_SUBPROG is bound to a GCC builtin, return the DECL for the builtin
5925 directly instead of its type. */
5927 static tree
5930 {
5937 tree gnu_return_type;
5940 /* Non-null for subprograms containing parameters passed by copy-in copy-out
5941 (In Out or Out parameters not passed by reference), in which case it is
5942 the list of nodes used to specify the values of the In Out/Out parameters
5943 that are returned as a record upon procedure return. The TREE_PURPOSE of
5944 an element of this list is a FIELD_DECL of the record and the TREE_VALUE
5945 is the PARM_DECL corresponding to that field. This list will be saved in
5946 the TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
5951 /* Although the semantics of "pure" units in Ada essentially match those of
5952 "const" in GNU C, the semantics of the Is_Pure flag in GNAT do not say
5953 anything about access to global memory, that's why it needs to be mapped
5954 to "pure" instead of "const" in GNU C. The property is orthogonal to the
5955 "nothrow" property only if the EH circuitry is explicit in the internal
5956 representation of the middle-end: if we are to completely hide the EH
5957 circuitry from it, we need to declare that calls to pure Ada subprograms
5958 that can throw have side effects, since they can trigger an "abnormal"
5959 transfer of control; therefore they cannot be "pure" in the GCC sense. */
5965 /* Look into the return type and get its associated GCC tree if it is not
5966 void, and then compute various flags for the subprogram type. But make
5967 sure not to do this processing multiple times. */
5974 {
5978 }
5980 else
5981 {
5982 /* For foreign convention/intrinsic subprograms, return System.Address
5983 as void * or equivalent; this comprises GCC builtins. */
5988 else
5991 /* If this function returns by reference or on the secondary stack, make
5992 the actual return type the reference type and make a note of that. */
5996 {
5999 }
6001 /* If the Mechanism is By_Reference, ensure this function uses the
6002 target's by-invisible-reference mechanism, which may not be the
6003 same as above (e.g. it might be passing an extra parameter). */
6007 /* Likewise, if the return type is itself By_Reference. */
6011 /* If the type is a padded type and the underlying type would not be
6012 passed by reference or the function has a foreign convention, return
6013 the underlying type. */
6015 && (!default_pass_by_ref
6020 /* If the return type is unconstrained, it must have a maximum size.
6021 Use the padded type as the effective return type. And ensure the
6022 function uses the target's by-invisible-reference mechanism to
6023 avoid copying too much data when it returns. */
6025 {
6029 /* If the size overflows to 0, set it to an arbitrary positive
6030 value so that assignments in the type are preserved. Their
6031 actual size is independent of this positive value. */
6035 {
6038 }
6044 /* Declare it now since it will never be declared otherwise. This
6045 is necessary to ensure that its subtrees are properly marked. */
6052 }
6054 /* If the return type has a size that overflows, we usually cannot have
6055 a function that returns that type. This usage doesn't really make
6056 sense anyway, so issue an error here. */
6061 {
6066 }
6068 /* If the return type is incomplete, there are 2 cases: if the function
6069 returns by reference, then the return type is only linked indirectly
6070 in the profile, so the profile can be seen as complete since it need
6071 not be further modified, only the reference types need be adjusted;
6072 otherwise the profile is incomplete and need be adjusted too. */
6074 {
6077 }
6081 || return_by_invisi_ref_p
6083 }
6085 /* A procedure (something that doesn't return anything) shouldn't be
6086 considered pure since there would be no reason for calling such a
6087 subprogram. Note that procedures with Out (or In Out) parameters
6088 have already been converted into a function with a return type.
6089 Similarly, if the function returns an unconstrained type, then the
6090 function will allocate the return value on the secondary stack and
6091 thus calls to it cannot be CSE'ed, lest the stack be reclaimed. */
6095 /* Loop over the parameters and get their associated GCC tree. While doing
6096 this, build a copy-in copy-out structure if we need one. */
6097 Entity_Id gnat_param;
6102 {
6103 const bool mech_is_by_ref
6110 /* For a variadic C function, do not build unnamed parameters. */
6115 /* Fetch an existing parameter with complete type and reuse it. But we
6116 didn't save the CICO property so we can only do it for In parameters
6117 or parameters passed by reference. */
6122 {
6125 }
6127 /* Otherwise translate the parameter type and act accordingly. */
6128 else
6129 {
6132 /* For foreign convention/intrinsic subprograms, pass System.Address
6133 as void * or equivalent; this comprises GCC builtins. */
6138 else
6141 /* If the parameter type is incomplete, there are 2 cases: if it is
6142 passed by reference, then the type is only linked indirectly in
6143 the profile, so the profile can be seen as complete since it need
6144 not be further modified, only the reference type need be adjusted;
6145 otherwise the profile is incomplete and need be adjusted too. */
6147 {
6148 Node_Id gnat_decl;
6152 && TYPE_IS_FAT_POINTER_P
6155 {
6157 gnu_param
6167 }
6169 /* ??? This is a kludge to support null procedures in spec taking
6170 a parameter with an untagged incomplete type coming from a
6171 limited context. The front-end creates a body without knowing
6172 anything about the non-limited view, which is illegal Ada and
6173 cannot be supported. Create a parameter with a fake type. */
6181 else
6182 {
6183 /* Build a minimal PARM_DECL without DECL_ARG_TYPE so that
6184 Call_to_gnu will stop if it encounters the PARM_DECL. */
6185 gnu_param
6187 gnu_param_type);
6189 gnu_param_type);
6191 }
6192 }
6194 /* Otherwise build the parameter declaration normally. */
6195 else
6196 {
6197 gnu_param
6201 /* We are returned either a PARM_DECL or a type if no parameter
6202 needs to be passed; in either case, adjust the type. */
6205 else
6206 {
6209 }
6210 }
6211 }
6213 /* If we have a GCC tree for the parameter, register it. */
6216 {
6217 gnu_param_type_list
6223 /* A pure function in the Ada sense which takes an access parameter
6224 may modify memory through it and thus cannot be considered pure
6225 in the GCC sense, unless it's access-to-function. Likewise it if
6226 takes a by-ref In Out or Out parameter. But if it takes a by-ref
6227 In parameter, then it may only read memory through it and can be
6228 considered pure in the GCC sense. */
6234 }
6236 /* If the parameter uses the copy-in copy-out mechanism, allocate a field
6237 for it in the return type and register the association. */
6239 {
6241 {
6244 /* If this is a function, we also need a field for the
6245 return value to be placed. */
6247 {
6248 tree gnu_field
6250 gnu_return_type,
6256 gnu_cico_list
6260 }
6263 /* Set a default alignment to speed up accesses. But we should
6264 not increase the size of the structure too much, lest it does
6265 not fit in return registers anymore. */
6268 }
6270 tree gnu_field
6281 }
6282 }
6284 /* If the subprogram uses the copy-in copy-out mechanism, possibly adjust
6285 and finish up the return type. */
6287 {
6288 /* If we have a CICO list but it has only one entry, we convert
6289 this function into a function that returns this object. */
6293 /* Do not finalize the return type if the subprogram is stubbed
6294 since structures are incomplete for the back-end. */
6296 {
6301 /* Try to promote the mode if the return type is fully returned
6302 in integer registers, again to speed up accesses. */
6304 && gnu_cico_only_integral_type
6306 NULL_TREE))
6307 {
6308 unsigned int size
6311 scalar_int_mode mode;
6316 {
6324 }
6325 }
6327 /* But demote the mode if the return type is partly returned in FP
6328 registers to avoid creating problematic paradoxical subregs.
6329 Note that we need to cater to historical 32-bit architectures
6330 that incorrectly use the mode to select the return mechanism. */
6332 && !gnu_cico_only_integral_type
6335 NULL_TREE))
6341 /* Declare it now since it will never be declared otherwise. This
6342 is necessary to ensure that its subtrees are properly marked. */
6344 gnu_cico_return_type,
6346 }
6349 }
6351 /* The lists have been built in reverse. */
6358 /* Turn imported C++ constructors into their callable form as done in the
6359 front-end, i.e. add the "this" pointer and void the return type. */
6363 {
6364 tree gnu_param_type
6367 tree gnu_param
6369 gnu_param_type);
6370 gnu_param_type_list
6375 }
6377 /* If the profile is incomplete, we only set the (temporary) return and
6378 parameter types; otherwise, we build the full type. In either case,
6379 we reuse an already existing GCC tree that we built previously here. */
6381 {
6383 ;
6384 else
6390 }
6391 else
6392 {
6394 {
6398 {
6402 }
6408 }
6409 else
6410 {
6412 {
6414 gnu_type
6417 }
6418 else
6419 gnu_type
6422 /* GNU_TYPE may be shared since GCC hashes types. Unshare it if it
6423 has a different TYPE_CI_CO_LIST or flags. */
6425 return_by_direct_ref_p,
6426 return_by_invisi_ref_p))
6427 {
6432 }
6433 }
6441 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
6442 corresponding DECL node and check the parameter association. */
6445 {
6449 /* If we have a builtin DECL for that function, use it. Check if
6450 the profiles are compatible and warn if they are not. Note that
6451 the checker is expected to post diagnostics in this case. */
6453 {
6455 {
6456 const enum built_in_function fncode
6460 {
6489 /* This is a generic builtin overloaded on its return
6490 type, so do type resolution based on it. */
6493 gnu_builtin_decl
6495 else
6496 {
6497 post_error
6499 gnat_subprog);
6500 post_error
6502 gnat_subprog);
6504 }
6508 /* This is a generic builtin overloaded on its third
6509 parameter type, so do type resolution based on it. */
6511 && type_for_atomic_builtin_p
6513 gnu_builtin_decl
6514 = resolve_atomic_builtin
6516 else
6517 {
6518 post_error
6520 gnat_subprog);
6521 post_error
6523 gnat_subprog);
6525 }
6531 post_error
6533 gnat_subprog);
6539 }
6540 }
6543 {
6544 const intrin_binding_t inb
6548 post_error
6550 gnat_subprog);
6553 }
6554 }
6556 /* Inability to find the builtin DECL most often indicates a genuine
6557 mistake, but imports of unregistered intrinsics are sometimes used
6558 on purpose to allow hooking in alternate bodies; we post a warning
6559 conditioned on Wshadow in this case, to let developers be notified
6560 on demand without risking false positives with common default sets
6561 of options. */
6564 }
6565 }
6570 }
6572 /* Return the external name for GNAT_SUBPROG given its entity name. */
6574 static tree
6576 {
6579 /* If there was no specified Interface_Name and the external and
6580 internal names of the subprogram are the same, only use the
6581 internal name to allow disambiguation of nested subprograms. */
6586 }
6588 /* Set TYPE_NONALIASED_COMPONENT on an array type built by means of
6589 build_nonshared_array_type. */
6591 static void
6593 {
6597 }
6599 /* Set TYPE_REVERSE_STORAGE_ORDER on an array type built by means of
6600 build_nonshared_array_type. */
6602 static void
6604 {
6608 }
6610 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
6612 static bool
6614 {
6621 return
6623 }
6625 /* Return true if the array type GNU_TYPE, which represents a dimension of
6626 GNAT_TYPE, has a non-aliased component in the back-end sense. */
6628 static bool
6630 {
6631 /* If the array type has an aliased component in the front-end sense,
6632 then it also has an aliased component in the back-end sense. */
6636 /* If this is a derived type, then it has a non-aliased component if
6637 and only if its parent type also has one. */
6639 {
6642 gnu_parent_type
6645 }
6647 /* For a multi-dimensional array type, find the component type. */
6652 /* Consider that an array of pointers has an aliased component, which is
6653 sort of logical and helps with Taft Amendment types in LTO mode. */
6657 /* Otherwise, rely exclusively on properties of the element type. */
6659 }
6661 /* Return true if GNAT_ADDRESS is a value known at compile-time. */
6663 static bool
6665 {
6666 /* Handle reference to a constant. */
6669 {
6673 }
6675 /* Catch System'To_Address. */
6680 }
6682 /* Return true if GNAT_INDIC, a N_Subtype_Indication node for the index of a
6683 FLB, cannot yield superflat objects, i.e. if the inequality HB >= LB - 1
6684 is true for these objects. LB and HB are the low and high bounds. */
6686 static bool
6688 {
6694 /* This is a FLB so LB is fixed. */
6698 {
6701 }
6702 else
6705 /* The low bound of the type is a lower bound for HB. */
6709 {
6712 }
6713 else
6716 /* We need at least a signed 64-bit type to catch most cases. */
6722 /* If the low bound is the smallest integer, nothing can be smaller. */
6728 }
6730 /* Return true if GNAT_RANGE, a N_Range node, cannot be superflat, i.e. if the
6731 inequality HB >= LB - 1 is true. LB and HB are the low and high bounds. */
6733 static bool
6735 {
6737 Node_Id gnat_scalar_range;
6740 /* This is the easy case. */
6744 /* If the low bound is not constant, take the worst case by finding an upper
6745 bound for its type, repeatedly if need be. */
6754 /* If the high bound is not constant, take the worst case by finding a lower
6755 bound for its type, repeatedly if need be. */
6764 /* If we have failed to find constant bounds, punt. */
6769 /* We need at least a signed 64-bit type to catch most cases. */
6775 /* If the low bound is the smallest integer, nothing can be smaller. */
6781 }
6783 /* Return true if GNU_EXPR is (essentially) the address of a CONSTRUCTOR. */
6785 static bool
6787 {
6794 }
6796 /* Return true if the size in units represented by GNU_SIZE can be handled by
6797 an allocation. If STATIC_P is true, consider only what can be done with a
6798 static allocation. */
6800 static bool
6802 {
6803 /* We can allocate a fixed size if it is a valid for the middle-end. */
6807 /* We can allocate a variable size if this isn't a static allocation. */
6808 else
6810 }
6812 /* Return true if GNU_EXPR needs a conversion to GNU_TYPE when used as the
6813 initial value of an object of GNU_TYPE. */
6815 static bool
6817 {
6818 /* Do not convert if the object's type is unconstrained because this would
6819 generate useless evaluations of the CONSTRUCTOR to compute the size. */
6824 /* Do not convert if the object's type is a padding record whose field is of
6825 self-referential size because we want to copy only the actual data. */
6829 /* Do not convert a call to a function that returns with variable size since
6830 we want to use the return slot optimization in this case. */
6835 /* Do not convert to a record type with a variant part from a record type
6836 without one, to keep the object simpler. */
6843 /* In all the other cases, convert the expression to the object's type. */
6845 }
6847 /* Add the contribution of [MIN, MAX] to the current number of elements N_ELEM
6848 of an array type and return the result, or NULL_TREE if it overflowed. */
6850 static tree
6852 {
6853 /* First deal with the empty case. */
6862 /* Compute the number of elements in this dimension. */
6863 tree this_n_elem
6869 /* Multiply the current number of elements by the result. */
6876 }
6878 /* Given GNAT_ENTITY, elaborate all expressions that are required to
6879 be elaborated at the point of its definition, but do nothing else. */
6881 void
6883 {
6885 {
6892 {
6896 /* ??? Tests to avoid Constraint_Error in static expressions
6897 are needed until after the front stops generating bogus
6898 conversions on bounds of real types. */
6906 }
6913 {
6914 Node_Id gnat_discriminant_expr;
6915 Entity_Id gnat_field;
6919 gnat_discriminant_expr
6924 /* Ignore access discriminants. */
6929 }
6932 /* -Wswitch warning avoidance. */
6935 }
6936 }
6938 /* Prepend to ATTR_LIST an entry for an attribute with provided TYPE,
6939 NAME, ARGS and ERROR_POINT. */
6941 static void
6944 tree attr_name,
6945 tree attr_args,
6946 Node_Id attr_error_point)
6947 {
6957 }
6959 /* Prepend to ATTR_LIST an entry for an attribute provided by GNAT_PRAGMA. */
6961 static void
6963 {
6969 /* Map the pragma at hand. Skip if this isn't one we know how to handle. */
6971 {
7002 }
7004 /* See what arguments we have and turn them into GCC trees for attribute
7005 handlers. The first one is always expected to be a string meant to be
7006 turned into an identifier. The next ones are all static expressions,
7007 among which strings meant to be turned into an identifier, except for
7008 a couple of specific attributes that require raw strings. */
7010 {
7015 const bool string_args
7025 {
7029 gnu_arg_list
7032 }
7033 }
7038 }
7040 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
7042 static void
7044 {
7045 Node_Id gnat_temp;
7047 /* Attributes are stored as Representation Item pragmas. */
7053 }
7055 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
7056 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
7057 return the GCC tree to use for that expression. S is the suffix to use
7058 if a variable needs to be created and DEFINITION is true if this is done
7059 for a definition of GNAT_ENTITY. If NEED_VALUE is true, we need a result;
7060 otherwise, we are just elaborating the expression for side-effects. If
7061 NEED_FOR_DEBUG is true, we need a variable for debugging purposes even
7062 if it isn't needed for code generation. */
7064 static tree
7067 {
7068 tree gnu_expr;
7070 /* If we already elaborated this expression (e.g. it was involved
7071 in the definition of a private type), use the old value. */
7075 /* If we don't need a value and this is static or a discriminant,
7076 we don't need to do anything. */
7083 /* If it's a static expression, we don't need a variable for debugging. */
7087 /* Otherwise, convert this tree to its GCC equivalent and elaborate it. */
7091 /* Save the expression in case we try to elaborate this entity again. Since
7092 it's not a DECL, don't check it. Don't save if it's a discriminant. */
7097 }
7099 /* Similar, but take a GNU expression and always return a result. */
7101 static tree
7104 {
7109 /* If GNU_EXPR contains a placeholder, just return it. We rely on the fact
7110 that an expression cannot contain both a discriminant and a variable. */
7114 /* If GNU_EXPR is neither a constant nor based on a read-only variable, make
7115 a variable that is initialized to contain the expression when the package
7116 containing the definition is elaborated. If this entity is defined at top
7117 level, replace the expression by the variable; otherwise use a SAVE_EXPR
7118 if this is necessary. */
7121 else
7122 {
7123 /* Skip any conversions and simple constant arithmetics to see if the
7124 expression is based on a read-only variable. */
7132 expr_variable_p
7133 = !(inner
7136 }
7138 /* We only need to use the variable if we are in a global context since GCC
7139 can do the right thing in the local case. However, when not optimizing,
7140 use it for bounds of loop iteration scheme to avoid code duplication. */
7141 use_variable = expr_variable_p
7142 && (expr_global_p
7143 || (!optimize
7144 && definition
7149 /* If the GNAT encodings are not used, we don't need a variable for debug
7150 info purposes if the expression is a constant or another variable, but
7151 we must be careful because we do not generate debug info for external
7152 variables so DECL_IGNORED_P is not stable across units. */
7156 || (!expr_public_p
7161 /* Now create it, possibly only for debugging purposes. */
7163 {
7164 /* The following variable creation can happen when processing the body
7165 of subprograms that are defined outside of the extended main unit and
7166 inlined. In this case, we are not at the global scope, and thus the
7167 new variable must not be tagged "external", as we used to do here as
7168 soon as DEFINITION was false. And note that we test Needs_Debug_Info
7169 here instead of NEED_FOR_DEBUG because, once the variable is created,
7170 whether or not debug information is generated for it is orthogonal to
7171 the reason why it was created in the first place. */
7172 tree gnu_decl
7180 /* Using this variable for debug (if need_for_debug is true) requires
7181 a proper location. The back-end will compute a location for this
7182 variable only if the variable is used by the generated code.
7183 Returning the variable ensures the caller will use it in generated
7184 code. Note that there is no need for a location if the debug info
7185 contains an integer constant. */
7188 }
7191 }
7193 /* Similar, but take an alignment factor and make it explicit in the tree. */
7195 static tree
7198 {
7200 return
7203 gnu_expr,
7204 unit_align),
7206 need_for_debug),
7207 unit_align);
7208 }
7210 /* Structure to hold internal data for elaborate_reference. */
7212 struct er_data
7213 {
7214 Entity_Id entity;
7217 };
7219 /* Wrapper function around elaborate_expression_1 for elaborate_reference. */
7221 static tree
7223 {
7227 /* This is what elaborate_expression_1 does if NEED_DEBUG is false. */
7231 /* If this is a COMPONENT_REF of a fat pointer, elaborate the entire fat
7232 pointer. This may be more efficient, but will also allow us to more
7233 easily find the match for the PLACEHOLDER_EXPR. */
7240 /* If this is the displacement of a pointer, elaborate the pointer and then
7241 displace the result. The actual purpose here is to drop the location on
7242 the expression, which may be problematic if replicated on references. */
7250 return
7252 }
7254 /* Elaborate the reference REF to be used as renamed object for GNAT_ENTITY.
7255 DEFINITION is true if this is done for a definition of GNAT_ENTITY and
7256 INIT is set to the first arm of a COMPOUND_EXPR present in REF, if any. */
7258 static tree
7261 {
7264 }
7266 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
7267 the value passed against the list of choices. */
7269 static tree
7271 {
7280 {
7282 tree gnu_test;
7285 {
7300 /* This represents either a subtype range or a static value of
7301 some kind; Ekind says which. */
7303 {
7309 }
7311 /* ... fall through ... */
7323 }
7325 /* Everything should be folded into constants at this point. */
7335 gnu_test
7346 gnu_test
7349 else
7354 else
7355 gnu_result
7358 }
7361 }
7363 /* Adjust PACKED setting as passed to gnat_to_gnu_field for a field of
7364 type FIELD_TYPE to be placed in RECORD_TYPE. Return the result. */
7366 static int
7368 {
7369 /* If the field is an array of variable size, we'd better not pack it because
7370 this would misalign it and, therefore, probably cause large temporarie to
7371 be created in case we need to take its address. See addressable_p and the
7372 notes on the addressability issues for further details. */
7377 /* In the other cases, we can honor the packing. */
7381 /* If the alignment of the record is specified and the field type
7382 is over-aligned, request Storage_Unit alignment for the field. */
7387 /* Likewise if the maximum alignment of the record is specified. */
7393 }
7395 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
7396 placed in GNU_RECORD_TYPE.
7398 PACKED is 1 if the enclosing record is packed or -1 if the enclosing
7399 record has Component_Alignment of Storage_Unit.
7401 DEFINITION is true if this field is for a record being defined.
7403 DEBUG_INFO_P is true if we need to write debug information for types
7404 that we may create in the process. */
7406 static tree
7409 {
7416 const bool is_full_access
7418 const bool is_independent
7420 const bool is_volatile
7424 /* We used to consider that volatile fields also require strict alignment,
7425 but that was an interpolation and would cause us to reject a pragma
7426 volatile on a packed record type containing boolean components, while
7427 there is no basis to do so in the RM. In such cases, the writes will
7428 involve load-modify-store sequences, but that's OK for volatile. The
7429 only constraint is the implementation advice whereby only the bits of
7430 the components should be accessed if they both start and end on byte
7431 boundaries, but that should be guaranteed by the GCC memory model.
7432 Note that we have some redundancies (is_full_access => is_independent,
7433 is_aliased => is_independent and is_by_ref => is_strict_alignment)
7434 so the following formula is sufficient. */
7440 /* Force the type of the Not_Handled_By_Others field to be that of the
7441 field in struct Exception_Data declared in raise.h instead of using
7442 the declared boolean type. We need to do that because there is no
7443 easy way to make use of a C compatible boolean type for the latter. */
7448 /* The qualifier to be used in messages. */
7452 {
7456 else
7458 }
7465 else
7468 /* The message to be used for incompatible size. */
7474 /* If a field requires strict alignment, we cannot pack it (RM 13.2(7)). */
7477 else
7480 /* If a size is specified, use it. Otherwise, if the record type is packed,
7481 use the official RM size. See "Handling of Type'Size Values" in Einfo
7482 for further details. */
7487 {
7491 }
7492 else
7495 /* Likewise for the position. */
7497 {
7500 }
7502 /* If the record has rep clauses and this is the tag field, make a rep
7503 clause for it as well. */
7506 {
7510 }
7512 else
7513 {
7516 }
7518 /* If the field's type is a fixed-size record that does not require strict
7519 alignment, and the record is packed or we have a position specified for
7520 the field that makes it a bitfield or we have a specified size that is
7521 smaller than that of the field's type, then see if we can get either an
7522 integral mode form of the field's type or a smaller form. If we can,
7523 consider that a size was specified for the field if there wasn't one
7524 already, so we know to make it a bitfield and avoid making things wider.
7526 Changing to an integral mode form is useful when the record is packed as
7527 we can then place the field at a non-byte-aligned position and so achieve
7528 tighter packing. This is in addition required if the field shares a byte
7529 with another field and the front-end lets the back-end handle the access
7530 to the field, because GCC cannot handle non-byte-aligned BLKmode fields.
7532 Changing to a smaller form is required if the specified size is smaller
7533 than that of the field's type and the type contains sub-fields that are
7534 padded, in order to avoid generating accesses to these sub-fields that
7535 are wider than the field.
7537 We avoid the transformation if it is not required or potentially useful,
7538 as it might entail an increase of the field's alignment and have ripple
7539 effects on the outer record type. A typical case is a field known to be
7540 byte-aligned and not to share a byte with another field. */
7546 || is_bitfield
7547 || (gnu_size
7549 {
7550 tree gnu_packable_type
7553 {
7557 }
7558 }
7560 /* Now check if the type of the field allows atomic access. */
7562 {
7563 const unsigned int align
7566 gnu_field_type
7570 }
7572 /* If a position is specified, check that it is valid. */
7574 {
7577 /* Ensure the position doesn't overlap with the parent subtype if there
7578 is one. It would be impossible to build CONSTRUCTORs and accessing
7579 the parent could clobber the component in the extension if directly
7580 done. We accept it with -gnatd.K for the sake of compatibility. */
7583 {
7588 post_error_ne_tree
7591 }
7593 /* If this field needs strict alignment, make sure that the record is
7594 sufficiently aligned and that the position and size are consistent
7595 with the type. But don't do it if we are just annotating types and
7596 the field's type is tagged, since tagged types aren't fully laid out
7597 in this mode. Also, note that atomic implies volatile so the inner
7598 test sequences ordering is significant here. */
7601 {
7608 /* If the position is not a multiple of the storage unit, then error
7609 out and reset the position. */
7611 bitsize_unit_node)))
7612 {
7618 }
7620 /* If the position is not a multiple of the alignment of the type,
7621 then error out and reset the position. */
7625 {
7628 field_s);
7635 }
7638 {
7642 /* If the size is not a multiple of the storage unit, then error
7643 out and reset the size. */
7645 bitsize_unit_node)))
7646 {
7652 }
7654 /* If the size is lower than that of the type, or greater for
7655 atomic and aliased, then error out and reset the size. */
7658 {
7662 type_size);
7664 }
7665 }
7666 }
7667 }
7669 else
7670 {
7671 /* If we are packing the record and the field is BLKmode, round the
7672 size up to a byte boundary. */
7675 }
7677 /* We need to make the size the maximum for the type if it is
7678 self-referential and an unconstrained type. In that case, we can't
7679 pack the field since we can't make a copy to align it. */
7681 && !gnu_size
7684 {
7687 }
7689 /* If a size is specified, adjust the field's type to it. */
7691 {
7692 tree orig_field_type;
7694 /* If the field's type is justified modular, we would need to remove
7695 the wrapper to (better) meet the layout requirements. However we
7696 can do so only if the field is not aliased to preserve the unique
7697 layout, if it has the same storage order as the enclosing record
7698 and if the prescribed size is not greater than that of the packed
7699 array to preserve the justification. */
7709 /* Similarly if the field's type is a misaligned integral type, but
7710 there is no restriction on the size as there is no justification. */
7717 gnu_field_type
7721 /* If the type has been extended, we may need to cap the alignment. */
7731 /* For a bitfield, if the type still has BLKmode, try again to change it
7732 to an integral mode form. This may be necessary on strict-alignment
7733 platforms with a size clause that is much larger than the field type,
7734 because maybe_pad_type has preserved the alignment of the field type,
7735 which may be too low for the new size. */
7743 /* If a padding record was made, declare it now since it will never be
7744 declared otherwise. This is necessary to ensure that its subtrees
7745 are properly marked. */
7750 }
7752 /* Otherwise (or if there was an error), don't specify a position. */
7753 else
7756 /* If the field's type is a padded type made for a scalar field of a record
7757 type with reverse storage order, we need to propagate the reverse storage
7758 order to the padding type since it is the innermost enclosing aggregate
7759 type around the scalar. */
7768 /* Now create the decl for the field. */
7769 gnu_field
7776 /* If this is a discriminant, then we treat it specially: first, we set its
7777 index number for the back-annotation; second, we record whether it cannot
7778 be changed once it has been set for the computation of loop invariants;
7779 third, we make it addressable in order for the optimizer to more easily
7780 see that it cannot be modified by assignments to the other fields of the
7781 record (see create_field_decl for a more detailed explanation), which is
7782 crucial to hoist the offset and size computations of dynamic fields. */
7784 {
7790 }
7793 }
7795 /* Return true if at least one member of COMPONENT_LIST needs strict
7796 alignment. */
7798 static bool
7800 {
7801 Node_Id component_decl;
7806 {
7814 }
7817 }
7819 /* Return true if FIELD is an artificial field. */
7821 static bool
7823 {
7824 /* These fields are generated by the front-end proper. */
7828 /* These fields are generated by gigi. */
7833 }
7835 /* Return true if FIELD is a non-artificial field with self-referential
7836 size. */
7838 static bool
7840 {
7848 }
7850 /* Return true if FIELD is a non-artificial field with variable size. */
7852 static bool
7854 {
7862 }
7864 /* qsort comparer for the bit positions of two record components. */
7866 static int
7868 {
7871 const int ret
7875 }
7877 /* Sort the LIST of fields in reverse order of increasing position. */
7879 static tree
7881 {
7891 {
7894 }
7897 }
7899 /* Reverse function from gnat_to_gnu_field: return the GNAT field present in
7900 either GNAT_COMPONENT_LIST or the discriminants of GNAT_RECORD_TYPE, and
7901 corresponding to the GNU tree GNU_FIELD. */
7903 static Entity_Id
7905 Entity_Id gnat_record_type)
7906 {
7914 {
7918 }
7928 }
7930 /* Issue a warning for the problematic placement of GNU_FIELD present in
7931 either GNAT_COMPONENT_LIST or the discriminants of GNAT_RECORD_TYPE.
7932 IN_VARIANT is true if GNAT_COMPONENT_LIST is the list of a variant.
7933 DO_REORDER is true if fields of GNAT_RECORD_TYPE are being reordered. */
7935 static void
7939 {
7943 Entity_Id gnat_field
7948 = in_variant
7960 = do_reorder
7967 }
7969 /* Likewise but for every field present on GNU_FIELD_LIST. */
7971 static void
7975 {
7979 }
7981 /* Structure holding information for a given variant. */
7983 {
7984 /* The record type of the variant. */
7985 tree type;
7987 /* The name of the variant. */
7988 tree name;
7990 /* The qualifier of the variant. */
7991 tree qual;
7993 /* Whether the variant has a rep clause. */
7996 /* Whether the variant is packed. */
8001 /* Translate and chain GNAT_COMPONENT_LIST present in GNAT_RECORD_TYPE to
8002 GNU_FIELD_LIST, set the result as the field list of GNU_RECORD_TYPE and
8003 finish it up. Return true if GNU_RECORD_TYPE has a rep clause that affects
8004 the layout (see below). When called from gnat_to_gnu_entity during the
8005 processing of a record definition, the GCC node for the parent, if any,
8006 will be the single field of GNU_RECORD_TYPE and the GCC nodes for the
8007 discriminants will be on GNU_FIELD_LIST. The other call to this function
8008 is a recursive call for the component list of a variant and, in this case,
8009 GNU_FIELD_LIST is empty. Note that GNAT_COMPONENT_LIST may be Empty.
8011 PACKED is 1 if this is for a packed record or -1 if this is for a record
8012 with Component_Alignment of Storage_Unit.
8014 DEFINITION is true if we are defining this record type.
8016 CANCEL_ALIGNMENT is true if the alignment should be zeroed before laying
8017 out the record. This means the alignment only serves to force fields to
8018 be bitfields, but not to require the record to be that aligned. This is
8019 used for variants.
8021 ALL_REP is true if a rep clause is present for all the fields.
8023 UNCHECKED_UNION is true if we are building this type for a record with a
8024 Pragma Unchecked_Union.
8026 ARTIFICIAL is true if this is a type that was generated by the compiler.
8028 DEBUG_INFO is true if we need to write debug information about the type.
8030 IN_VARIANT is true if the componennt list is that of a variant.
8032 FIRST_FREE_POS, if nonzero, is the first (lowest) free field position in
8033 the outer record type down to this variant level. It is nonzero only if
8034 all the fields down to this level have a rep clause and ALL_REP is false.
8036 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
8037 with a rep clause is to be added; in this case, that is all that should
8038 be done with such fields and the return value will be false. */
8040 static bool
8047 {
8048 const bool needs_xv_encodings
8061 /* For each component referenced in a component declaration create a GCC
8062 field and add it to the list, skipping pragmas in the GNAT list. */
8070 {
8074 /* If present, the _Parent field must have been created as the single
8075 field of the record type. Put it before any other fields. */
8077 {
8080 }
8081 else
8082 {
8086 /* If this is the _Tag field, put it before any other fields. */
8090 /* If this is the _Controller field, put it before the other
8091 fields except for the _Tag or _Parent field. */
8093 {
8096 }
8098 /* If this is a regular field, put it after the other fields. */
8099 else
8100 {
8106 /* And record information for the final layout. */
8115 }
8116 }
8119 }
8121 /* At the end of the component list there may be a variant part. */
8124 else
8127 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
8128 mutually exclusive and should go in the same memory. To do this we need
8129 to treat each variant as a record whose elements are created from the
8130 component list for the variant. So here we create the records from the
8131 lists for the variants and put them all into the QUAL_UNION_TYPE.
8132 If this is an Unchecked_Union, we make a UNION_TYPE instead or
8133 use GNU_RECORD_TYPE if there are no fields so far. */
8135 {
8139 tree gnu_var_name
8142 tree gnu_union_name
8144 tree gnu_union_type;
8153 /* Reuse the enclosing union if this is an Unchecked_Union whose fields
8154 are all in the variant part, to match the layout of C unions. There
8155 is an associated check below. */
8158 else
8159 {
8160 gnu_union_type
8168 }
8170 /* If all the fields down to this level have a rep clause, find out
8171 whether all the fields at this level also have one. If so, then
8172 compute the new first free position to be passed downward. */
8175 {
8177 gnu_field;
8180 {
8183 this_first_free_pos
8185 }
8186 else
8187 {
8190 }
8191 }
8193 /* For an unchecked union with a fixed part, we need to compute whether
8194 we are at the innermost level of the variant part. */
8201 {
8204 }
8206 /* We build the variants in two passes. The bulk of the work is done in
8207 the first pass, that is to say translating the GNAT nodes, building
8208 the container types and computing the associated properties. However
8209 we cannot finish up the container types during this pass because we
8210 don't know where the variant part will be placed until the end. */
8214 {
8219 vinfo_t vinfo;
8227 /* Set the alignment of the inner type in case we need to make
8228 inner objects into bitfields, but then clear it out so the
8229 record actually gets only the alignment required. */
8235 /* Similarly, if the outer record has a size specified and all
8236 the fields have a rep clause, we can propagate the size. */
8238 {
8242 }
8244 /* Add the fields into the record type for the variant but note that
8245 we aren't sure to really use it at this point, see below. In the
8246 case of an unchecked union with a fixed part, we force the fields
8247 with a rep clause present in the innermost variant to be moved to
8248 the outer variant, so as to flatten the rep-ed layout as much as
8249 possible, the reason being that we cannot do any flattening when
8250 a subtype statically selects a variant later on, for example for
8251 an aggregate. */
8252 has_rep
8259 && !(unchecked_union
8260 && gnu_field_list
8264 /* Translate the qualifier and annotate the GNAT node. */
8268 /* Deal with packedness like in gnat_to_gnu_field. */
8270 {
8273 }
8274 else
8275 field_packed
8278 /* Push this variant onto the stack for the second pass. */
8286 /* Compute the global properties that will determine the placement of
8287 the variant part. */
8291 }
8293 /* Round up the first free position to the alignment of the variant part
8294 for the variants without rep clause. This will guarantee a consistent
8295 layout independently of the placement of the variant part. */
8299 /* In the second pass, the container types are adjusted if necessary and
8300 finished up, then the corresponding fields of the variant part are
8301 built with their qualifier, unless this is an unchecked union. */
8303 {
8307 /* If this is an Unchecked_Union whose fields are all in the variant
8308 part and we have a single field with no representation clause or
8309 placed at offset zero, use the field directly to match the layout
8310 of C unions. */
8312 && gnu_field_list
8316 {
8319 }
8320 else
8321 {
8322 /* Finalize the variant type now. We used to throw away empty
8323 record types but we no longer do that because we need them to
8324 generate complete debug info for the variant; otherwise, the
8325 union type definition will be lacking the fields associated
8326 with these empty variants. */
8328 {
8329 /* The variant part will be at offset 0 so we need to ensure
8330 that the fields are laid out starting from the first free
8331 position at this level. */
8333 tree gnu_rep_part;
8337 gnu_rep_part
8339 this_first_free_pos);
8344 }
8351 gnu_field
8353 gnu_union_type,
8354 all_rep_and_size
8363 }
8367 }
8369 /* Only make the QUAL_UNION_TYPE if there are non-empty variants. */
8371 {
8375 {
8379 }
8384 /* If GNU_UNION_TYPE is our record type, this means that we must have
8385 an Unchecked_Union whose fields are all in the variant part. Now
8386 verify that and, if so, just return. */
8388 {
8390 && !gnu_field_list
8393 }
8398 /* Deal with packedness like in gnat_to_gnu_field. */
8401 else
8402 union_field_packed
8405 gnu_variant_part
8407 all_rep_and_size
8413 }
8414 }
8416 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses. If they do,
8417 pull them out and put them onto the appropriate list.
8419 Similarly, pull out the fields with zero size and no rep clause, as they
8420 would otherwise modify the layout and thus very likely run afoul of the
8421 Ada semantics, which are different from those of C here.
8423 Finally, if there is an aliased field placed in the list after fields
8424 with self-referential size, pull out the latter in the same way.
8426 Optionally, if the reordering mechanism is enabled, pull out the fields
8427 with self-referential size, variable size and fixed size not a multiple
8428 of a byte, so that they don't cause the regular fields to be either at
8429 self-referential/variable offset or misaligned. Note, in the latter
8430 case, that this can only happen in packed record types so the alignment
8431 is effectively capped to the byte for the whole record. But we don't
8432 do it for packed record types if not all fixed-size fiels can be packed
8433 and for non-packed record types if pragma Optimize_Alignment (Space) is
8434 specified, because this can prevent alignment gaps from being filled.
8436 Optionally, if the layout warning is enabled, keep track of the above 4
8437 different kinds of fields and issue a warning if some of them would be
8438 (or are being) reordered by the reordering mechanism.
8440 ??? If we reorder fields, the debugging information will be affected and
8441 the debugger print fields in a different order from the source code. */
8442 const bool do_reorder
8446 ? has_non_packed_fixed_size_field
8449 const bool w_reorder
8462 #define MOVE_FROM_FIELD_LIST_TO(LIST) \
8463 do { \
8464 if (gnu_last) \
8465 DECL_CHAIN (gnu_last) = gnu_next; \
8466 else \
8467 gnu_field_list = gnu_next; \
8468 \
8469 DECL_CHAIN (gnu_field) = (LIST); \
8470 (LIST) = gnu_field; \
8471 } while (0)
8475 {
8479 {
8482 }
8485 {
8496 }
8499 {
8502 }
8504 /* We don't need further processing in default mode. */
8506 {
8509 }
8512 {
8514 {
8518 do_reorder);
8519 else
8521 }
8524 {
8527 }
8528 }
8531 {
8533 {
8537 do_reorder);
8538 else
8540 }
8543 {
8546 }
8547 }
8549 else
8550 {
8551 /* If the field has no size, then it cannot be bit-packed. */
8552 const unsigned int bitp_size
8557 /* If the field is bit-packed, we move it to a temporary list that
8558 contains the contiguously preceding bit-packed fields, because
8559 we want to be able to put them back if the misalignment happens
8560 to cancel itself after several bit-packed fields. */
8562 {
8566 {
8569 }
8572 {
8575 }
8576 }
8578 /* No more bit-packed fields, move the existing ones to the end or
8579 put them back at their original location. */
8581 {
8585 {
8587 {
8590 gnat_component_list,
8592 do_reorder);
8593 else
8595 gnat_component_list,
8597 do_reorder);
8598 }
8605 }
8606 else
8607 {
8608 /* Rechain the temporary list in front of GNU_FIELD. */
8611 {
8616 else
8620 }
8621 }
8622 }
8624 else
8626 }
8629 }
8631 #undef MOVE_FROM_FIELD_LIST_TO
8635 /* If permitted, we reorder the fields as follows:
8637 1) all (groups of) fields whose length is fixed and multiple of a byte,
8638 2) the remaining fields whose length is fixed and not multiple of a byte,
8639 3) the remaining fields whose length doesn't depend on discriminants,
8640 4) all fields whose length depends on discriminants,
8641 5) the variant part,
8643 within the record and within each variant recursively. */
8646 {
8647 /* If we have pending bit-packed fields, warn if they would be moved
8648 to after regular fields. */
8652 {
8657 else
8661 }
8662 }
8665 {
8666 /* If we have pending bit-packed fields on the temporary list, we put
8667 them either on the bit-packed list or back on the regular list. */
8669 {
8672 else
8674 }
8676 gnu_field_list
8680 }
8682 /* Otherwise, if there is an aliased field placed after a field whose length
8683 depends on discriminants, we put all the fields of the latter sort, last.
8684 We need to do this in case an object of this record type is mutable. */
8688 /* If P_REP_LIST is nonzero, this means that we are asked to move the fields
8689 in our REP list to the previous level because this level needs them in
8690 order to do a correct layout, i.e. avoid having overlapping fields. */
8694 /* Deal with the case of an extension of a record type with variable size and
8695 partial rep clause, for which the _Parent field is forced at offset 0 and
8696 has variable size. Note that we cannot do it if the field has fixed size
8697 because we rely on the presence of the REP part built below to trigger the
8698 reordering of the fields in a derived record type when all the fields have
8699 a fixed position. */
8703 && !variants_have_rep
8704 && first_free_pos
8707 {
8711 }
8713 /* Otherwise, sort the fields by bit position and put them into their own
8714 record, before the others, if we also have fields without rep clause. */
8716 {
8719 /* If all the fields have a rep clause, we can do a flat layout. */
8720 layout_with_rep = !gnu_field_list
8723 /* Same as above but the extension itself has a rep clause, in which case
8724 we need to set aside the _Parent field to lay out the REP part. */
8726 && !layout_with_rep
8727 && !variants_have_rep
8728 && first_free_pos
8731 {
8734 }
8735 else
8738 gnu_rep_type
8741 /* Sort the fields in order of increasing bit position. */
8747 {
8750 }
8756 {
8760 }
8762 /* Do the layout of the REP part, if any. */
8765 else
8766 {
8773 /* If FIRST_FREE_POS is nonzero, we need to ensure that the fields
8774 without rep clause are laid out starting from this position.
8775 Therefore, we force it as a minimal size on the REP part. */
8776 tree gnu_rep_part
8779 /* If this is an extension, put back the _Parent field as the first
8780 field of the REP part at offset 0 and update its layout. */
8782 {
8788 {
8795 }
8796 }
8801 /* Chain the REP part at the beginning of the field list. */
8804 }
8805 }
8807 /* Chain the variant part at the end of the field list. */
8819 /* Chain the fields with zero size at the beginning of the field list. */
8825 }
8827 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
8828 placed into an Esize, Component_Bit_Offset, or Component_Size value
8829 in the GNAT tree. */
8831 static Uint
8833 {
8835 TCode tcode;
8839 /* See if we've already saved the value for this node. */
8841 {
8849 }
8850 else
8853 /* If we do not return inside this switch, TCODE will be set to the
8854 code to be used in a call to Create_Node. */
8856 {
8858 /* For negative values, build NEGATE_EXPR of the opposite. Such values
8859 can appear for discriminants in expressions for variants. */
8861 {
8865 }
8866 else
8871 /* The only case we handle here is a simple discriminant reference. */
8873 {
8877 /* Climb up the chain of successive extensions, if any. */
8884 {
8885 /* Fall through to common processing as a FIELD_DECL. */
8888 }
8889 else
8891 }
8892 else
8902 CASE_CONVERT:
8906 /* Now just list the operations we handle. */
8934 /* Turn addition of negative constant into subtraction. */
8937 {
8942 }
8944 /* ... fall through ... */
8948 /* Fold conversions from bytes to bits into inner operations. */
8951 {
8955 {
8959 widest_int op1;
8963 else
8964 {
8969 }
8971 }
8972 }
8977 /* For negative values in sizetype, build NEGATE_EXPR of the opposite.
8978 Such values can appear in expressions with aligning patterns. */
8980 {
8984 }
8988 /* In regular mode, inline back only if symbolic annotation is requested
8989 in order to avoid memory explosion on big discriminated record types.
8990 But not in ASIS mode, as symbolic annotation is required for DDA. */
8992 {
8995 }
8996 else
9001 }
9003 /* Now get each of the operands that's relevant for this code. If any
9004 cannot be expressed as a repinfo node, say we can't. */
9007 {
9011 }
9015 /* Save the result in the cache. */
9017 {
9019 /* We can't assume the hash table data hasn't moved since the initial
9020 look up, so we have to search again. Allocating and inserting an
9021 entry at that point would be an alternative, but then we'd better
9022 discard the entry if we decided not to cache it. */
9028 }
9031 }
9033 /* Given GNAT_ENTITY, an object (constant, variable, parameter, exception)
9034 and GNU_TYPE, its corresponding GCC type, set Esize and Alignment to the
9035 size and alignment used by Gigi. Prefer SIZE over TYPE_SIZE if non-null.
9036 BY_REF is true if the object is used by reference. */
9038 void
9040 {
9042 {
9045 else
9047 }
9050 {
9059 }
9064 }
9066 /* Return first element of field list whose TREE_PURPOSE is the same as ELEM.
9067 Return NULL_TREE if there is no such element in the list. */
9069 static tree
9071 {
9073 {
9078 }
9080 }
9082 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding GCC type,
9083 set Component_Bit_Offset and Esize of the components to the position and
9084 size used by Gigi. */
9086 static void
9088 {
9089 /* For an extension, the inherited components have not been translated because
9090 they are fetched from the _Parent component on the fly. */
9091 const bool is_extension
9094 /* We operate by first making a list of all fields and their position (we
9095 can get the size easily) and then update all the sizes in the tree. */
9096 tree gnu_list
9107 {
9109 gnu_list);
9111 {
9115 /* If we are just annotating types and the type is tagged, the tag
9116 and the parent components are not generated by the front-end so
9117 we need to add the appropriate offset to each component without
9118 representation clause. */
9122 {
9123 tree parent_bit_offset;
9125 /* For a component appearing in the current extension, the
9126 offset is the size of the parent. */
9129 parent_bit_offset
9131 bitsizetype);
9132 else
9136 parent_bit_offset
9140 offset
9144 parent_bit_offset,
9145 bitsize_unit_node)));
9146 }
9148 /* If the field has a variable offset, also compute the normalized
9149 position since it's easier to do on trees here than to deduce
9150 it from the annotated expression of Component_Bit_Offset. */
9152 {
9158 }
9160 Set_Component_Bit_Offset
9164 Set_Esize
9167 }
9169 {
9170 /* If there is no entry, this is an inherited component whose
9171 position is the same as in the parent type. */
9174 /* If we are just annotating types, discriminants renaming those of
9175 the parent have no entry so deal with them specifically. */
9182 {
9187 }
9193 }
9194 }
9195 }
9197 /* Scan all fields in GNU_TYPE and return a TREE_LIST where TREE_PURPOSE is
9198 the FIELD_DECL and TREE_VALUE a TREE_VEC containing the byte position, the
9199 value to be placed into DECL_OFFSET_ALIGN and the bit position. The list
9200 of fields is flattened, except for variant parts if DO_NOT_FLATTEN_VARIANT
9201 is set to true. GNU_POS is to be added to the position, GNU_BITPOS to the
9202 bit position, OFFSET_ALIGN is the present offset alignment. GNU_LIST is a
9203 pre-existing list to be chained to the newly created entries. */
9205 static tree
9208 {
9209 tree gnu_field;
9212 gnu_field;
9214 {
9219 unsigned int our_offset_align
9228 /* Recurse on internal fields, flattening the nested fields except for
9229 those in the variant part, if requested. */
9231 {
9235 gnu_list
9239 else
9240 gnu_list
9244 }
9245 }
9248 }
9250 /* Return a list describing the substitutions needed to reflect the
9251 discriminant substitutions from GNAT_TYPE to GNAT_SUBTYPE. They can
9252 be in any order. The values in an element of the list are in the form
9253 of operands to SUBSTITUTE_IN_EXPR. DEFINITION is true if this is for
9254 a definition of GNAT_SUBTYPE. */
9258 {
9260 Entity_Id gnat_discrim;
9261 Node_Id gnat_constr;
9268 /* Ignore access discriminants. */
9270 {
9272 tree replacement
9276 /* If this is a definition, we need to make sure that the SAVE_EXPRs
9277 are instantiated on every possibly path in size computations. */
9283 }
9286 }
9288 /* Scan all fields in {GNU_QUAL_UNION_TYPE,GNAT_VARIANT_PART} and return a list
9289 describing the variants of GNU_QUAL_UNION_TYPE that are still relevant after
9290 applying the substitutions described in SUBST_LIST. GNU_LIST is an existing
9291 list to be prepended to the newly created entries. */
9296 {
9297 Node_Id gnat_variant;
9298 tree gnu_field;
9301 gnat_variant
9305 gnu_field;
9307 gnat_variant
9311 {
9319 /* If the new qualifier is not unconditionally false, its variant may
9320 still be accessed. */
9322 {
9324 variant_desc v
9329 /* Annotate the GNAT node if present. */
9333 /* Recurse on the variant subpart of the variant, if any. */
9336 gnu_list
9339 ? Variant_Part
9342 subst_list,
9343 gnu_list);
9345 /* If the new qualifier is unconditionally true, the subsequent
9346 variants cannot be accessed. */
9349 }
9350 }
9353 }
9355 /* If SIZE has overflowed, return the maximum valid size, which is the upper
9356 bound of the signed sizetype in bits, rounded down to ALIGN. Otherwise
9357 return SIZE unmodified. */
9359 static tree
9361 {
9363 {
9364 size
9369 }
9372 }
9374 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
9375 corresponding to GNAT_OBJECT. If the size is valid, return an INTEGER_CST
9376 corresponding to its value. Otherwise, return NULL_TREE. KIND is set to
9377 VAR_DECL if we are specifying the size of an object, TYPE_DECL for the
9378 size of a type, and FIELD_DECL for the size of a field. COMPONENT_P is
9379 true if we are being called to process the Component_Size of GNAT_OBJECT;
9380 this is used only for error messages. ZERO_OK is true if a size of zero
9381 is permitted; if ZERO_OK is false, it means that a size of zero should be
9382 treated as an unspecified size. S1 and S2 are used for error messages. */
9384 static tree
9388 {
9389 Node_Id gnat_error_node;
9392 /* Return 0 if no size was specified. */
9396 /* Ignore a negative size since that corresponds to our back-annotation. */
9400 /* Find the node to use for error messages. */
9409 else
9412 /* Get the size as an INTEGER_CST. Issue an error if a size was specified
9413 but cannot be represented in bitsizetype. */
9416 {
9419 gnat_object);
9420 else
9422 gnat_object);
9424 }
9426 /* Ignore a zero size if it is not permitted. */
9430 /* The size of objects is always a multiple of a byte. */
9433 {
9437 else
9441 }
9443 /* If this is an integral type or a bit-packed array type, the front-end has
9444 already verified the size, so we need not do it again (which would mean
9445 checking against the bounds). However, if this is an aliased object, it
9446 may not be smaller than the type of the object. */
9451 /* If the object is a record that contains a template, add the size of the
9452 template to the specified size. */
9459 /* If the old size is self-referential, get the maximum size. */
9463 /* If this is an access type or a fat pointer, the minimum size is that given
9464 by the smallest integral mode that's valid for pointers. */
9466 {
9471 }
9473 /* Issue an error either if the default size of the object isn't a constant
9474 or if the new size is smaller than it. */
9477 {
9482 {
9485 }
9488 else
9494 }
9497 }
9499 /* Similarly, but both validate and process a value of RM size. This routine
9500 is only called for types. */
9502 static void
9504 {
9505 Node_Id gnat_attr_node;
9508 /* Do nothing if no size was specified. */
9512 /* Only issue an error if a Value_Size clause was explicitly given for the
9513 entity; otherwise, we'd be duplicating an error on the Size clause. */
9514 gnat_attr_node
9519 /* Get the size as an INTEGER_CST. Issue an error if a size was specified
9520 but cannot be represented in bitsizetype. */
9523 {
9526 gnat_entity);
9528 }
9530 /* Ignore a zero size unless a Value_Size clause exists, or a size clause
9531 exists, or this is an integer type, in which case the front-end will
9532 have always set it. */
9541 /* If the old size is self-referential, get the maximum size. */
9545 /* Issue an error either if the old size of the object isn't a constant or
9546 if the new size is smaller than it. The front-end has already verified
9547 this for scalar and bit-packed array types. */
9555 {
9557 post_error_ne_tree
9561 }
9563 /* Otherwise, set the RM size proper for integral types... */
9570 /* ...or the Ada size for record and union types. */
9574 }
9576 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
9577 a type or object whose present alignment is ALIGN. If this alignment is
9578 valid, return it. Otherwise, give an error and return ALIGN. */
9580 static unsigned int
9582 {
9585 Node_Id gnat_error_node;
9587 /* Don't worry about checking alignment if alignment was not specified
9588 by the source program and we already posted an error for this entity. */
9592 /* Post the error on the alignment clause if any. Note, for the implicit
9593 base type of an array type, the alignment clause is on the first
9594 subtype. */
9602 gnat_error_node =
9605 else
9608 /* Within GCC, an alignment is an integer, so we must make sure a value is
9609 specified that fits in that range. Also, there is an upper bound to
9610 alignments we can support/allow. */
9618 {
9622 /* If the default alignment of "double" or larger scalar types is
9623 specifically capped and the new alignment is above the cap, do
9624 not post an error and change the alignment only if there is an
9625 alignment clause; this makes it possible to have the associated
9626 GCC type overaligned by default for performance reasons. */
9628 {
9629 Entity_Id gnat_type
9631 is_capped_double
9633 }
9635 {
9636 Entity_Id gnat_type
9638 is_capped_double
9640 }
9641 else
9645 {
9648 }
9649 else
9650 {
9657 }
9658 }
9659 else
9660 {
9664 }
9667 }
9669 /* Promote the alignment of GNU_TYPE for an object with GNU_SIZE corresponding
9670 to GNAT_ENTITY. Return a positive value on success or zero on failure. */
9672 static unsigned int
9674 {
9677 /* No point in promoting the alignment if this doesn't prevent BLKmode access
9678 to the object, in particular block copy, as this will for example disable
9679 the NRV optimization for it. No point in jumping through all the hoops
9680 needed in order to support BIGGEST_ALIGNMENT if we don't really have to.
9681 So we cap to the smallest alignment that corresponds to a known efficient
9682 memory access pattern, except for a full access entity. */
9684 {
9687 }
9688 else
9689 {
9692 }
9697 /* Do the promotion within the above limits. */
9703 else
9706 /* But make sure not to under-align the object. */
9710 /* And honor the minimum valid atomic alignment, if any. */
9711 #ifdef MINIMUM_ATOMIC_ALIGNMENT
9714 #endif
9717 }
9719 /* Return whether GNAT_ENTITY is a simple constant, i.e. it represents only
9720 its value and reading it has no side effects. */
9722 bool
9724 {
9730 }
9732 /* Verify that TYPE is something we can implement atomically. If not, issue
9733 an error for GNAT_ENTITY. COMPONENT_P is true if we are being called to
9734 process a component type. */
9736 static void
9738 {
9740 Node_Id gnat_node;
9741 machine_mode mode;
9744 tree size;
9746 /* If this is an anonymous base type, nothing to check, the error will be
9747 reported on the source type if need be. */
9756 /* Consider all aligned floating-point types atomic and any aligned types
9757 that are represented by integers no wider than a machine word. */
9758 scalar_int_mode int_mode;
9765 /* For the moment, also allow anything that has an alignment equal to its
9766 size and which is smaller than a word. */
9777 {
9778 const Pragma_Id pragma_id
9783 {
9786 }
9787 }
9795 else
9798 }
9800 /* Return true if TYPE is suitable for a type-generic atomic builtin. */
9802 static bool
9804 {
9809 scalar_int_mode imode;
9814 }
9816 /* Return the GCC atomic builtin based on CODE and sized for TYPE. */
9818 static tree
9820 {
9825 }
9827 /* Helper for intrin_profiles_compatible_p, to perform compatibility checks
9828 on the Ada/builtin argument lists for the INB binding. */
9830 static bool
9832 {
9838 /* Sequence position of the last argument we checked. */
9842 {
9846 /* If we've exhausted both lists simultaneously, we're done. */
9850 /* If the internal builtin uses a variable list, accept anything. */
9854 /* If we're done with the Ada args and not with the internal builtin
9855 args, or the other way around, complain. */
9857 {
9860 }
9863 {
9867 }
9869 /* Otherwise, check that types match for the current argument. */
9870 argpos++;
9872 {
9873 /* For vector builtins, issue an error to avoid an ICE. */
9875 post_error_ne_num
9878 else
9879 post_error_ne_num
9883 }
9888 }
9891 }
9893 /* Helper for intrin_profiles_compatible_p, to perform compatibility checks
9894 on the Ada/builtin return values for the INB binding. */
9896 static bool
9898 {
9902 /* Accept function imported as procedure, common and convenient. */
9906 /* Check return types compatibility otherwise. Note that this
9907 handles void/void as well. */
9909 {
9910 /* For vector builtins, issue an error to avoid an ICE. */
9914 else
9918 }
9921 }
9923 /* Check and return whether the Ada and gcc builtin profiles bound by INB are
9924 compatible. Issue relevant warnings when they are not.
9926 This is intended as a light check to diagnose the most obvious cases, not
9927 as a full fledged type compatibility predicate. It is the programmer's
9928 responsibility to ensure correctness of the Ada declarations in Imports,
9929 especially when binding straight to a compiler internal. */
9931 static bool
9933 {
9934 /* Check compatibility on return values and argument lists, each responsible
9935 for posting warnings as appropriate. Ensure use of the proper sloc for
9936 this purpose. */
9949 }
9951 /* Return a FIELD_DECL node modeled on OLD_FIELD. FIELD_TYPE is its type
9952 and RECORD_TYPE is the type of the parent. If SIZE is nonzero, it is the
9953 specified size for this field. POS_LIST is a position list describing
9954 the layout of OLD_FIELD and SUBST_LIST a substitution list to be applied
9955 to this layout. */
9957 static tree
9961 {
9973 /* If the position is now a constant, we can set it as the position of the
9974 field when we make it. Otherwise, we need to deal with it specially. */
9977 else
9980 new_field
9986 {
9988 /* Finalize the position. */
9997 }
10005 }
10007 /* Create the REP part of RECORD_TYPE with REP_TYPE. If MIN_SIZE is nonzero,
10008 it is the minimal size the REP_PART must have. */
10010 static tree
10012 {
10013 tree field;
10023 }
10025 /* Return the REP part of RECORD_TYPE, if any. Otherwise return NULL. */
10027 static tree
10029 {
10032 /* The REP part is the first field, internal, another record, and its name
10033 starts with an 'R'. */
10041 }
10043 /* Return the variant part of RECORD_TYPE, if any. Otherwise return NULL. */
10045 tree
10047 {
10048 tree field;
10050 /* The variant part is the only internal field that is a qualified union. */
10057 }
10059 /* Return a new variant part modeled on OLD_VARIANT_PART. VARIANT_LIST is
10060 the list of variants to be used and RECORD_TYPE is the type of the parent.
10061 POS_LIST is a position list describing the layout of fields present in
10062 OLD_VARIANT_PART and SUBST_LIST a substitution list to be applied to this
10063 layout. DEBUG_INFO_P is true if we need to write debug information. */
10065 static tree
10071 {
10079 /* First create the type of the variant part from that of the old one. */
10085 /* If the position of the variant part is constant, subtract it from the
10086 size of the type of the parent to get the new size. This manual CSE
10087 reduces the code size when not optimizing. */
10091 {
10101 first_bit));
10104 }
10105 else
10108 /* Now finish up the new variants and populate the union type. */
10110 {
10114 /* Skip variants that don't belong to this nesting level. */
10118 /* Retrieve the list of fields already added to the new variant. */
10122 /* If the old variant had a variant subpart, we need to create a new
10123 variant subpart and add it to the field list. */
10127 {
10128 tree new_variant_subpart
10131 debug_info_p);
10134 }
10136 /* Finish up the new variant and create the field. */
10141 new_field
10149 }
10151 /* Finish up the union type and create the variant part. Note that we don't
10152 reverse the field list because VARIANT_LIST has been traversed in reverse
10153 order. */
10158 new_variant_part
10164 /* With multiple discriminants it is possible for an inner variant to be
10165 statically selected while outer ones are not; in this case, the list
10166 of fields of the inner variant is not flattened and we end up with a
10167 qualified union with a single member. Drop the useless container. */
10169 {
10178 }
10181 }
10183 /* Copy the size (and alignment and alias set) from OLD_TYPE to NEW_TYPE,
10184 which are both RECORD_TYPE, after applying the substitutions described
10185 in SUBST_LIST. */
10187 static void
10190 {
10214 SET_TYPE_ADA_SIZE
10218 /* Finalize the size. */
10221 }
10223 /* Return true if DISC is a stored discriminant of RECORD_TYPE. */
10227 {
10234 else
10236 }
10238 /* Copy the layout from {GNAT,GNU}_OLD_TYPE to {GNAT,GNU}_NEW_TYPE, which are
10239 both record types, after applying the substitutions described in SUBST_LIST.
10240 DEBUG_INFO_P is true if we need to write debug information for NEW_TYPE. */
10242 static void
10244 Entity_Id gnat_old_type,
10245 tree gnu_new_type,
10246 tree gnu_old_type,
10249 {
10256 /* Look for REP and variant parts in the old type. */
10260 /* If there is a variant part, we must compute whether the constraints
10261 statically select a particular variant. If so, we simply drop the
10262 qualified union and flatten the list of fields. Otherwise we will
10263 build a new qualified union for the variants that are still relevant. */
10265 {
10270 gnu_variant_list
10272 is_subtype
10273 ? Empty
10274 : Variant_Part
10276 subst_list,
10277 vNULL);
10279 /* If all the qualifiers are unconditionally true, the innermost variant
10280 is statically selected. */
10284 {
10287 }
10289 /* Otherwise, create the new variants. */
10292 {
10295 tree suffix
10305 }
10306 }
10307 else
10308 {
10311 }
10313 /* Make a list of fields and their position in the old type. */
10314 tree gnu_pos_list
10320 /* Now go down every component in the new type and compute its size and
10321 position from those of the component in the old type and the stored
10322 constraints of the new type. */
10335 {
10345 /* If the type is the same, retrieve the GCC type from the
10346 old field to take into account possible adjustments. */
10349 else
10352 /* If there was a component clause, the field types must be the same
10353 for the old and new types, so copy the data from the old field to
10354 avoid recomputation here. Also if the field is justified modular
10355 and the optimization in gnat_to_gnu_field was applied. */
10361 {
10364 }
10366 /* If the old field was packed and of constant size, we have to get the
10367 old size here as it might differ from what the Etype conveys and the
10368 latter might overlap with the following field. Try to arrange the
10369 type for possible better packing along the way. */
10372 {
10378 }
10380 else
10383 /* If the context of the old field is the old type or its REP part,
10384 put the field directly in the new type; otherwise look up the
10385 context in the variant list and put the field either in the new
10386 type if there is a selected variant or in one new variant. */
10390 else
10391 {
10393 tree rep_part;
10403 else
10404 /* The front-end may pass us zombie components if it fails to
10405 recognize that a constrain statically selects a particular
10406 variant. Discard them. */
10408 }
10410 /* Now create the new field modeled on the old one. */
10411 gnu_field
10417 /* If the context is a variant, put it in the new variant directly. */
10419 {
10421 {
10424 }
10425 else
10426 {
10429 }
10430 }
10432 /* To match the layout crafted in components_to_record, if this is
10433 the _Tag or _Parent field, put it before any other fields. */
10437 /* Similarly, if this is the _Controller field, put it before the
10438 other fields except for the _Tag or _Parent field. */
10440 {
10443 }
10445 /* Otherwise, put it after the other fields. */
10446 else
10447 {
10449 {
10454 }
10455 else
10456 {
10459 }
10460 }
10462 /* For a stored discriminant in a derived type, replace the field. */
10464 {
10467 }
10468 else
10470 }
10472 /* Put the fields with fixed position in order of increasing position. */
10476 /* Put the fields with variable position at the end. */
10480 /* If there is a variant list and no selected variant, we need to create the
10481 nest of variant parts from the old nest. */
10483 {
10487 /* Same processing as above for the fields of each variant. */
10489 {
10496 }
10498 tree new_variant_part
10504 }
10509 /* If NEW_TYPE is a subtype, it inherits all the attributes from OLD_TYPE.
10510 Otherwise sizes and alignment must be computed independently. */
10514 /* Now go through the entities again looking for itypes that we have not yet
10515 elaborated (e.g. Etypes of fields that have Original_Components). */
10524 }
10526 /* Associate to the implementation type of a packed array type specified by
10527 GNU_TYPE, which is the translation of GNAT_ENTITY, the original array type
10528 if it has been translated. This association is a parallel type for GNAT
10529 encodings or a debug type for standard DWARF. Note that for standard DWARF,
10530 we also want to get the original type name and therefore we return it. */
10532 static tree
10534 {
10535 const Entity_Id gnat_original_array_type
10537 tree gnu_original_array_type;
10550 {
10553 }
10554 else
10555 {
10562 }
10563 }
10565 /* Given a type T, a FIELD_DECL F, and a replacement value R, return an
10566 equivalent type with adjusted size expressions where all occurrences
10567 of references to F in a PLACEHOLDER_EXPR have been replaced by R.
10569 The function doesn't update the layout of the type, i.e. it assumes
10570 that the substitution is purely formal. That's why the replacement
10571 value R must itself contain a PLACEHOLDER_EXPR. */
10573 tree
10575 {
10576 tree nt;
10581 {
10587 /* First the domain types of arrays. */
10590 {
10602 SET_TYPE_INDEX_TYPE
10606 }
10608 /* Then the subtypes. */
10611 {
10623 }
10636 /* These should never show up here. */
10640 {
10660 }
10665 {
10667 tree field;
10669 /* Start out with no fields, make new fields, and chain them
10670 in. If we haven't actually changed the type of any field,
10671 discard everything we've done and return the old type. */
10676 {
10681 {
10684 }
10688 {
10691 }
10693 /* Do the substitution inside the qualifier, if any. */
10695 {
10698 {
10701 }
10702 }
10709 }
10719 }
10723 }
10724 }
10726 /* Return the RM size of GNU_TYPE. This is the actual number of bits
10727 needed to represent the object. */
10729 tree
10731 {
10732 /* For integral types, we store the RM size explicitly. */
10736 /* If the type contains a template, return the padded size of the template
10737 plus the RM size of the actual data. */
10740 return
10745 /* For record or union types, we store the size explicitly. */
10751 /* For other types, this is just the size. */
10753 }
10755 /* Return the name to be used for GNAT_ENTITY. If a type, create a
10756 fully-qualified name, possibly with type information encoding.
10757 Otherwise, return the name. */
10761 {
10764 }
10766 tree
10768 {
10771 }
10773 /* Return an identifier representing the external name to be used for
10774 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
10775 and the specified suffix. */
10777 tree
10779 {
10787 /* A variable using the Stdcall convention lives in a DLL. We adjust
10788 its name to use the jump table, the _imp__NAME contains the address
10789 for the NAME variable. */
10792 {
10798 }
10801 }
10803 /* Given GNU_NAME, an IDENTIFIER_NODE containing a name and SUFFIX, a
10804 string, return a new IDENTIFIER_NODE that is the concatenation of
10805 the name followed by "___" and the specified suffix. */
10807 tree
10809 {
10816 }
10818 /* Initialize the data structures of the decl.cc module. */
10820 void
10822 {
10823 /* Initialize the cache of annotated values. */
10826 /* Initialize the association of dummy types with subprograms. */
10828 }
10830 /* Destroy the data structures of the decl.cc module. */
10832 void
10834 {
10835 /* Destroy the cache of annotated values. */
10839 /* Destroy the association of dummy types with subprograms. */
10842 }