| blob | 7a18d32752ae71828a2356a71a144f3d23cacb16 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2011, 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 ****************************************************************************/
53 /* Convention_Stdcall should be processed in a specific way on 32 bits
54 Windows targets only. The macro below is a helper to avoid having to
55 check for a Windows specific attribute throughout this unit. */
57 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
58 #ifdef TARGET_64BIT
59 #define Has_Stdcall_Convention(E) \
60 (!TARGET_64BIT && Convention (E) == Convention_Stdcall)
61 #else
62 #define Has_Stdcall_Convention(E) (Convention (E) == Convention_Stdcall)
63 #endif
64 #else
65 #define Has_Stdcall_Convention(E) 0
66 #endif
68 /* Stack realignment is necessary for functions with foreign conventions when
69 the ABI doesn't mandate as much as what the compiler assumes - that is, up
70 to PREFERRED_STACK_BOUNDARY.
72 Such realignment can be requested with a dedicated function type attribute
73 on the targets that support it. We define FOREIGN_FORCE_REALIGN_STACK to
74 characterize the situations where the attribute should be set. We rely on
75 compiler configuration settings for 'main' to decide. */
77 #ifdef MAIN_STACK_BOUNDARY
78 #define FOREIGN_FORCE_REALIGN_STACK \
79 (MAIN_STACK_BOUNDARY < PREFERRED_STACK_BOUNDARY)
80 #else
81 #define FOREIGN_FORCE_REALIGN_STACK 0
82 #endif
84 struct incomplete
85 {
87 tree old_type;
88 Entity_Id full_type;
89 };
91 /* These variables are used to defer recursively expanding incomplete types
92 while we are processing an array, a record or a subprogram type. */
96 /* This variable is used to delay expanding From_With_Type types until the
97 end of the spec. */
100 /* These variables are used to defer finalizing types. The element of the
101 list is the TYPE_DECL associated with the type. */
106 tree discriminant;
107 tree replacement;
114 /* The type of the variant. */
115 tree type;
117 /* The associated field. */
118 tree field;
120 /* The value of the qualifier. */
121 tree qual;
123 /* The record associated with this variant. */
124 tree record;
130 /* A hash table used to cache the result of annotate_value. */
134 enum alias_set_op
135 {
136 ALIAS_SET_COPY,
137 ALIAS_SET_SUBSET,
138 ALIAS_SET_SUPERSET
139 };
186 /* The relevant constituents of a subprogram binding to a GCC builtin. Used
187 to pass around calls performing profile compatibility checks. */
196 \f
197 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
198 entity, return the equivalent GCC tree for that entity (a ..._DECL node)
199 and associate the ..._DECL node with the input GNAT defining identifier.
201 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
202 initial value (in GCC tree form). This is optional for a variable. For
203 a renamed entity, GNU_EXPR gives the object being renamed.
205 DEFINITION is nonzero if this call is intended for a definition. This is
206 used for separate compilation where it is necessary to know whether an
207 external declaration or a definition must be created if the GCC equivalent
208 was not created previously. The value of 1 is normally used for a nonzero
209 DEFINITION, but a value of 2 is used in special circumstances, defined in
210 the code. */
212 tree
214 {
215 /* Contains the kind of the input GNAT node. */
217 /* True if this is a type. */
219 /* True if debug info is requested for this entity. */
221 /* True if this entity is to be considered as imported. */
222 const bool imported_p
224 /* For a type, contains the equivalent GNAT node to be used in gigi. */
226 /* Temporary used to walk the GNAT tree. */
227 Entity_Id gnat_temp;
228 /* Contains the GCC DECL node which is equivalent to the input GNAT node.
229 This node will be associated with the GNAT node by calling at the end
230 of the `switch' statement. */
232 /* Contains the GCC type to be used for the GCC node. */
234 /* Contains the GCC size tree to be used for the GCC node. */
236 /* Contains the GCC name to be used for the GCC node. */
237 tree gnu_entity_name;
238 /* True if we have already saved gnu_decl as a GNAT association. */
240 /* True if we incremented defer_incomplete_level. */
242 /* True if we incremented force_global. */
244 /* True if we should check to see if elaborated during processing. */
246 /* True if we made GNU_DECL and its type here. */
248 /* Size and alignment of the GCC node, if meaningful. */
250 /* Contains the list of attributes directly attached to the entity. */
253 /* Since a use of an Itype is a definition, process it as such if it
254 is not in a with'ed unit. */
256 && is_type
260 {
261 /* Ensure that we are in a subprogram mentioned in the Scope chain of
262 this entity, our current scope is global, or we encountered a task
263 or entry (where we can't currently accurately check scoping). */
266 {
269 }
274 {
279 gnat_temp
291 && (current_function_decl
293 {
296 }
297 }
299 /* This abort means the Itype has an incorrect scope, i.e. that its
300 scope does not correspond to the subprogram it is declared in. */
302 }
304 /* If we've already processed this entity, return what we got last time.
305 If we are defining the node, we should not have already processed it.
306 In that case, we will abort below when we try to save a new GCC tree
307 for this object. We also need to handle the case of getting a dummy
308 type when a Full_View exists. */
311 {
318 {
319 gnu_decl
323 }
326 }
328 /* If this is a numeric or enumeral type, or an access type, a nonzero
329 Esize must be specified unless it was specified by the programmer. */
339 /* The RM size must be specified for all discrete and fixed-point types. */
343 /* If we get here, it means we have not yet done anything with this entity.
344 If we are not defining it, it must be a type or an entity that is defined
345 elsewhere or externally, otherwise we should have defined it already. */
347 || type_annotate_only
348 || is_type
355 /* Get the name of the entity and set up the line number and filename of
356 the original definition for use in any decl we make. */
360 /* For cases when we are not defining (i.e., we are referencing from
361 another compilation unit) public entities, show we are at global level
362 for the purpose of computing scopes. Don't do this for components or
363 discriminants since the relevant test is whether or not the record is
364 being defined. Don't do this for constants either as we'll look into
365 their defining expression in the local context. */
374 /* Handle any attributes directly attached to the entity. */
378 /* Do some common processing for types. */
380 {
381 /* Compute the equivalent type to be used in gigi. */
384 /* Machine_Attributes on types are expected to be propagated to
385 subtypes. The corresponding Gigi_Rep_Items are only attached
386 to the first subtype though, so we handle the propagation here. */
393 /* Compute a default value for the size of the type. */
396 {
404 else
409 }
410 else
412 }
415 {
417 /* If this is a use of a deferred constant without address clause,
418 get its full definition. */
422 {
423 gnu_decl
427 }
429 /* If we have an external constant that we are not defining, get the
430 expression that is was defined to represent. We may throw it away
431 later if it is not a constant. But do not retrieve the expression
432 if it is an allocator because the designated type might be dummy
433 at this point. */
439 {
442 /* The expression may contain N_Expression_With_Actions nodes and
443 thus object declarations from other units. In this case, even
444 though the expression will eventually be discarded since not a
445 constant, the declarations would be stuck either in the global
446 varpool or in the current scope. Therefore we force the local
447 context and create a fake scope that we'll zap at the end. */
449 {
452 }
460 }
462 /* Ignore deferred constant definitions without address clause since
463 they are processed fully in the front-end. If No_Initialization
464 is set, this is not a deferred constant but a constant whose value
465 is built manually. And constants that are renamings are handled
466 like variables. */
468 && !gnu_expr
472 {
476 }
478 /* Ignore constant definitions already marked with the error node. See
479 the N_Object_Declaration case of gnat_to_gnu for the rationale. */
481 && gnu_expr
484 {
487 }
492 /* We used to special case VMS exceptions here to directly map them to
493 their associated condition code. Since this code had to be masked
494 dynamically to strip off the severity bits, this caused trouble in
495 the GCC/ZCX case because the "type" pointers we store in the tables
496 have to be static. We now don't special case here anymore, and let
497 the regular processing take place, which leaves us with a regular
498 exception data object for VMS exceptions too. The condition code
499 mapping is taken care of by the front end and the bitmasking by the
500 run-time library. */
505 {
506 /* The GNAT record where the component was defined. */
509 /* If the variable is an inherited record component (in the case of
510 extended record types), just return the inherited entity, which
511 must be a FIELD_DECL. Likewise for discriminants.
512 For discriminants of untagged records which have explicit
513 stored discriminants, return the entity for the corresponding
514 stored discriminant. Also use Original_Record_Component
515 if the record has a private extension. */
518 {
519 gnu_decl
524 }
526 /* If the enclosing record has explicit stored discriminants,
527 then it is an untagged record. If the Corresponding_Discriminant
528 is not empty then this must be a renamed discriminant and its
529 Original_Record_Component must point to the corresponding explicit
530 stored discriminant (i.e. we should have taken the previous
531 branch). */
534 {
535 /* A tagged record has no explicit stored discriminants. */
538 gnu_decl
543 }
547 {
552 }
554 /* If the enclosing record has explicit stored discriminants, then
555 it is an untagged record. If the Corresponding_Discriminant
556 is not empty then this must be a renamed discriminant and its
557 Original_Record_Component must point to the corresponding explicit
558 stored discriminant (i.e. we should have taken the first
559 branch). */
565 /* Otherwise, if we are not defining this and we have no GCC type
566 for the containing record, make one for it. Then we should
567 have made our own equivalent. */
569 {
570 /* ??? If this is in a record whose scope is a protected
571 type and we have an Original_Record_Component, use it.
572 This is a workaround for major problems in protected type
573 handling. */
580 {
581 gnu_decl
587 }
593 }
595 else
596 /* Here we have no GCC type and this is a reference rather than a
597 definition. This should never happen. Most likely the cause is
598 reference before declaration in the gnat tree for gnat_entity. */
600 }
606 /* Simple variables, loop variables, Out parameters and exceptions. */
607 object:
608 {
609 bool const_flag
624 tree gnu_object_size;
627 {
631 else
633 }
635 /* Get the type after elaborating the renamed object. */
638 /* If this is a standard exception definition, then use the standard
639 exception type. This is necessary to make sure that imported and
640 exported views of exceptions are properly merged in LTO mode. */
645 /* For a debug renaming declaration, build a debug-only entity. */
647 {
648 /* Force a non-null value to make sure the symbol is retained. */
652 integer_minus_one_node));
659 }
661 /* If this is a loop variable, its type should be the base type.
662 This is because the code for processing a loop determines whether
663 a normal loop end test can be done by comparing the bounds of the
664 loop against those of the base type, which is presumed to be the
665 size used for computation. But this is not correct when the size
666 of the subtype is smaller than the type. */
670 /* Reject non-renamed objects whose type is an unconstrained array or
671 any object whose type is a dummy type or void. */
676 {
679 force_global--;
681 }
683 /* If an alignment is specified, use it if valid. Note that exceptions
684 are objects but don't have an alignment. We must do this before we
685 validate the size, since the alignment can affect the size. */
687 {
693 /* No point in changing the type if there is an address clause
694 as the final type of the object will be a reference type. */
697 else
698 {
701 gnu_type
705 /* If a padding record was made, declare it now since it will
706 never be declared otherwise. This is necessary to ensure
707 that its subtrees are properly marked. */
711 }
712 }
714 /* If we are defining the object, see if it has a Size and validate it
715 if so. If we are not defining the object and a Size clause applies,
716 simply retrieve the value. We don't want to ignore the clause and
717 it is expected to have been validated already. Then get the new
718 type, if any. */
727 {
728 gnu_type
734 }
736 /* If this object has self-referential size, it must be a record with
737 a default discriminant. We are supposed to allocate an object of
738 the maximum size in this case, unless it is a constant with an
739 initializing expression, in which case we can get the size from
740 that. Note that the resulting size may still be a variable, so
741 this may end up with an indirect allocation. */
744 {
746 {
749 {
750 /* If the initializing expression is itself a constant,
751 despite having a nominal type with self-referential
752 size, we can get the size directly from it. */
754 && TYPE_IS_PADDING_P
758 || DECL_READONLY_ONCE_ELAB
761 else
762 gnu_size
764 }
765 else
767 }
768 /* We may have no GNU_EXPR because No_Initialization is
769 set even though there's an Expression. */
774 gnu_size
776 (Etype
778 else
779 {
782 }
783 }
785 /* If the size is zero byte, make it one byte since some linkers have
786 troubles with zero-sized objects. If the object will have a
787 template, that will make it nonzero so don't bother. Also avoid
788 doing that for an object renaming or an object with an address
789 clause, as we would lose useful information on the view size
790 (e.g. for null array slices) and we are not allocating the object
791 here anyway. */
804 /* If this is an object with no specified size and alignment, and
805 if either it is atomic or we are not optimizing alignment for
806 space and it is composite and not an exception, an Out parameter
807 or a reference to another object, and the size of its type is a
808 constant, set the alignment to the smallest one which is not
809 smaller than the size, with an appropriate cap. */
818 && !imported_p
822 {
823 /* No point in jumping through all the hoops needed in order
824 to support BIGGEST_ALIGNMENT if we don't really have to.
825 So we cap to the smallest alignment that corresponds to
826 a known efficient memory access pattern of the target. */
828 ? BIGGEST_ALIGNMENT
834 else
837 /* But make sure not to under-align the object. */
841 /* And honor the minimum valid atomic alignment, if any. */
842 #ifdef MINIMUM_ATOMIC_ALIGNMENT
845 #endif
846 }
848 /* If the object is set to have atomic components, find the component
849 type and validate it.
851 ??? Note that we ignore Has_Volatile_Components on objects; it's
852 not at all clear what to do in that case. */
854 {
863 }
865 /* Now check if the type of the object allows atomic access. Note
866 that we must test the type, even if this object has size and
867 alignment to allow such access, because we will be going inside
868 the padded record to assign to the object. We could fix this by
869 always copying via an intermediate value, but it's not clear it's
870 worth the effort. */
874 /* If this is an aliased object with an unconstrained nominal subtype,
875 make a type that includes the template. */
879 {
880 tree gnu_fat
882 gnu_type
886 debug_info_p);
887 }
889 #ifdef MINIMUM_ATOMIC_ALIGNMENT
890 /* If the size is a constant and no alignment is specified, force
891 the alignment to be the minimum valid atomic alignment. The
892 restriction on constant size avoids problems with variable-size
893 temporaries; if the size is variable, there's no issue with
894 atomic access. Also don't do this for a constant, since it isn't
895 necessary and can interfere with constant replacement. Finally,
896 do not do it for Out parameters since that creates an
897 size inconsistency with In parameters. */
906 #endif
908 /* Make a new type with the desired size and alignment, if needed.
909 But do not take into account alignment promotions to compute the
910 size of the object. */
913 {
920 /* If a padding record was made, declare it now since it will
921 never be declared otherwise. This is necessary to ensure
922 that its subtrees are properly marked. */
926 }
928 /* If this is a renaming, avoid as much as possible to create a new
929 object. However, in several cases, creating it is required.
930 This processing needs to be applied to the raw expression so
931 as to make it more likely to rename the underlying object. */
933 {
936 /* If the renamed object had padding, strip off the reference
937 to the inner object and reset our type. */
940 /* Strip useless conversions around the object. */
942 && gnat_types_compatible_p
945 {
948 }
950 /* Case 1: If this is a constant renaming stemming from a function
951 call, treat it as a normal object whose initial value is what
952 is being renamed. RM 3.3 says that the result of evaluating a
953 function call is a constant object. As a consequence, it can
954 be the inner object of a constant renaming. In this case, the
955 renaming must be fully instantiated, i.e. it cannot be a mere
956 reference to (part of) an existing object. */
958 {
964 }
966 /* Otherwise, see if we can proceed with a stabilized version of
967 the renamed entity or if we need to make a new object. */
969 {
973 /* Case 2: If the renaming entity need not be materialized and
974 the renamed expression is something we can stabilize, use
975 that for the renaming. At the global level, we can only do
976 this if we know no SAVE_EXPRs need be made, because the
977 expression we return might be used in arbitrary conditional
978 branches so we must force the evaluation of the SAVE_EXPRs
979 immediately and this requires a proper function context.
980 Note that an external constant is at the global level. */
986 {
987 maybe_stable_expr
991 {
992 /* ??? No DECL_EXPR is created so we need to mark
993 the expression manually lest it is shared. */
1003 }
1005 /* The stabilization failed. Keep maybe_stable_expr
1006 untouched here to let the pointer case below know
1007 about that failure. */
1008 }
1010 /* Case 3: If this is a constant renaming and creating a
1011 new object is allowed and cheap, treat it as a normal
1012 object whose initial value is what is being renamed. */
1014 && !Is_Composite_Type
1016 ;
1018 /* Case 4: Make this into a constant pointer to the object we
1019 are to rename and attach the object to the pointer if it is
1020 something we can stabilize.
1022 From the proper scope, attached objects will be referenced
1023 directly instead of indirectly via the pointer to avoid
1024 subtle aliasing problems with non-addressable entities.
1025 They have to be stable because we must not evaluate the
1026 variables in the expression every time the renaming is used.
1027 The pointer is called a "renaming" pointer in this case.
1029 In the rare cases where we cannot stabilize the renamed
1030 object, we just make a "bare" pointer, and the renamed
1031 entity is always accessed indirectly through it. */
1032 else
1033 {
1038 /* If the previous attempt at stabilizing failed, there
1039 is no point in trying again and we reuse the result
1040 without attaching it to the pointer. In this case it
1041 will only be used as the initializing expression of
1042 the pointer and thus needs no special treatment with
1043 regard to multiple evaluations. */
1045 ;
1047 /* Otherwise, try to stabilize and attach the expression
1048 to the pointer if the stabilization succeeds.
1050 Note that this might introduce SAVE_EXPRs and we don't
1051 check whether we're at the global level or not. This
1052 is fine since we are building a pointer initializer and
1053 neither the pointer nor the initializing expression can
1054 be accessed before the pointer elaboration has taken
1055 place in a correct program.
1057 These SAVE_EXPRs will be evaluated at the right place
1058 by either the evaluation of the initializer for the
1059 non-global case or the elaboration code for the global
1060 case, and will be attached to the elaboration procedure
1061 in the latter case. */
1062 else
1063 {
1064 maybe_stable_expr
1070 /* Attaching is actually performed downstream, as soon
1071 as we have a VAR_DECL for the pointer we make. */
1072 }
1075 maybe_stable_expr);
1079 }
1080 }
1081 }
1083 /* Make a volatile version of this object's type if we are to make
1084 the object volatile. We also interpret 13.3(19) conservatively
1085 and disallow any optimizations for such a non-constant object. */
1087 || (!const_flag
1090 || imported_p
1097 /* If we are defining an aliased object whose nominal subtype is
1098 unconstrained, the object is a record that contains both the
1099 template and the object. If there is an initializer, it will
1100 have already been converted to the right type, but we need to
1101 create the template if there is no initializer. */
1103 && !gnu_expr
1106 /* Beware that padding might have been introduced above. */
1109 == RECORD_TYPE
1110 && TYPE_CONTAINS_TEMPLATE_P
1112 {
1113 tree template_field
1120 NULL_TREE);
1123 }
1125 /* Convert the expression to the type of the object except in the
1126 case where the object's type is unconstrained or the object's type
1127 is a padded record whose field is of self-referential size. In
1128 the former case, converting will generate unnecessary evaluations
1129 of the CONSTRUCTOR to compute the size and in the latter case, we
1130 want to only copy the actual data. */
1135 && CONTAINS_PLACEHOLDER_P
1139 /* If this is a pointer that doesn't have an initializing expression,
1140 initialize it to NULL, unless the object is imported. */
1143 && !gnu_expr
1147 /* If we are defining the object and it has an Address clause, we must
1148 either get the address expression from the saved GCC tree for the
1149 object if it has a Freeze node, or elaborate the address expression
1150 here since the front-end has guaranteed that the elaboration has no
1151 effects in this case. */
1153 {
1155 tree gnu_address
1161 /* Ignore the size. It's either meaningless or was handled
1162 above. */
1164 /* Convert the type of the object to a reference type that can
1165 alias everything as per 13.3(19). */
1166 gnu_type
1170 const_flag
1174 /* If this is a deferred constant, the initializer is attached to
1175 the full view. */
1177 gnu_expr
1178 = gnat_to_gnu
1181 /* If we don't have an initializing expression for the underlying
1182 variable, the initializing expression for the pointer is the
1183 specified address. Otherwise, we have to make a COMPOUND_EXPR
1184 to assign both the address and the initial value. */
1187 else
1188 gnu_expr
1190 build_binary_op
1193 gnu_address),
1194 gnu_expr),
1195 gnu_address);
1196 }
1198 /* If it has an address clause and we are not defining it, mark it
1199 as an indirect object. Likewise for Stdcall objects that are
1200 imported. */
1204 {
1205 /* Convert the type of the object to a reference type that can
1206 alias everything as per 13.3(19). */
1207 gnu_type
1211 /* No point in taking the address of an initializing expression
1212 that isn't going to be used. */
1215 /* If it has an address clause whose value is known at compile
1216 time, make the object a CONST_DECL. This will avoid a
1217 useless dereference. */
1219 {
1220 Node_Id gnat_address
1224 {
1227 }
1228 }
1231 }
1233 /* If we are at top level and this object is of variable size,
1234 make the actual type a hidden pointer to the real type and
1235 make the initializer be a memory allocation and initialization.
1236 Likewise for objects we aren't defining (presumed to be
1237 external references from other packages), but there we do
1238 not set up an initialization.
1240 If the object's size overflows, make an allocator too, so that
1241 Storage_Error gets raised. Note that we will never free
1242 such memory, so we presume it never will get allocated. */
1245 || !definition
1249 || !definition
1251 {
1256 /* In case this was a aliased object whose nominal subtype is
1257 unconstrained, the pointer above will be a thin pointer and
1258 build_allocator will automatically make the template.
1260 If we have a template initializer only (that we made above),
1261 pretend there is none and rely on what build_allocator creates
1262 again anyway. Otherwise (if we have a full initializer), get
1263 the data part and feed that to build_allocator.
1265 If we are elaborating a mutable object, tell build_allocator to
1266 ignore a possibly simpler size from the initializer, if any, as
1267 we must allocate the maximum possible size in this case. */
1269 {
1274 {
1275 gnu_alloc_type
1282 else
1283 gnu_expr
1284 = build_component_ref
1288 }
1293 gnat_entity);
1295 gnu_expr
1299 }
1300 else
1301 {
1304 }
1305 }
1307 /* If this object would go into the stack and has an alignment larger
1308 than the largest stack alignment the back-end can honor, resort to
1309 a variable of "aligning type". */
1312 {
1313 /* Create the new variable. No need for extra room before the
1314 aligned field as this is in automatic storage. */
1315 tree gnu_new_type
1319 tree gnu_new_var
1324 /* Initialize the aligned field if we have an initializer. */
1326 add_stmt_with_node
1328 build_component_ref
1331 gnu_expr),
1332 gnat_entity);
1334 /* And setup this entity as a reference to the aligned field. */
1336 gnu_expr
1337 = build_unary_op
1345 }
1351 /* Convert the expression to the type of the object except in the
1352 case where the object's type is unconstrained or the object's type
1353 is a padded record whose field is of self-referential size. In
1354 the former case, converting will generate unnecessary evaluations
1355 of the CONSTRUCTOR to compute the size and in the latter case, we
1356 want to only copy the actual data. */
1361 && CONTAINS_PLACEHOLDER_P
1365 /* If this name is external or there was a name specified, use it,
1366 unless this is a VMS exception object since this would conflict
1367 with the symbol we need to export in addition. Don't use the
1368 Interface_Name if there is an address clause (see CD30005). */
1377 /* If this is an aggregate constant initialized to a constant, force it
1378 to be statically allocated. This saves an initialization copy. */
1380 && const_flag
1389 /* Now create the variable or the constant and set various flags. */
1390 gnu_decl
1394 gnat_entity);
1398 /* If we are defining an Out parameter and optimization isn't enabled,
1399 create a fake PARM_DECL for debugging purposes and make it point to
1400 the VAR_DECL. Suppress debug info for the latter but make sure it
1401 will live on the stack so that it can be accessed from within the
1402 debugger through the PARM_DECL. */
1404 {
1411 }
1413 /* If this is a renaming pointer, attach the renamed object to it and
1414 register it if we are at the global level. Note that an external
1415 constant is at the global level. */
1417 {
1420 {
1423 }
1424 }
1426 /* If this is a constant and we are defining it or it generates a real
1427 symbol at the object level and we are referencing it, we may want
1428 or need to have a true variable to represent it:
1429 - if optimization isn't enabled, for debugging purposes,
1430 - if the constant is public and not overlaid on something else,
1431 - if its address is taken,
1432 - if either itself or its type is aliased. */
1441 {
1442 tree gnu_corr_var
1446 gnat_entity);
1450 /* As debugging information will be generated for the variable,
1451 do not generate debugging information for the constant. */
1454 else
1456 }
1458 /* If this is a constant, even if we don't need a true variable, we
1459 may need to avoid returning the initializer in every case. That
1460 can happen for the address of a (constant) constructor because,
1461 upon dereferencing it, the constructor will be reinjected in the
1462 tree, which may not be valid in every case; see lvalue_required_p
1463 for more details. */
1467 /* If this object is declared in a block that contains a block with an
1468 exception handler, and we aren't using the GCC exception mechanism,
1469 we must force this variable in memory in order to avoid an invalid
1470 optimization. */
1475 /* If we are defining an object with variable size or an object with
1476 fixed size that will be dynamically allocated, and we are using the
1477 setjmp/longjmp exception mechanism, update the setjmp buffer. */
1490 gnat_entity);
1492 /* Back-annotate Esize and Alignment of the object if not already
1493 known. Note that we pick the values of the type, not those of
1494 the object, to shield ourselves from low-level platform-dependent
1495 adjustments like alignment promotion. This is both consistent with
1496 all the treatment above, where alignment and size are set on the
1497 type of the object and not on the object directly, and makes it
1498 possible to support all confirming representation clauses. */
1501 }
1505 /* Return a TYPE_DECL for "void" that we previously made. */
1510 /* A special case: for the types Character and Wide_Character in
1511 Standard, we do not list all the literals. So if the literals
1512 are not specified, make this an unsigned type. */
1514 {
1518 /* Set TYPE_STRING_FLAG for Character and Wide_Character types.
1519 This is needed by the DWARF-2 back-end to distinguish between
1520 unsigned integer types and character types. */
1523 }
1525 {
1526 /* We have a list of enumeral constants in First_Literal. We make a
1527 CONST_DECL for each one and build into GNU_LITERAL_LIST the list to
1528 be placed into TYPE_FIELDS. Each node in the list is a TREE_LIST
1529 whose TREE_VALUE is the literal name and whose TREE_PURPOSE is the
1530 value of the literal. But when we have a regular boolean type, we
1531 simplify this a little by using a BOOLEAN_TYPE. */
1535 Entity_Id gnat_literal;
1539 else
1547 {
1548 tree gnu_value
1550 tree gnu_literal
1554 /* Do not generate debug info for individual enumerators. */
1559 }
1564 /* Note that the bounds are updated at the end of this function
1565 to avoid an infinite recursion since they refer to the type. */
1566 }
1572 /* For integer types, just make a signed type the appropriate number
1573 of bits. */
1578 {
1579 /* For modular types, make the unsigned type of the proper number
1580 of bits and then set up the modulus, if required. */
1583 /* Packed array types are supposed to be subtypes only. */
1588 /* Get the modulus in this type. If it overflows, assume it is because
1589 it is equal to 2**Esize. Note that there is no overflow checking
1590 done on unsigned type, so we detect the overflow by looking for
1591 a modulus of zero, which is otherwise invalid. */
1595 {
1600 }
1602 /* If the upper bound is not maximal, make an extra subtype. */
1605 {
1612 }
1613 }
1622 /* For integral subtypes, we make a new INTEGER_TYPE. Note that we do
1623 not want to call create_range_type since we would like each subtype
1624 node to be distinct. ??? Historically this was in preparation for
1625 when memory aliasing is implemented, but that's obsolete now given
1626 the call to relate_alias_sets below.
1628 The TREE_TYPE field of the INTEGER_TYPE points to the base type;
1629 this fact is used by the arithmetic conversion functions.
1631 We elaborate the Ancestor_Subtype if it is not in the current unit
1632 and one of our bounds is non-static. We do this to ensure consistent
1633 naming in the case where several subtypes share the same bounds, by
1634 elaborating the first such subtype first, thus using its name. */
1643 /* Set the precision to the Esize except for bit-packed arrays. */
1648 /* This should be an unsigned type if the base type is unsigned or
1649 if the lower bound is constant and non-negative or if the type
1650 is biased. */
1655 else
1659 SET_TYPE_RM_MIN_VALUE
1667 SET_TYPE_RM_MAX_VALUE
1675 /* One of the above calls might have caused us to be elaborated,
1676 so don't blow up if so. */
1678 {
1681 }
1686 /* Attach the TYPE_STUB_DECL in case we have a parallel type. */
1690 /* Inherit our alias set from what we're a subtype of. Subtypes
1691 are not different types and a pointer can designate any instance
1692 within a subtype hierarchy. */
1695 /* For a packed array, make the original array type a parallel type. */
1700 gnat_to_gnu_type
1703 discrete_type:
1705 /* We have to handle clauses that under-align the type specially. */
1708 && Present
1711 {
1715 }
1717 /* If the type we are dealing with represents a bit-packed array,
1718 we need to have the bits left justified on big-endian targets
1719 and right justified on little-endian targets. We also need to
1720 ensure that when the value is read (e.g. for comparison of two
1721 such values), we only get the good bits, since the unused bits
1722 are uninitialized. Both goals are accomplished by wrapping up
1723 the modular type in an enclosing record type. */
1726 {
1729 /* Set the RM size before wrapping up the original type. */
1734 /* Create a stripped-down declaration, mainly for debugging. */
1738 /* Now save it and build the enclosing record type. */
1748 /* Propagate the alignment of the modular type to the record type,
1749 unless there is an alignment clause that under-aligns the type.
1750 This means that bit-packed arrays are given "ceil" alignment for
1751 their size by default, which may seem counter-intuitive but makes
1752 it possible to overlay them on modular types easily. */
1758 /* Don't declare the field as addressable since we won't be taking
1759 its address and this would prevent create_field_decl from making
1760 a bitfield. */
1761 gnu_field
1765 /* Do not emit debug info until after the parallel type is added. */
1771 {
1772 /* Make the original array type a parallel type. */
1775 gnat_to_gnu_type
1779 }
1780 }
1782 /* If the type we are dealing with has got a smaller alignment than the
1783 natural one, we need to wrap it up in a record type and under-align
1784 the latter. We reuse the padding machinery for this purpose. */
1786 {
1789 /* Set the RM size before wrapping up the type. */
1793 /* Create a stripped-down declaration, mainly for debugging. */
1797 /* Now save it and build the enclosing record type. */
1809 /* Don't declare the field as addressable since we won't be taking
1810 its address and this would prevent create_field_decl from making
1811 a bitfield. */
1812 gnu_field
1819 }
1824 /* If this is a VAX floating-point type, use an integer of the proper
1825 size. All the operations will be handled with ASM statements. */
1827 {
1832 sizetype));
1834 }
1836 /* The type of the Low and High bounds can be our type if this is
1837 a type from Standard, so set them at the end of the function. */
1845 {
1848 }
1850 {
1868 SET_TYPE_RM_MIN_VALUE
1876 SET_TYPE_RM_MAX_VALUE
1884 /* One of the above calls might have caused us to be elaborated,
1885 so don't blow up if so. */
1887 {
1890 }
1892 /* Inherit our alias set from what we're a subtype of, as for
1893 integer subtypes. */
1895 }
1898 /* Array and String Types and Subtypes
1900 Unconstrained array types are represented by E_Array_Type and
1901 constrained array types are represented by E_Array_Subtype. There
1902 are no actual objects of an unconstrained array type; all we have
1903 are pointers to that type.
1905 The following fields are defined on array types and subtypes:
1907 Component_Type Component type of the array.
1908 Number_Dimensions Number of dimensions (an int).
1909 First_Index Type of first index. */
1913 {
1914 const bool convention_fortran_p
1926 /* We complete an existing dummy fat pointer type in place. This both
1927 avoids further complex adjustments in update_pointer_to and yields
1928 better debugging information in DWARF by leveraging the support for
1929 incomplete declarations of "tagged" types in the DWARF back-end. */
1932 {
1935 /* Save the contents of the dummy type for update_pointer_to. */
1937 }
1938 else
1941 /* Make a node for the array. If we are not defining the array
1942 suppress expanding incomplete types. */
1946 {
1947 defer_incomplete_level++;
1949 }
1951 /* Build the fat pointer type. Use a "void *" object instead of
1952 a pointer to the array type since we don't have the array type
1953 yet (it will reference the fat pointer via the bounds). */
1954 tem
1962 {
1963 /* We are going to lay it out again so reset the alias set. */
1969 {
1972 }
1973 }
1974 else
1975 {
1978 }
1980 /* Build a reference to the template from a PLACEHOLDER_EXPR that
1981 is the fat pointer. This will be used to access the individual
1982 fields once we build them. */
1986 gnu_template_reference
1990 /* Now create the GCC type for each index and add the fields for that
1991 index to the template. */
1997 {
1999 tree gnu_index_base_type
2004 /* Make the FIELD_DECLs for the low and high bounds of this
2005 type and then make extractions of these fields from the
2006 template. */
2009 gnu_index_base_type,
2017 gnu_index_base_type,
2025 /* We can't use build_component_ref here since the template type
2026 isn't complete yet. */
2029 NULL_TREE);
2032 NULL_TREE);
2038 /* Compute the size of this dimension. See the E_Array_Subtype
2039 case below for the rationale. */
2040 gnu_high
2044 gnu_max,
2047 /* Make a range type with the new range in the Ada base type.
2048 Then make an index type with the size range in sizetype. */
2052 gnu_orig_min,
2053 gnu_orig_max),
2054 gnat_entity);
2056 /* Update the maximum size of the array in elements. */
2058 {
2060 tree gnu_min
2062 tree gnu_max
2064 tree gnu_this_max
2069 size_zero_node);
2074 else
2075 gnu_max_size
2077 }
2081 }
2083 /* Install all the fields into the template. */
2088 gnu_template_fields
2091 debug_info_p);
2094 /* Now make the array of arrays and update the pointer to the array
2095 in the fat pointer. Note that it is the first field. */
2096 tem
2099 /* If Component_Size is not already specified, annotate it with the
2100 size of the component. */
2104 /* Compute the maximum size of the array in units and bits. */
2106 {
2112 }
2113 else
2116 /* Now build the array type. */
2118 {
2123 }
2125 /* If an alignment is specified, use it if valid. But ignore it
2126 for the original type of packed array types. If the alignment
2127 was requested with an explicit alignment clause, state so. */
2130 {
2136 }
2140 /* Adjust the type of the pointer-to-array field of the fat pointer
2141 and record the aliasing relationships if necessary. */
2146 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
2147 corresponding fat pointer. */
2154 /* If the maximum size doesn't overflow, use it. */
2160 {
2165 }
2171 /* Give the fat pointer type a name. If this is a packed type, tell
2172 the debugger how to interpret the underlying bits. */
2175 else
2181 /* Create the type to be used as what a thin pointer designates:
2182 a record type for the object and its template with the fields
2183 shifted to have the template at a negative offset. */
2186 debug_info_p);
2191 }
2197 /* This is the actual data type for array variables. Multidimensional
2198 arrays are implemented as arrays of arrays. Note that arrays which
2199 have sparse enumeration subtypes as index components create sparse
2200 arrays, which is obviously space inefficient but so much easier to
2201 code for now.
2203 Also note that the subtype never refers to the unconstrained array
2204 type, which is somewhat at variance with Ada semantics.
2206 First check to see if this is simply a renaming of the array type.
2207 If so, the result is the array type. */
2211 ;
2212 else
2213 {
2215 const bool convention_fortran_p
2224 /* First create the GCC type for each index and find out whether
2225 special types are needed for debugging information. */
2228 gnat_base_index
2234 {
2240 tree gnu_base_index_type
2244 tree gnu_high;
2246 /* See if the base array type is already flat. If it is, we
2247 are probably compiling an ACATS test but it will cause the
2248 code below to malfunction if we don't handle it specially. */
2252 {
2256 }
2258 /* Similarly, if one of the values overflows in sizetype and the
2259 range is null, use 1..0 for the sizetype bounds. */
2264 {
2268 }
2270 /* If the minimum and maximum values both overflow in sizetype,
2271 but the difference in the original type does not overflow in
2272 sizetype, ignore the overflow indication. */
2276 && !TREE_OVERFLOW
2279 gnu_orig_max,
2280 gnu_orig_min))))
2281 {
2285 }
2287 /* Compute the size of this dimension in the general case. We
2288 need to provide GCC with an upper bound to use but have to
2289 deal with the "superflat" case. There are three ways to do
2290 this. If we can prove that the array can never be superflat,
2291 we can just use the high bound of the index type. */
2294 /* Packed Array Types are never superflat. */
2298 /* Otherwise, if the high bound is constant but the low bound is
2299 not, we use the expression (hb >= lb) ? lb : hb + 1 for the
2300 lower bound. Note that the comparison must be done in the
2301 original type to avoid any overflow during the conversion. */
2304 {
2306 gnu_min
2309 boolean_type_node,
2310 gnu_orig_max,
2311 gnu_orig_min),
2312 gnu_min,
2314 size_one_node));
2315 }
2317 /* Finally we use (hb >= lb) ? hb : lb - 1 for the upper bound
2318 in all the other cases. Note that, here as well as above,
2319 the condition used in the comparison must be equivalent to
2320 the condition (length != 0). This is relied upon in order
2321 to optimize array comparisons in compare_arrays. */
2322 else
2323 gnu_high
2326 boolean_type_node,
2327 gnu_orig_max,
2328 gnu_orig_min),
2329 gnu_max,
2331 size_one_node));
2333 /* Reuse the index type for the range type. Then make an index
2334 type with the size range in sizetype. */
2337 gnat_entity);
2339 /* Update the maximum size of the array in elements. Here we
2340 see if any constraint on the index type of the base type
2341 can be used in the case of self-referential bound on the
2342 index type of the subtype. We look for a non-"infinite"
2343 and non-self-referential bound from any type involved and
2344 handle each bound separately. */
2346 {
2349 tree gnu_base_index_base_type
2351 tree gnu_base_base_min
2354 tree gnu_base_base_max
2375 else
2376 {
2377 tree gnu_this_max
2381 gnu_base_max,
2382 gnu_base_min)),
2383 size_zero_node);
2388 else
2389 gnu_max_size
2391 }
2392 }
2394 /* We need special types for debugging information to point to
2395 the index types if they have variable bounds, are not integer
2396 types, are biased or are wider than sizetype. */
2407 }
2409 /* Then flatten: create the array of arrays. For an array type
2410 used to implement a packed array, get the component type from
2411 the original array type since the representation clauses that
2412 can affect it are on the latter. */
2415 {
2420 /* One of the above calls might have caused us to be elaborated,
2421 so don't blow up if so. */
2423 {
2426 }
2427 }
2428 else
2429 {
2431 debug_info_p);
2433 /* One of the above calls might have caused us to be elaborated,
2434 so don't blow up if so. */
2436 {
2439 }
2440 }
2442 /* Compute the maximum size of the array in units and bits. */
2444 {
2450 }
2451 else
2454 /* Now build the array type. */
2456 {
2462 }
2464 /* Attach the TYPE_STUB_DECL in case we have a parallel type. */
2468 /* If we are at file level and this is a multi-dimensional array,
2469 we need to make a variable corresponding to the stride of the
2470 inner dimensions. */
2472 {
2474 tree gnu_arr_type;
2480 {
2488 /* ??? For now, store the size as a multiple of the
2489 alignment of the element type in bytes so that we
2490 can see the alignment from the tree. */
2493 gnat_entity,
2498 /* ??? create_type_decl is not invoked on the inner types so
2499 the MULT_EXPR node built above will never be marked. */
2501 }
2502 }
2504 /* If we need to write out a record type giving the names of the
2505 bounds for debugging purposes, do it now and make the record
2506 type a parallel type. This is not needed for a packed array
2507 since the bounds are conveyed by the original array type. */
2509 && debug_info_p
2511 {
2514 tree gnu_field;
2520 {
2527 /* Make sure to reference the types themselves, and not just
2528 their names, as the debugger may fall back on them. */
2534 }
2538 }
2540 /* If this is a packed array type, make the original array type a
2541 parallel type. Otherwise, do it for the base array type if it
2542 isn't artificial to make sure it is kept in the debug info. */
2544 {
2548 gnat_to_gnu_type
2550 else
2551 {
2552 tree gnu_base_decl
2557 }
2558 }
2565 /* If the size is self-referential and the maximum size doesn't
2566 overflow, use it. */
2568 && gnu_max_size
2573 {
2579 }
2581 /* Set our alias set to that of our base type. This gives all
2582 array subtypes the same alias set. */
2585 /* If this is a packed type, make this type the same as the packed
2586 array type, but do some adjusting in the type first. */
2588 {
2589 Entity_Id gnat_index;
2590 tree gnu_inner;
2592 /* First finish the type we had been making so that we output
2593 debugging information for it. */
2595 gnu_type
2600 /* Make it artificial only if the base type was artificial too.
2601 That's sort of "morally" true and will make it possible for
2602 the debugger to look it up by name in DWARF, which is needed
2603 in order to decode the packed array type. */
2604 gnu_decl
2610 /* Save it as our equivalent in case the call below elaborates
2611 this type again. */
2626 /* We need to attach the index type to the type we just made so
2627 that the actual bounds can later be put into a template. */
2632 {
2634 {
2635 /* The TYPE_ACTUAL_BOUNDS field is overloaded with the
2636 TYPE_MODULUS for modular types so we make an extra
2637 subtype if necessary. */
2639 {
2640 tree gnu_subtype
2649 }
2653 #ifdef ENABLE_CHECKING
2654 /* Check for other cases of overloading. */
2656 #endif
2657 }
2662 SET_TYPE_ACTUAL_BOUNDS
2669 SET_TYPE_ACTUAL_BOUNDS
2675 }
2676 }
2678 else
2679 /* Abort if packed array with no Packed_Array_Type field set. */
2681 }
2685 /* Create the type for a string literal. */
2686 {
2687 Entity_Id gnat_full_type
2692 tree gnu_string_array_type
2694 tree gnu_string_index_type
2697 tree gnu_lower_bound
2702 tree gnu_upper_bound
2704 gnu_lower_bound,
2706 tree gnu_index_type
2710 gnu_lower_bound,
2711 gnu_upper_bound),
2712 gnat_entity);
2714 gnu_type
2717 gnu_index_type);
2721 }
2724 /* Record Types and Subtypes
2726 The following fields are defined on record types:
2728 Has_Discriminants True if the record has discriminants
2729 First_Discriminant Points to head of list of discriminants
2730 First_Entity Points to head of list of fields
2731 Is_Tagged_Type True if the record is tagged
2733 Implementation of Ada records and discriminated records:
2735 A record type definition is transformed into the equivalent of a C
2736 struct definition. The fields that are the discriminants which are
2737 found in the Full_Type_Declaration node and the elements of the
2738 Component_List found in the Record_Type_Definition node. The
2739 Component_List can be a recursive structure since each Variant of
2740 the Variant_Part of the Component_List has a Component_List.
2742 Processing of a record type definition comprises starting the list of
2743 field declarations here from the discriminants and the calling the
2744 function components_to_record to add the rest of the fields from the
2745 component list and return the gnu type node. The function
2746 components_to_record will call itself recursively as it traverses
2747 the tree. */
2751 {
2752 gnu_type
2753 = build_complex_type
2754 (get_unpadded_type
2757 (Component_List
2758 (Type_Definition
2762 }
2764 {
2767 Entity_Id gnat_field;
2769 /* Set PACKED in keeping with gnat_to_gnu_field. */
2770 int packed
2783 bool is_extension
2788 /* See if all fields have a rep clause. Stop when we find one
2789 that doesn't. */
2797 {
2800 }
2802 /* If this is a record extension, go a level further to find the
2803 record definition. Also, verify we have a Parent_Subtype. */
2805 {
2812 }
2814 /* Make a node for the record. If we are not defining the record,
2815 suppress expanding incomplete types. */
2821 {
2822 defer_incomplete_level++;
2824 }
2826 /* If both a size and rep clause was specified, put the size in
2827 the record type now so that it can get the proper mode. */
2831 /* Always set the alignment here so that it can be used to
2832 set the mode, if it is making the alignment stricter. If
2833 it is invalid, it will be checked again below. If this is to
2834 be Atomic, choose a default alignment of a word unless we know
2835 the size and it's smaller. */
2842 /* If a type needs strict alignment, the minimum size will be the
2843 type size instead of the RM size (see validate_size). Cap the
2844 alignment, lest it causes this type size to become too large. */
2847 {
2852 }
2853 else
2856 /* If we have a Parent_Subtype, make a field for the parent. If
2857 this record has rep clauses, force the position to zero. */
2859 {
2861 tree gnu_parent;
2863 /* A major complexity here is that the parent subtype will
2864 reference our discriminants in its Discriminant_Constraint
2865 list. But those must reference the parent component of this
2866 record which is of the parent subtype we have not built yet!
2867 To break the circle we first build a dummy COMPONENT_REF which
2868 represents the "get to the parent" operation and initialize
2869 each of those discriminants to a COMPONENT_REF of the above
2870 dummy parent referencing the corresponding discriminant of the
2871 base type of the parent subtype. */
2876 void_type_node),
2877 NULL_TREE);
2884 {
2885 tree gnu_field
2888 save_gnu_tree
2893 }
2895 /* Then we build the parent subtype. If it has discriminants but
2896 the type itself has unknown discriminants, this means that it
2897 doesn't contain information about how the discriminants are
2898 derived from those of the ancestor type, so it cannot be used
2899 directly. Instead it is built by cloning the parent subtype
2900 of the underlying record view of the type, for which the above
2901 derivation of discriminants has been made explicit. */
2904 {
2907 /* If we are defining the type, the underlying record
2908 view must already have been elaborated at this point.
2909 Otherwise do it now as its parent subtype cannot be
2910 technically elaborated on its own. */
2913 else
2918 /* Substitute the "get to the parent" of the type for that
2919 of its underlying record view in the cloned type. */
2924 {
2926 tree gnu_ref
2929 gnu_parent
2931 }
2932 }
2933 else
2936 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
2937 initially built. The discriminants must reference the fields
2938 of the parent subtype and not those of its base type for the
2939 placeholder machinery to properly work. */
2941 {
2942 /* The actual parent subtype is the full view. */
2944 {
2947 else
2949 }
2955 {
2965 }
2966 }
2968 /* The "get to the parent" COMPONENT_REF must be given its
2969 proper type... */
2972 /* ...and reference the _Parent field of this record. */
2973 gnu_field
2976 has_rep
2978 has_rep
2984 }
2986 /* Make the fields for the discriminants and put them into the record
2987 unless it's an Unchecked_Union. */
2992 {
2993 /* If this is a record extension and this discriminant is the
2994 renaming of another discriminant, we've handled it above. */
2999 gnu_field
3001 debug_info_p);
3003 /* Make an expression using a PLACEHOLDER_EXPR from the
3004 FIELD_DECL node just created and link that with the
3005 corresponding GNAT defining identifier. */
3013 {
3016 }
3017 }
3019 /* Add the fields into the record type and finish it up. */
3024 NULL);
3026 /* If it is passed by reference, force BLKmode to ensure that objects
3027 of this type will always be put in memory. */
3031 /* We used to remove the associations of the discriminants and _Parent
3032 for validity checking but we may need them if there's a Freeze_Node
3033 for a subtype used in this record. */
3036 /* Fill in locations of fields. */
3039 /* If there are any entities in the chain corresponding to components
3040 that we did not elaborate, ensure we elaborate their types if they
3041 are Itypes. */
3051 /* If this is a record type associated with an exception definition,
3052 equate its fields to those of the standard exception type. This
3053 will make it possible to convert between them. */
3055 {
3056 tree gnu_std_field;
3059 gnu_field;
3064 }
3065 }
3069 /* If an equivalent type is present, that is what we should use.
3070 Otherwise, fall through to handle this like a record subtype
3071 since it may have constraints. */
3073 {
3077 }
3079 /* ... fall through ... */
3082 /* If Cloned_Subtype is Present it means this record subtype has
3083 identical layout to that type or subtype and we should use
3084 that GCC type for this one. The front end guarantees that
3085 the component list is shared. */
3087 {
3092 }
3094 /* Otherwise, first ensure the base type is elaborated. Then, if we are
3095 changing the type, make a new type with each field having the type of
3096 the field in the new subtype but the position computed by transforming
3097 every discriminant reference according to the constraints. We don't
3098 see any difference between private and non-private type here since
3099 derivations from types should have been deferred until the completion
3100 of the private type. */
3101 else
3102 {
3104 tree gnu_base_type;
3107 {
3108 defer_incomplete_level++;
3110 }
3115 {
3118 }
3120 /* If this is a record subtype associated with a dispatch table,
3121 strip the suffix. This is necessary to make sure 2 different
3122 subtypes associated with the imported and exported views of a
3123 dispatch table are properly merged in LTO mode. */
3125 {
3132 }
3134 /* When the subtype has discriminants and these discriminants affect
3135 the initial shape it has inherited, factor them in. But for an
3136 Unchecked_Union (it must be an Itype), just return the type.
3137 We can't just test Is_Constrained because private subtypes without
3138 discriminants of types with discriminants with default expressions
3139 are Is_Constrained but aren't constrained! */
3147 {
3153 Entity_Id gnat_field;
3159 /* Set the size, alignment and alias set of the new type to
3160 match that of the old one, doing required substitutions. */
3162 gnu_subst_list);
3166 else
3169 /* Look for a REP part in the base type. */
3172 /* Look for a variant part in the base type. */
3175 /* If there is a variant part, we must compute whether the
3176 constraints statically select a particular variant. If
3177 so, we simply drop the qualified union and flatten the
3178 list of fields. Otherwise we'll build a new qualified
3179 union for the variants that are still relevant. */
3181 {
3185 gnu_variant_list
3189 /* If all the qualifiers are unconditionally true, the
3190 innermost variant is statically selected. */
3195 {
3198 }
3200 /* Otherwise, create the new variants. */
3204 {
3210 gnu_subst_list);
3212 }
3213 }
3214 else
3215 {
3218 }
3220 gnu_pos_list
3236 {
3238 Entity_Id gnat_old_field
3240 tree gnu_old_field
3246 /* If the type is the same, retrieve the GCC type from the
3247 old field to take into account possible adjustments. */
3250 else
3253 /* If there was a component clause, the field types must be
3254 the same for the type and subtype, so copy the data from
3255 the old field to avoid recomputation here. Also if the
3256 field is justified modular and the optimization in
3257 gnat_to_gnu_field was applied. */
3263 {
3266 }
3268 /* If the old field was packed and of constant size, we
3269 have to get the old size here, as it might differ from
3270 what the Etype conveys and the latter might overlap
3271 onto the following field. Try to arrange the type for
3272 possible better packing along the way. */
3276 {
3281 gnu_field_type
3283 }
3285 else
3288 /* If the context of the old field is the base type or its
3289 REP part (if any), put the field directly in the new
3290 type; otherwise look up the context in the variant list
3291 and put the field either in the new type if there is a
3292 selected variant or in one of the new variants. */
3294 || (gnu_rep_part
3297 else
3298 {
3306 {
3309 }
3311 {
3314 else
3316 }
3317 else
3318 /* The front-end may pass us "ghost" components if
3319 it fails to recognize that a constrained subtype
3320 is statically constrained. Discard them. */
3322 }
3324 /* Now create the new field modeled on the old one. */
3325 gnu_field
3330 /* Put it in one of the new variants directly. */
3332 {
3335 }
3337 /* To match the layout crafted in components_to_record,
3338 if this is the _Tag or _Parent field, put it before
3339 any other fields. */
3344 /* Similarly, if this is the _Controller field, put
3345 it before the other fields except for the _Tag or
3346 _Parent field. */
3348 {
3351 }
3353 /* Otherwise, if this is a regular field, put it after
3354 the other fields. */
3355 else
3356 {
3361 }
3364 }
3366 /* If there is a variant list and no selected variant, we need
3367 to create the nest of variant parts from the old nest. */
3369 {
3370 tree new_variant_part
3376 }
3378 /* Now go through the entities again looking for Itypes that
3379 we have not elaborated but should (e.g., Etypes of fields
3380 that have Original_Components). */
3388 /* Do not emit debug info for the type yet since we're going to
3389 modify it below. */
3393 /* See the E_Record_Type case for the rationale. */
3396 else
3401 /* Fill in locations of fields. */
3404 /* If debugging information is being written for the type, write
3405 a record that shows what we are a subtype of and also make a
3406 variable that indicates our size, if still variable. */
3408 {
3420 build_reference_type
3422 gnu_subtype_marker,
3428 gnu_subtype_marker);
3438 gnat_entity);
3439 }
3444 /* Now we can finalize it. */
3446 }
3448 /* Otherwise, go down all the components in the new type and make
3449 them equivalent to those in the base type. */
3450 else
3451 {
3461 gnat_to_gnu_field_decl
3464 }
3465 }
3469 /* Use the special descriptor type for dispatch tables if needed,
3470 that is to say for the Prim_Ptr of a-tags.ads and its clones.
3471 Note that we are only required to do so for static tables in
3472 order to be compatible with the C++ ABI, but Ada 2005 allows
3473 to extend library level tagged types at the local level so
3474 we do it in the non-static case as well. */
3477 {
3481 }
3483 /* ... fall through ... */
3486 /* If we are not defining this entity, and we have incomplete
3487 entities being processed above us, make a dummy type and
3488 fill it in later. */
3490 {
3494 gnu_type
3495 = build_pointer_type
3510 }
3512 /* ... fall through ... */
3519 {
3520 /* The designated type and its equivalent type for gigi. */
3523 /* Whether it comes from a limited with. */
3524 bool is_from_limited_with
3527 /* The "full view" of the designated type. If this is an incomplete
3528 entity from a limited with, treat its non-limited view as the full
3529 view. Otherwise, if this is an incomplete or private type, use the
3530 full view. In the former case, we might point to a private type,
3531 in which case, we need its full view. Also, we want to look at the
3532 actual type used for the representation, so this takes a total of
3533 three steps. */
3534 Entity_Id gnat_desig_full_direct_first
3535 = (is_from_limited_with
3539 Entity_Id gnat_desig_full_direct
3540 = ((is_from_limited_with
3545 Entity_Id gnat_desig_full
3547 /* The type actually used to represent the designated type, either
3548 gnat_desig_full or gnat_desig_equiv. */
3549 Entity_Id gnat_desig_rep;
3550 /* True if this is a pointer to an unconstrained array. */
3552 /* We want to know if we'll be seeing the freeze node for any
3553 incomplete type we may be pointing to. */
3554 bool in_main_unit
3558 /* True if we make a dummy type here. */
3560 /* The mode to be used for the pointer type. */
3562 /* The GCC type used for the designated type. */
3568 /* If either the designated type or its full view is an unconstrained
3569 array subtype, replace it with the type it's a subtype of. This
3570 avoids problems with multiple copies of unconstrained array types.
3571 Likewise, if the designated type is a subtype of an incomplete
3572 record type, use the parent type to avoid order of elaboration
3573 issues. This can lose some code efficiency, but there is no
3574 alternative. */
3585 /* Set the type that's actually the representation of the designated
3586 type and also flag whether we have a unconstrained array. */
3587 gnat_desig_rep
3589 is_unconstrained_array
3592 /* If we are pointing to an incomplete type whose completion is an
3593 unconstrained array, make dummy fat and thin pointer types to it.
3594 Likewise if the type itself is dummy or an unconstrained array. */
3598 && TYPE_IS_DUMMY_P
3600 || (!in_main_unit
3603 || (in_main_unit
3604 && is_from_limited_with
3606 {
3609 else
3610 {
3613 }
3615 /* If the call above got something that has a pointer, the pointer
3616 is our type. This could have happened either because the type
3617 was elaborated or because somebody else executed the code. */
3621 }
3623 /* If we already know what the full type is, use it. */
3628 /* Get the type of the thing we are to point to and build a pointer to
3629 it. If it is a reference to an incomplete or private type with a
3630 full view that is a record, make a dummy type node and get the
3631 actual type later when we have verified it is safe. */
3637 /* Likewise if we are pointing to a record or array and we are
3638 to defer elaborating incomplete types. We do this as this
3639 access type may be the full view of a private type. Note
3640 that the unconstrained array case is handled above. */
3646 /* If this is a reference from a limited_with type back to our
3647 main unit and there's a freeze node for it, either we have
3648 already processed the declaration and made the dummy type,
3649 in which case we just reuse the latter, or we have not yet,
3650 in which case we make the dummy type and it will be reused
3651 when the declaration is finally processed. In both cases,
3652 the pointer eventually created below will be automatically
3653 adjusted when the freeze node is processed. Note that the
3654 unconstrained array case is handled above. */
3655 || (in_main_unit
3656 && is_from_limited_with
3658 {
3661 }
3663 /* Otherwise handle the case of a pointer to itself. */
3665 {
3666 gnu_type
3670 }
3672 /* If expansion is disabled, the equivalent type of a concurrent type
3673 is absent, so build a dummy pointer type. */
3677 /* Finally, handle the default case where we can just elaborate our
3678 designated type. */
3679 else
3682 /* It is possible that a call to gnat_to_gnu_type above resolved our
3683 type. If so, just return it. */
3685 {
3688 }
3690 /* If we have not done it yet, build the pointer type the usual way. */
3692 {
3693 /* Modify the designated type if we are pointing only to constant
3694 objects, but don't do it for unconstrained arrays. */
3697 {
3698 gnu_desig_type
3699 = build_qualified_type
3703 /* Some extra processing is required if we are building a
3704 pointer to an incomplete type (in the GCC sense). We might
3705 have such a type if we just made a dummy, or directly out
3706 of the call to gnat_to_gnu_type above if we are processing
3707 an access type for a record component designating the
3708 record type itself. */
3710 {
3711 /* We must ensure that the pointer to variant we make will
3712 be processed by update_pointer_to when the initial type
3713 is completed. Pretend we made a dummy and let further
3714 processing act as usual. */
3717 /* We must ensure that update_pointer_to will not retrieve
3718 the dummy variant when building a properly qualified
3719 version of the complete type. We take advantage of the
3720 fact that get_qualified_type is requiring TYPE_NAMEs to
3721 match to influence build_qualified_type and then also
3722 update_pointer_to here. */
3725 }
3726 }
3728 gnu_type
3731 }
3733 /* If we are not defining this object and we have made a dummy pointer,
3734 save our current definition, evaluate the actual type, and replace
3735 the tentative type we made with the actual one. If we are to defer
3736 actually looking up the actual type, make an entry in the deferred
3737 list. If this is from a limited with, we may have to defer to the
3738 end of the current unit. */
3740 {
3741 tree gnu_old_desig_type;
3744 {
3747 gnu_type = build_pointer_type
3749 }
3750 else
3761 /* Note that the call to gnat_to_gnu_type on gnat_desig_equiv might
3762 update gnu_old_desig_type directly, in which case it will not be
3763 a dummy type any more when we get into update_pointer_to.
3765 This can happen e.g. when the designated type is a record type,
3766 because their elaboration starts with an initial node from
3767 make_dummy_type, which may be the same node as the one we got.
3769 Besides, variants of this non-dummy type might have been created
3770 along the way. update_pointer_to is expected to properly take
3771 care of those situations. */
3773 {
3774 defer_finalize_level++;
3777 defer_finalize_level--;
3778 }
3779 else
3780 {
3783 = (is_from_limited_with
3789 }
3790 }
3791 }
3798 else
3799 {
3800 /* The run-time representation is the equivalent type. */
3803 }
3816 /* We treat this as identical to its base type; any constraint is
3817 meaningful only to the front end.
3819 The designated type must be elaborated as well, if it does
3820 not have its own freeze node. Designated (sub)types created
3821 for constrained components of records with discriminants are
3822 not frozen by the front end and thus not elaborated by gigi,
3823 because their use may appear before the base type is frozen,
3824 and because it is not clear that they are needed anywhere in
3825 Gigi. With the current model, there is no correct place where
3826 they could be elaborated. */
3833 {
3834 /* If we are not defining this entity, and we have incomplete
3835 entities being processed above us, make a dummy type and
3836 elaborate it later. */
3838 {
3841 tree gnu_ptr_type
3842 = build_pointer_type
3849 }
3852 Incomplete_Or_Private_Kind))
3855 }
3860 /* Subprogram Entities
3862 The following access functions are defined for subprograms:
3864 Etype Return type or Standard_Void_Type.
3865 First_Formal The first formal parameter.
3866 Is_Imported Indicates that the subprogram has appeared in
3867 an INTERFACE or IMPORT pragma. For now we
3868 assume that the external language is C.
3869 Is_Exported Likewise but for an EXPORT pragma.
3870 Is_Inlined True if the subprogram is to be inlined.
3872 Each parameter is first checked by calling must_pass_by_ref on its
3873 type to determine if it is passed by reference. For parameters which
3874 are copied in, if they are Ada In Out or Out parameters, their return
3875 value becomes part of a record which becomes the return type of the
3876 function (C function - note that this applies only to Ada procedures
3877 so there is no Ada return type). Additional code to store back the
3878 parameters will be generated on the caller side. This transformation
3879 is done here, not in the front-end.
3881 The intended result of the transformation can be seen from the
3882 equivalent source rewritings that follow:
3884 struct temp {int a,b};
3885 procedure P (A,B: In Out ...) is temp P (int A,B)
3886 begin {
3887 .. ..
3888 end P; return {A,B};
3889 }
3891 temp t;
3892 P(X,Y); t = P(X,Y);
3893 X = t.a , Y = t.b;
3895 For subprogram types we need to perform mainly the same conversions to
3896 GCC form that are needed for procedures and function declarations. The
3897 only difference is that at the end, we make a type declaration instead
3898 of a function declaration. */
3903 {
3904 /* The type returned by a function or else Standard_Void_Type for a
3905 procedure. */
3907 tree gnu_return_type;
3908 /* The first GCC parameter declaration (a PARM_DECL node). The
3909 PARM_DECL nodes are chained through the DECL_CHAIN field, so this
3910 actually is the head of this parameter list. */
3912 /* Likewise for the stub associated with an exported procedure. */
3914 /* Non-null for subprograms containing parameters passed by copy-in
3915 copy-out (Ada In Out or Out parameters not passed by reference),
3916 in which case it is the list of nodes used to specify the values
3917 of the In Out/Out parameters that are returned as a record upon
3918 procedure return. The TREE_PURPOSE of an element of this list is
3919 a field of the record and the TREE_VALUE is the PARM_DECL
3920 corresponding to that field. This list will be saved in the
3921 TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
3923 /* List of fields in return type of procedure with copy-in copy-out
3924 parameters. */
3926 /* If an import pragma asks to map this subprogram to a GCC builtin,
3927 this is the builtin DECL node. */
3929 /* For the stub associated with an exported procedure. */
3932 Entity_Id gnat_param;
3935 bool extern_flag
3937 /* The semantics of "pure" in Ada essentially matches that of "const"
3938 in the back-end. In particular, both properties are orthogonal to
3939 the "nothrow" property if the EH circuitry is explicit in the
3940 internal representation of the back-end. If we are to completely
3941 hide the EH circuitry from it, we need to declare that calls to pure
3942 Ada subprograms that can throw have side effects since they can
3943 trigger an "abnormal" transfer of control flow; thus they can be
3944 neither "const" nor "pure" in the back-end sense. */
3945 bool const_flag
3955 /* A parameter may refer to this type, so defer completion of any
3956 incomplete types. */
3958 {
3959 defer_incomplete_level++;
3961 }
3963 /* If the subprogram has an alias, it is probably inherited, so
3964 we can use the original one. If the original "subprogram"
3965 is actually an enumeration literal, it may be the first use
3966 of its type, so we must elaborate that type now. */
3968 {
3974 /* Elaborate any Itypes in the parameters of this entity. */
3982 }
3984 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
3985 corresponding DECL node. Proper generation of calls later on need
3986 proper parameter associations so we don't "break;" here. */
3989 {
3992 /* Inability to find the builtin decl most often indicates a
3993 genuine mistake, but imports of unregistered intrinsics are
3994 sometimes issued on purpose to allow hooking in alternate
3995 bodies. We post a warning conditioned on Wshadow in this case,
3996 to let developers be notified on demand without risking false
3997 positives with common default sets of options. */
4001 }
4003 /* ??? What if we don't find the builtin node above ? warn ? err ?
4004 In the current state we neither warn nor err, and calls will just
4005 be handled as for regular subprograms. */
4007 /* Look into the return type and get its associated GCC tree. If it
4008 is not void, compute various flags for the subprogram type. */
4011 else
4012 {
4015 /* If this function returns by reference, make the actual return
4016 type the pointer type and make a note of that. */
4018 {
4021 }
4023 /* If we are supposed to return an unconstrained array type, make
4024 the actual return type the fat pointer type. */
4026 {
4029 }
4031 /* Likewise, if the return type requires a transient scope, the
4032 return value will be allocated on the secondary stack so the
4033 actual return type is the pointer type. */
4035 {
4038 }
4040 /* If the Mechanism is By_Reference, ensure this function uses the
4041 target's by-invisible-reference mechanism, which may not be the
4042 same as above (e.g. it might be passing an extra parameter). */
4047 /* Likewise, if the return type is itself By_Reference. */
4051 /* If the type is a padded type and the underlying type would not
4052 be passed by reference or the function has a foreign convention,
4053 return the underlying type. */
4055 && (!default_pass_by_ref
4060 /* If the return type is unconstrained, that means it must have a
4061 maximum size. Use the padded type as the effective return type.
4062 And ensure the function uses the target's by-invisible-reference
4063 mechanism to avoid copying too much data when it returns. */
4065 {
4066 gnu_return_type
4072 }
4074 /* If the return type has a size that overflows, we cannot have
4075 a function that returns that type. This usage doesn't make
4076 sense anyway, so give an error here. */
4080 {
4082 gnat_entity);
4088 }
4089 }
4091 /* Loop over the parameters and get their associated GCC tree. While
4092 doing this, build a copy-in copy-out structure if we need one. */
4096 {
4103 /* Builtins are expanded inline and there is no real call sequence
4104 involved. So the type expected by the underlying expander is
4105 always the type of each argument "as is". */
4108 /* Handle the first parameter of a valued procedure specially. */
4111 /* Otherwise, see if a Mechanism was supplied that forced this
4112 parameter to be passed one way or another. */
4115 ;
4124 {
4128 mech))
4130 else
4132 }
4133 else
4134 {
4137 }
4139 gnu_param
4144 /* We are returned either a PARM_DECL or a type if no parameter
4145 needs to be passed; in either case, adjust the type. */
4148 else
4149 {
4152 }
4154 /* The failure of this assertion will very likely come from an
4155 order of elaboration issue for the type of the parameter. */
4160 {
4161 /* If it's an exported subprogram, we build a parameter list
4162 in parallel, in case we need to emit a stub for it. */
4164 {
4165 gnu_stub_param_list
4167 /* Change By_Descriptor parameter to By_Reference for
4168 the internal version of an exported subprogram. */
4170 {
4171 gnu_param
4176 }
4177 else
4179 }
4186 /* If a parameter is a pointer, this function may modify
4187 memory through it and thus shouldn't be considered
4188 a const function. Also, the memory may be modified
4189 between two calls, so they can't be CSE'ed. The latter
4190 case also handles by-ref parameters. */
4194 }
4197 {
4199 {
4202 /* If this is a function, we also need a field for the
4203 return value to be placed. */
4205 {
4206 gnu_field
4208 gnu_return_type,
4214 gnu_cico_list
4216 }
4220 /* Set a default alignment to speed up accesses. */
4223 }
4225 gnu_field
4233 gnu_cico_list
4235 }
4236 }
4238 /* Do not compute record for out parameters if subprogram is
4239 stubbed since structures are incomplete for the back-end. */
4244 /* If we have a CICO list but it has only one entry, we convert
4245 this function into a function that simply returns that one
4246 object. */
4251 prepend_one_attribute_to
4254 gnat_entity);
4256 /* If we should request stack realignment for a foreign convention
4257 subprogram, do so. Note that this applies to task entry points in
4258 particular. */
4261 prepend_one_attribute_to
4264 gnat_entity);
4266 /* The lists have been built in reverse. */
4274 || return_by_direct_ref_p
4275 || return_by_invisi_ref_p
4277 gnu_type
4280 return_by_direct_ref_p,
4281 return_by_invisi_ref_p);
4284 gnu_stub_type
4287 return_by_direct_ref_p,
4288 return_by_invisi_ref_p);
4290 /* A subprogram (something that doesn't return anything) shouldn't
4291 be considered const since there would be no reason for such a
4292 subprogram. Note that procedures with Out (or In Out) parameters
4293 have already been converted into a function with a return type. */
4297 gnu_type
4304 gnu_stub_type
4310 /* If we have a builtin decl for that function, use it. Check if the
4311 profiles are compatible and warn if they are not. The checker is
4312 expected to post extra diagnostics in this case. */
4314 {
4315 intrin_binding_t inb;
4322 post_error
4324 gnat_entity);
4329 }
4331 /* If there was no specified Interface_Name and the external and
4332 internal names of the subprogram are the same, only use the
4333 internal name to allow disambiguation of nested subprograms. */
4338 /* If we are defining the subprogram and it has an Address clause
4339 we must get the address expression from the saved GCC tree for the
4340 subprogram if it has a Freeze_Node. Otherwise, we elaborate
4341 the address expression here since the front-end has guaranteed
4342 in that case that the elaboration has no effects. If there is
4343 an Address clause and we are not defining the object, just
4344 make it a constant. */
4346 {
4350 gnu_address
4357 /* Convert the type of the object to a reference type that can
4358 alias everything as per 13.3(19). */
4359 gnu_type
4364 gnu_decl
4369 }
4375 else
4376 {
4378 {
4382 }
4388 gnat_entity);
4390 {
4391 tree gnu_stub_decl
4396 gnat_entity);
4398 }
4400 /* This is unrelated to the stub built right above. */
4403 }
4404 }
4415 {
4416 /* Get the "full view" of this entity. If this is an incomplete
4417 entity from a limited with, treat its non-limited view as the
4418 full view. Otherwise, use either the full view or the underlying
4419 full view, whichever is present. This is used in all the tests
4420 below. */
4421 Entity_Id full_view
4428 /* If this is an incomplete type with no full view, it must be a Taft
4429 Amendment type, in which case we return a dummy type. Otherwise,
4430 just get the type from its Etype. */
4432 {
4434 {
4437 }
4438 else
4439 {
4443 }
4445 }
4447 /* If we already made a type for the full view, reuse it. */
4449 {
4452 }
4454 /* Otherwise, if we are not defining the type now, get the type
4455 from the full view. But always get the type from the full view
4456 for define on use types, since otherwise we won't see them! */
4462 {
4466 }
4468 /* For incomplete types, make a dummy type entry which will be
4469 replaced later. Save it as the full declaration's type so
4470 we can do any needed updates when we see it. */
4477 }
4480 /* Class-wide types are always transformed into their root type. */
4489 /* Concurrent types are always transformed into their record type. */
4492 else
4503 /* Nothing at all to do here, so just return an ERROR_MARK and claim
4504 we've already saved it, so we don't try to. */
4511 }
4513 /* If we had a case where we evaluated another type and it might have
4514 defined this one, handle it here. */
4516 {
4519 }
4521 /* If we are processing a type and there is either no decl for it or
4522 we just made one, do some common processing for the type, such as
4523 handling alignment and possible padding. */
4525 {
4526 /* Tell the middle-end that objects of tagged types are guaranteed to
4527 be properly aligned. This is necessary because conversions to the
4528 class-wide type are translated into conversions to the root type,
4529 which can be less aligned than some of its derived types. */
4534 /* If the type is passed by reference, objects of this type must be
4535 fully addressable and cannot be copied. */
4539 /* ??? Don't set the size for a String_Literal since it is either
4540 confirming or we don't handle it properly (if the low bound is
4541 non-constant). */
4547 /* If a size was specified, see if we can make a new type of that size
4548 by rearranging the type, for example from a fat to a thin pointer. */
4550 {
4551 gnu_type
4558 }
4560 /* If the alignment hasn't already been processed and this is
4561 not an unconstrained array, see if an alignment is specified.
4562 If not, we pick a default alignment for atomic objects. */
4564 ;
4566 {
4570 /* Warn on suspiciously large alignments. This should catch
4571 errors about the (alignment,byte)/(size,bit) discrepancy. */
4573 {
4574 tree size;
4576 /* If a size was specified, take it into account. Otherwise
4577 use the RM size for records as the type size has already
4578 been adjusted to the alignment. */
4586 else
4589 /* Consider an alignment as suspicious if the alignment/size
4590 ratio is greater or equal to the byte/bit ratio. */
4595 gnat_entity);
4596 }
4597 }
4608 /* See if we need to pad the type. If we did, and made a record,
4609 the name of the new type may be changed. So get it back for
4610 us when we make the new TYPE_DECL below. */
4616 {
4620 }
4624 /* If we are at global level, GCC will have applied variable_size to
4625 the type, but that won't have done anything. So, if it's not
4626 a constant or self-referential, call elaborate_expression_1 to
4627 make a variable for the size rather than calculating it each time.
4628 Handle both the RM size and the actual size. */
4633 {
4641 /* ??? For now, store the size as a multiple of the alignment in
4642 bytes so that we can see the alignment from the tree. */
4649 /* ??? gnu_type may come from an existing type so the MULT_EXPR node
4650 may not be marked by the call to create_type_decl below. */
4654 {
4659 {
4663 /* If the position of the variant part is constant, subtract
4664 it from the size of the type of the parent to get the new
4665 size. This manual CSE reduces the data size. */
4667 {
4675 }
4676 else
4677 {
4680 gnat_entity,
4684 /* ??? For now, store the size as a multiple of the
4685 alignment in bytes so that we can see the alignment
4686 from the tree. */
4689 gnat_entity,
4690 get_identifier
4695 /* ??? For now, store the offset as a multiple of the
4696 alignment in bytes so that we can see the alignment
4697 from the tree. */
4700 gnat_entity,
4703 DECL_OFFSET_ALIGN
4705 }
4709 }
4713 else
4714 ada_size
4719 }
4720 }
4722 /* If this is a record type or subtype, call elaborate_expression_1 on
4723 any field position. Do this for both global and local types.
4724 Skip any fields that we haven't made trees for to avoid problems with
4725 class wide types. */
4730 {
4733 /* ??? For now, store the offset as a multiple of the alignment
4734 in bytes so that we can see the alignment from the tree. */
4736 {
4739 gnat_temp,
4744 /* ??? The context of gnu_field is not necessarily gnu_type
4745 so the MULT_EXPR node built above may not be marked by
4746 the call to create_type_decl below. */
4749 }
4750 }
4753 gnu_type
4770 else
4771 {
4774 }
4775 }
4778 {
4781 /* If this is a derived type, relate its alias set to that of its parent
4782 to avoid troubles when a call to an inherited primitive is inlined in
4783 a context where a derived object is accessed. The inlined code works
4784 on the parent view so the resulting code may access the same object
4785 using both the parent and the derived alias sets, which thus have to
4786 conflict. As the same issue arises with component references, the
4787 parent alias set also has to conflict with composite types enclosing
4788 derived components. For instance, if we have:
4790 type D is new T;
4791 type R is record
4792 Component : D;
4793 end record;
4795 we want T to conflict with both D and R, in addition to R being a
4796 superset of D by record/component construction.
4798 One way to achieve this is to perform an alias set copy from the
4799 parent to the derived type. This is not quite appropriate, though,
4800 as we don't want separate derived types to conflict with each other:
4802 type I1 is new Integer;
4803 type I2 is new Integer;
4805 We want I1 and I2 to both conflict with Integer but we do not want
4806 I1 to conflict with I2, and an alias set copy on derivation would
4807 have that effect.
4809 The option chosen is to make the alias set of the derived type a
4810 superset of that of its parent type. It trivially fulfills the
4811 simple requirement for the Integer derivation example above, and
4812 the component case as well by superset transitivity:
4814 superset superset
4815 R ----------> D ----------> T
4817 However, for composite types, conversions between derived types are
4818 translated into VIEW_CONVERT_EXPRs so a sequence like:
4820 type Comp1 is new Comp;
4821 type Comp2 is new Comp;
4822 procedure Proc (C : Comp1);
4824 C : Comp2;
4825 Proc (Comp1 (C));
4827 is translated into:
4829 C : Comp2;
4830 Proc ((Comp1 &) &VIEW_CONVERT_EXPR <Comp1> (C));
4832 and gimplified into:
4834 C : Comp2;
4835 Comp1 *C.0;
4836 C.0 = (Comp1 *) &C;
4837 Proc (C.0);
4839 i.e. generates code involving type punning. Therefore, Comp1 needs
4840 to conflict with Comp2 and an alias set copy is required.
4842 The language rules ensure the parent type is already frozen here. */
4844 {
4849 }
4851 /* Back-annotate the Alignment of the type if not already in the
4852 tree. Likewise for sizes. */
4854 {
4858 /* If the default alignment of "double" or larger scalar types is
4859 specifically capped and this is not an array with an alignment
4860 clause on the component type, return the cap. */
4862 is_capped_double
4865 is_capped_double
4867 else
4872 else
4876 }
4879 {
4882 /* If the size is self-referential, annotate the maximum value. */
4887 {
4888 /* In this mode, the tag and the parent components are not
4889 generated by the front-end so the sizes must be adjusted. */
4891 Uint uint_size;
4894 {
4896 bitsizetype);
4899 }
4900 else
4906 gnu_size,
4907 pointer_size));
4911 }
4912 else
4914 }
4918 }
4920 /* If we really have a ..._DECL node, set a couple of flags on it. But we
4921 cannot do that if we are reusing the ..._DECL node made for a renamed
4922 object, since the predicates don't apply to it but to GNAT_ENTITY. */
4924 {
4930 }
4932 /* If we haven't already, associate the ..._DECL node that we just made with
4933 the input GNAT entity node. */
4937 /* If this is an enumeration or floating-point type, we were not able to set
4938 the bounds since they refer to the type. These are always static. */
4941 {
4945 /* If this is a padded type, we need to use the underlying type. */
4949 /* If this is a floating point type and we haven't set a floating
4950 point type yet, use this in the evaluation of the bounds. */
4958 {
4959 /* Enumeration types have specific RM bounds. */
4963 /* Write full debugging information. Since this has both a
4964 typedef and a tag, avoid outputting the name twice. */
4967 }
4969 else
4970 {
4971 /* Floating-point types don't have specific RM bounds. */
4974 }
4975 }
4977 /* If we deferred processing of incomplete types, re-enable it. If there
4978 were no other disables and we have deferred types to process, do so. */
4982 {
4985 /* We are back to level 0 for the deferring of incomplete types.
4986 But processing these incomplete types below may itself require
4987 deferring, so preserve what we have and restart from scratch. */
4991 /* For finalization, however, all types must be complete so we
4992 cannot do the same because deferred incomplete types may end up
4993 referencing each other. Process them all recursively first. */
4994 defer_finalize_level++;
4997 {
5004 }
5006 defer_finalize_level--;
5007 }
5009 /* If all the deferred incomplete types have been processed, we can proceed
5010 with the finalization of the deferred types. */
5014 {
5016 tree t;
5022 }
5024 /* If we are not defining this type, see if it's on one of the lists of
5025 incomplete types. If so, handle the list entry now. */
5027 {
5032 {
5036 }
5040 {
5044 }
5045 }
5048 force_global--;
5050 /* If this is a packed array type whose original array type is itself
5051 an Itype without freeze node, make sure the latter is processed. */
5059 }
5061 /* Similar, but if the returned value is a COMPONENT_REF, return the
5062 FIELD_DECL. */
5064 tree
5066 {
5073 }
5075 /* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
5076 the GCC type corresponding to that entity. */
5078 tree
5080 {
5081 tree gnu_decl;
5083 /* The back end never attempts to annotate generic types. */
5091 }
5093 /* Similar, but GNAT_ENTITY is assumed to refer to a GNAT type. Return
5094 the unpadded version of the GCC type corresponding to that entity. */
5096 tree
5098 {
5105 }
5106 \f
5107 /* Wrap up compilation of DECL, a TYPE_DECL, possibly deferring it.
5108 Every TYPE_DECL generated for a type definition must be passed
5109 to this function once everything else has been done for it. */
5111 void
5113 {
5114 /* We need to defer finalizing the type if incomplete types
5115 are being deferred or if they are being processed. */
5118 else
5120 }
5122 /* Same as above but without deferring the compilation. This
5123 function should not be invoked directly on a TYPE_DECL. */
5125 static void
5127 {
5133 /* Now process all the variants. This is needed for STABS. */
5135 {
5143 }
5144 }
5146 /* Finalize the processing of From_With_Type incomplete types. */
5148 void
5150 {
5157 {
5164 }
5165 }
5167 /* Return the equivalent type to be used for GNAT_ENTITY, if it's a
5168 kind of type (such E_Task_Type) that has a different type which Gigi
5169 uses for its representation. If the type does not have a special type
5170 for its representation, return GNAT_ENTITY. If a type is supposed to
5171 exist, but does not, abort unless annotating types, in which case
5172 return Empty. If GNAT_ENTITY is Empty, return Empty. */
5174 Entity_Id
5176 {
5183 {
5207 }
5211 }
5213 /* Return a GCC tree for a type corresponding to the component type of the
5214 array type or subtype GNAT_ARRAY. DEFINITION is true if this component
5215 is for an array being defined. DEBUG_INFO_P is true if we need to write
5216 debug information for other types that we may create in the process. */
5218 static tree
5221 {
5223 tree gnu_comp_size;
5225 /* Try to get a smaller form of the component if needed. */
5239 /* Get and validate any specified Component_Size. */
5240 gnu_comp_size
5245 /* If the array has aliased components and the component size can be zero,
5246 force at least unit size to ensure that the components have distinct
5247 addresses. */
5253 gnu_comp_size
5256 /* If the component type is a RECORD_TYPE that has a self-referential size,
5257 then use the maximum size for the component size. */
5263 /* Honor the component size. This is not needed for bit-packed arrays. */
5265 {
5269 /* If an alignment is specified, use it as a cap on the component type
5270 so that it can be honored for the whole type. But ignore it for the
5271 original type of packed array types. */
5274 else
5280 else
5286 /* If a padding record was made, declare it now since it will never be
5287 declared otherwise. This is necessary to ensure that its subtrees
5288 are properly marked. */
5292 }
5295 gnu_type
5300 }
5302 /* Return a GCC tree for a parameter corresponding to GNAT_PARAM and
5303 using MECH as its passing mechanism, to be placed in the parameter
5304 list built for GNAT_SUBPROG. Assume a foreign convention for the
5305 latter if FOREIGN is true. Also set CICO to true if the parameter
5306 must use the copy-in copy-out implementation mechanism.
5308 The returned tree is a PARM_DECL, except for those cases where no
5309 parameter needs to be actually passed to the subprogram; the type
5310 of this "shadow" parameter is then returned instead. */
5312 static tree
5315 {
5320 /* The parameter can be indirectly modified if its address is taken. */
5324 tree gnu_param;
5326 /* Copy-return is used only for the first parameter of a valued procedure.
5327 It's a copy mechanism for which a parameter is never allocated. */
5329 {
5333 }
5335 /* If this is either a foreign function or if the underlying type won't
5336 be passed by reference, strip off possible padding type. */
5338 {
5342 || foreign
5346 }
5348 /* If this is a read-only parameter, make a variant of the type that is
5349 read-only. ??? However, if this is an unconstrained array, that type
5350 can be very complex, so skip it for now. Likewise for any other
5351 self-referential type. */
5359 /* For foreign conventions, pass arrays as pointers to the element type.
5360 First check for unconstrained array and get the underlying array. */
5362 gnu_param_type
5365 /* For GCC builtins, pass Address integer types as (void *) */
5371 /* VMS descriptors are themselves passed by reference. */
5374 gnu_param_type
5377 gnat_subprog));
5379 {
5380 /* Build both a 32-bit and 64-bit descriptor, one of which will be
5381 chosen in fill_vms_descriptor. */
5382 gnu_param_type_alt
5385 gnat_subprog));
5386 gnu_param_type
5389 gnat_subprog));
5390 }
5392 /* Arrays are passed as pointers to element type for foreign conventions. */
5396 {
5397 /* Strip off any multi-dimensional entries, then strip
5398 off the last array to get the component type. */
5412 }
5414 /* Fat pointers are passed as thin pointers for foreign conventions. */
5416 gnu_param_type
5419 /* If we must pass or were requested to pass by reference, do so.
5420 If we were requested to pass by copy, do so.
5421 Otherwise, for foreign conventions, pass In Out or Out parameters
5422 or aggregates by reference. For COBOL and Fortran, pass all
5423 integer and FP types that way too. For Convention Ada, use
5424 the standard Ada default. */
5428 && ((foreign
5430 || (foreign
5435 || (!foreign
5437 {
5441 /* In some ABIs, e.g. SPARC 32-bit, fat pointer types are themselves
5442 passed by reference. Pass them by explicit reference, this will
5443 generate more debuggable code at -O0. */
5447 gnu_param_type,
5449 {
5452 }
5453 }
5455 /* Pass In Out or Out parameters using copy-in copy-out mechanism. */
5462 /* If this is an Out parameter that isn't passed by reference and isn't
5463 a pointer or aggregate, we don't make a PARM_DECL for it. Instead,
5464 it will be a VAR_DECL created when we process the procedure, so just
5465 return its type. For the special parameter of a valued procedure,
5466 never pass it in.
5468 An exception is made to cover the RM-6.4.1 rule requiring "by copy"
5469 Out parameters with discriminants or implicit initial values to be
5470 handled like In Out parameters. These type are normally built as
5471 aggregates, hence passed by reference, except for some packed arrays
5472 which end up encoded in special integer types.
5474 The exception we need to make is then for packed arrays of records
5475 with discriminants or implicit initial values. We have no light/easy
5476 way to check for the latter case, so we merely check for packed arrays
5477 of records. This may lead to useless copy-in operations, but in very
5478 rare cases only, as these would be exceptions in a set of already
5479 exceptional situations. */
5481 && !by_ref
5482 && (by_return
5502 /* Save the alternate descriptor type, if any. */
5506 /* If no Mechanism was specified, indicate what we're using, then
5507 back-annotate it. */
5513 }
5515 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
5517 static bool
5519 {
5526 return
5528 }
5530 /* Return true if the array type GNU_TYPE, which represents a dimension of
5531 GNAT_TYPE, has a non-aliased component in the back-end sense. */
5533 static bool
5535 {
5536 /* If the array type is not the innermost dimension of the GNAT type,
5537 then it has a non-aliased component. */
5542 /* If the array type has an aliased component in the front-end sense,
5543 then it also has an aliased component in the back-end sense. */
5547 /* If this is a derived type, then it has a non-aliased component if
5548 and only if its parent type also has one. */
5550 {
5554 gnu_parent_type
5559 }
5561 /* Otherwise, rely exclusively on properties of the element type. */
5563 }
5565 /* Return true if GNAT_ADDRESS is a value known at compile-time. */
5567 static bool
5569 {
5570 /* Catch System'To_Address. */
5575 }
5577 /* Return true if GNAT_RANGE, a N_Range node, cannot be superflat, i.e. if the
5578 inequality HB >= LB-1 is true. LB and HB are the low and high bounds. */
5580 static bool
5582 {
5584 Node_Id scalar_range;
5587 /* If the low bound is not constant, try to find an upper bound. */
5596 /* If the high bound is not constant, try to find a lower bound. */
5605 /* If we have failed to find constant bounds, punt. */
5610 /* We need at least a signed 64-bit type to catch most cases. */
5616 /* If the low bound is the smallest integer, nothing can be smaller. */
5622 }
5624 /* Return true if GNU_EXPR is (essentially) the address of a CONSTRUCTOR. */
5626 static bool
5628 {
5636 }
5637 \f
5638 /* Given GNAT_ENTITY, elaborate all expressions that are required to
5639 be elaborated at the point of its definition, but do nothing else. */
5641 void
5643 {
5645 {
5652 {
5656 /* ??? Tests to avoid Constraint_Error in static expressions
5657 are needed until after the front stops generating bogus
5658 conversions on bounds of real types. */
5666 }
5669 {
5673 /* If this is a record extension, go a level further to find the
5674 record definition. */
5677 }
5687 {
5688 Node_Id gnat_discriminant_expr;
5689 Entity_Id gnat_field;
5693 gnat_discriminant_expr
5698 /* ??? For now, ignore access discriminants. */
5703 }
5706 }
5707 }
5708 \f
5709 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
5710 any entities on its entity chain similarly. */
5712 void
5714 {
5715 Entity_Id gnat_sub_entity;
5718 /* If this has an entity list, process all in the list. */
5735 /* Now clear this if it has been defined, but only do so if it isn't
5736 a subprogram or parameter. We could refine this, but it isn't
5737 worth it. If this is statically allocated, it is supposed to
5738 hang around out of cope. */
5741 {
5744 }
5745 }
5746 \f
5747 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
5748 If this is a multi-dimensional array type, do this recursively.
5750 OP may be
5751 - ALIAS_SET_COPY: the new set is made a copy of the old one.
5752 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
5753 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
5755 static void
5757 {
5758 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
5759 of a one-dimensional array, since the padding has the same alias set
5760 as the field type, but if it's a multi-dimensional array, we need to
5761 see the inner types. */
5767 /* Unconstrained array types are deemed incomplete and would thus be given
5768 alias set 0. Retrieve the underlying array type. */
5770 gnu_old_type
5773 gnu_new_type
5782 {
5784 /* The alias set shouldn't be copied between array types with different
5785 aliasing settings because this can break the aliasing relationship
5786 between the array type and its element type. */
5787 #ifndef ENABLE_CHECKING
5789 #endif
5800 {
5804 /* Do nothing if the alias sets conflict. This ensures that we
5805 never call record_alias_subset several times for the same pair
5806 or at all for alias set 0. */
5808 {
5811 else
5813 }
5814 }
5819 }
5822 }
5823 \f
5824 /* Return true if the size represented by GNU_SIZE can be handled by an
5825 allocation. If STATIC_P is true, consider only what can be done with a
5826 static allocation. */
5828 static bool
5830 {
5831 HOST_WIDE_INT our_size;
5833 /* If this is not a static allocation, the only case we want to forbid
5834 is an overflowing size. That will be converted into a raise a
5835 Storage_Error. */
5840 /* Otherwise, we need to deal with both variable sizes and constant
5841 sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
5842 since assemblers may not like very large sizes. */
5848 }
5849 \f
5850 /* Prepend to ATTR_LIST an entry for an attribute with provided TYPE,
5851 NAME, ARGS and ERROR_POINT. */
5853 static void
5856 tree attr_name,
5857 tree attr_args,
5858 Node_Id attr_error_point)
5859 {
5869 }
5871 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
5873 static void
5875 {
5876 Node_Id gnat_temp;
5878 /* Attributes are stored as Representation Item pragmas. */
5883 {
5888 /* Map the kind of pragma at hand. Skip if this is not one
5889 we know how to handle. */
5892 {
5923 }
5925 /* See what arguments we have and turn them into GCC trees for
5926 attribute handlers. These expect identifier for strings. We
5927 handle at most two arguments, static expressions only. */
5930 {
5936 {
5943 }
5947 {
5952 }
5953 }
5955 /* Prepend to the list now. Make a list of the argument we might
5956 have, as GCC expects it. */
5957 prepend_one_attribute_to
5964 }
5965 }
5966 \f
5967 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
5968 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
5969 return the GCC tree to use for that expression. GNU_NAME is the suffix
5970 to use if a variable needs to be created and DEFINITION is true if this
5971 is a definition of GNAT_ENTITY. If NEED_VALUE is true, we need a result;
5972 otherwise, we are just elaborating the expression for side-effects. If
5973 NEED_DEBUG is true, we need a variable for debugging purposes even if it
5974 isn't needed for code generation. */
5976 static tree
5979 {
5980 tree gnu_expr;
5982 /* If we already elaborated this expression (e.g. it was involved
5983 in the definition of a private type), use the old value. */
5987 /* If we don't need a value and this is static or a discriminant,
5988 we don't need to do anything. */
5995 /* If it's a static expression, we don't need a variable for debugging. */
5999 /* Otherwise, convert this tree to its GCC equivalent and elaborate it. */
6003 /* Save the expression in case we try to elaborate this entity again. Since
6004 it's not a DECL, don't check it. Don't save if it's a discriminant. */
6009 }
6011 /* Similar, but take a GNU expression and always return a result. */
6013 static tree
6016 {
6020 /* In most cases, we won't see a naked FIELD_DECL because a discriminant
6021 reference will have been replaced with a COMPONENT_REF when the type
6022 is being elaborated. However, there are some cases involving child
6023 types where we will. So convert it to a COMPONENT_REF. We hope it
6024 will be at the highest level of the expression in these cases. */
6030 /* If GNU_EXPR contains a placeholder, just return it. We rely on the fact
6031 that an expression cannot contain both a discriminant and a variable. */
6035 /* If GNU_EXPR is neither a constant nor based on a read-only variable, make
6036 a variable that is initialized to contain the expression when the package
6037 containing the definition is elaborated. If this entity is defined at top
6038 level, replace the expression by the variable; otherwise use a SAVE_EXPR
6039 if this is necessary. */
6042 else
6043 {
6044 /* Skip any conversions and simple arithmetics to see if the expression
6045 is based on a read-only variable.
6046 ??? This really should remain read-only, but we have to think about
6047 the typing of the tree here. */
6048 tree inner
6052 {
6054 tree offset;
6060 /* If the offset is variable, err on the side of caution. */
6063 }
6065 expr_variable_p
6066 = !(inner
6069 }
6071 /* We only need to use the variable if we are in a global context since GCC
6072 can do the right thing in the local case. However, when not optimizing,
6073 use it for bounds of loop iteration scheme to avoid code duplication. */
6074 use_variable = expr_variable_p
6075 && (expr_global_p
6076 || (!optimize
6081 /* Now create it, possibly only for debugging purposes. */
6083 {
6084 tree gnu_decl
6093 }
6096 }
6098 /* Similar, but take an alignment factor and make it explicit in the tree. */
6100 static tree
6103 {
6105 return
6108 gnu_expr,
6109 unit_align),
6111 need_debug),
6112 unit_align);
6113 }
6114 \f
6115 /* Create a record type that contains a SIZE bytes long field of TYPE with a
6116 starting bit position so that it is aligned to ALIGN bits, and leaving at
6117 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
6118 record is guaranteed to get. */
6120 tree
6123 {
6124 /* We will be crafting a record type with one field at a position set to be
6125 the next multiple of ALIGN past record'address + room bytes. We use a
6126 record placeholder to express record'address. */
6130 tree record_addr_st
6133 /* The diagram below summarizes the shape of what we manipulate:
6135 <--------- pos ---------->
6136 { +------------+-------------+-----------------+
6137 record =>{ |############| ... | field (type) |
6138 { +------------+-------------+-----------------+
6139 |<-- room -->|<- voffset ->|<---- size ----->|
6140 o o
6141 | |
6142 record_addr vblock_addr
6144 Every length is in sizetype bytes there, except "pos" which has to be
6145 set as a bit position in the GCC tree for the record. */
6157 /* Compute VOFFSET and then POS. The next byte position multiple of some
6158 alignment after some address is obtained by "and"ing the alignment minus
6159 1 with the two's complement of the address. */
6164 /* POS = (ROOM + VOFFSET) * BIT_PER_UNIT, in bitsizetype. */
6168 bitsize_unit_node);
6170 /* Craft the GCC record representation. We exceptionally do everything
6171 manually here because 1) our generic circuitry is not quite ready to
6172 handle the complex position/size expressions we are setting up, 2) we
6173 have a strong simplifying factor at hand: we know the maximum possible
6174 value of voffset, and 3) we have to set/reset at least the sizes in
6175 accordance with this maximum value anyway, as we need them to convey
6176 what should be "alloc"ated for this type.
6178 Use -1 as the 'addressable' indication for the field to prevent the
6179 creation of a bitfield. We don't need one, it would have damaging
6180 consequences on the alignment computation, and create_field_decl would
6181 make one without this special argument, for instance because of the
6182 complex position expression. */
6193 bitsize_unit_node),
6202 /* Declare it now since it will never be declared otherwise. This is
6203 necessary to ensure that its subtrees are properly marked. */
6207 }
6208 \f
6209 /* Return the result of rounding T up to ALIGN. */
6213 {
6218 }
6220 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
6221 as the field type of a packed record if IN_RECORD is true, or as the
6222 component type of a packed array if IN_RECORD is false. See if we can
6223 rewrite it either as a type that has a non-BLKmode, which we can pack
6224 tighter in the packed record case, or as a smaller type. If so, return
6225 the new type. If not, return the original type. */
6227 static tree
6229 {
6234 /* No point in doing anything if the size is zero. */
6240 /* Copy the name and flags from the old type to that of the new.
6241 Note that we rely on the pointer equality created here for
6242 TYPE_NAME to look through conversions in various places. */
6249 /* If we are in a record and have a small size, set the alignment to
6250 try for an integral mode. Otherwise set it to try for a smaller
6251 type with BLKmode. */
6253 {
6256 }
6257 else
6258 {
6261 /* Do not try to shrink the size if the RM size is not constant. */
6266 /* Round the RM size up to a unit boundary to get the minimal size
6267 for a BLKmode record. Give up if it's already the size. */
6275 }
6279 /* Now copy the fields, keeping the position and size as we don't want
6280 to change the layout by propagating the packedness downwards. */
6283 {
6294 /* However, for the last field in a not already packed record type
6295 that is of an aggregate type, we need to use the RM size in the
6296 packable version of the record type, see finish_record_type. */
6306 else
6309 new_field
6322 }
6327 /* If this is a padding record, we never want to make the size smaller
6328 than what was specified. For QUAL_UNION_TYPE, also copy the size. */
6330 {
6334 }
6335 else
6336 {
6340 }
6347 /* Try harder to get a packable type if necessary, for example
6348 in case the record itself contains a BLKmode field. */
6353 /* If neither the mode nor the size has shrunk, return the old type. */
6358 }
6359 \f
6360 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
6361 if needed. We have already verified that SIZE and TYPE are large enough.
6362 GNAT_ENTITY is used to name the resulting record and to issue a warning.
6363 IS_COMPONENT_TYPE is true if this is being done for the component type
6364 of an array. IS_USER_TYPE is true if we must complete the original type.
6365 DEFINITION is true if this type is being defined. SAME_RM_SIZE is true
6366 if the RM size of the resulting type is to be set to SIZE too; otherwise,
6367 it's set to the RM size of the original type. */
6369 tree
6373 {
6378 /* If TYPE is a padded type, see if it agrees with any size and alignment
6379 we were given. If so, return the original type. Otherwise, strip
6380 off the padding, since we will either be returning the inner type
6381 or repadding it. If no size or alignment is specified, use that of
6382 the original padded type. */
6384 {
6401 }
6403 /* If the size is either not being changed or is being made smaller (which
6404 is not done here and is only valid for bitfields anyway), show the size
6405 isn't changing. Likewise, clear the alignment if it isn't being
6406 changed. Then return if we aren't doing anything. */
6419 /* If requested, complete the original type and give it a name. */
6426 gnat_entity);
6428 /* We used to modify the record in place in some cases, but that could
6429 generate incorrect debugging information. So make a new record
6430 type and name. */
6445 bitsize_unit_node));
6447 /* If we are changing the alignment and the input type is a record with
6448 BLKmode and a small constant size, try to make a form that has an
6449 integral mode. This might allow the padding record to also have an
6450 integral mode, which will be much more efficient. There is no point
6451 in doing so if a size is specified unless it is also a small constant
6452 size and it is incorrect to do so if we cannot guarantee that the mode
6453 will be naturally aligned since the field must always be addressable.
6455 ??? This might not always be a win when done for a stand-alone object:
6456 since the nominal and the effective type of the object will now have
6457 different modes, a VIEW_CONVERT_EXPR will be required for converting
6458 between them and it might be hard to overcome afterwards, including
6459 at the RTL level when the stand-alone object is accessed as a whole. */
6466 && (!size
6469 {
6474 }
6476 /* Now create the field with the original size. */
6481 /* Do not emit debug info until after the auxiliary record is built. */
6484 /* Set the same size for its RM size if requested; otherwise reuse
6485 the RM size of the original type. */
6488 /* Unless debugging information isn't being written for the input type,
6489 write a record that shows what we are a subtype of and also make a
6490 variable that indicates our size, if still variable. */
6496 {
6522 }
6526 /* If the size was widened explicitly, maybe give a warning. Take the
6527 original size as the maximum size of the input if there was an
6528 unconstrained record involved and round it up to the specified alignment,
6529 if one was specified. */
6537 && size
6546 {
6559 /* Generate message only for entities that come from source, since
6560 if we have an entity created by expansion, the message will be
6561 generated for some other corresponding source entity. */
6563 {
6572 }
6573 }
6576 }
6577 \f
6578 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
6579 the value passed against the list of choices. */
6581 tree
6583 {
6584 Node_Id choice;
6585 Node_Id gnat_temp;
6590 {
6592 {
6597 this_test
6611 this_test
6621 /* This represents either a subtype range, an enumeration
6622 literal, or a constant Ekind says which. If an enumeration
6623 literal or constant, fall through to the next case. */
6626 {
6632 this_test
6639 }
6641 /* ... fall through ... */
6647 single);
6656 }
6659 this_test);
6660 }
6663 }
6664 \f
6665 /* Adjust PACKED setting as passed to gnat_to_gnu_field for a field of
6666 type FIELD_TYPE to be placed in RECORD_TYPE. Return the result. */
6668 static int
6670 {
6671 /* If the field contains an item of variable size, we cannot pack it
6672 because we cannot create temporaries of non-fixed size in case
6673 we need to take the address of the field. See addressable_p and
6674 the notes on the addressability issues for further details. */
6678 /* If the alignment of the record is specified and the field type
6679 is over-aligned, request Storage_Unit alignment for the field. */
6681 {
6684 else
6686 }
6689 }
6691 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
6692 placed in GNU_RECORD_TYPE.
6694 PACKED is 1 if the enclosing record is packed, -1 if the enclosing
6695 record has Component_Alignment of Storage_Unit, -2 if the enclosing
6696 record has a specified alignment.
6698 DEFINITION is true if this field is for a record being defined.
6700 DEBUG_INFO_P is true if we need to write debug information for types
6701 that we may create in the process. */
6703 static tree
6706 {
6710 bool needs_strict_alignment
6714 /* If this field requires strict alignment, we cannot pack it because
6715 it would very likely be under-aligned in the record. */
6718 else
6721 /* If a size is specified, use it. Otherwise, if the record type is packed,
6722 use the official RM size. See "Handling of Type'Size Values" in Einfo
6723 for further details. */
6730 else
6733 /* If we have a specified size that is smaller than that of the field's type,
6734 or a position is specified, and the field's type is a record that doesn't
6735 require strict alignment, see if we can get either an integral mode form
6736 of the type or a smaller form. If we can, show a size was specified for
6737 the field if there wasn't one already, so we know to make this a bitfield
6738 and avoid making things wider.
6740 Changing to an integral mode form is useful when the record is packed as
6741 we can then place the field at a non-byte-aligned position and so achieve
6742 tighter packing. This is in addition required if the field shares a byte
6743 with another field and the front-end lets the back-end handle the access
6744 to the field, because GCC cannot handle non-byte-aligned BLKmode fields.
6746 Changing to a smaller form is required if the specified size is smaller
6747 than that of the field's type and the type contains sub-fields that are
6748 padded, in order to avoid generating accesses to these sub-fields that
6749 are wider than the field.
6751 We avoid the transformation if it is not required or potentially useful,
6752 as it might entail an increase of the field's alignment and have ripple
6753 effects on the outer record type. A typical case is a field known to be
6754 byte-aligned and not to share a byte with another field. */
6760 || (gnu_size
6766 {
6769 {
6773 }
6774 }
6776 /* If we are packing the record and the field is BLKmode, round the
6777 size up to a byte boundary. */
6782 {
6783 Entity_Id gnat_parent
6790 /* Ensure the position does not overlap with the parent subtype, if there
6791 is one. This test is omitted if the parent of the tagged type has a
6792 full rep clause since, in this case, component clauses are allowed to
6793 overlay the space allocated for the parent type and the front-end has
6794 checked that there are no overlapping components. */
6796 {
6801 {
6802 post_error_ne_tree
6806 }
6807 }
6809 /* If this field needs strict alignment, ensure the record is
6810 sufficiently aligned and that that position and size are
6811 consistent with the alignment. */
6813 {
6819 {
6821 post_error_ne_tree
6827 post_error_ne_tree
6833 post_error_ne_tree
6839 }
6844 {
6846 post_error_ne_num
6852 post_error_ne_num
6858 post_error_ne_num
6863 else
6867 }
6868 }
6872 }
6874 /* If the record has rep clauses and this is the tag field, make a rep
6875 clause for it as well. */
6878 {
6881 }
6883 else
6886 /* We need to make the size the maximum for the type if it is
6887 self-referential and an unconstrained type. In that case, we can't
6888 pack the field since we can't make a copy to align it. */
6890 && !gnu_size
6893 {
6896 }
6898 /* If a size is specified, adjust the field's type to it. */
6900 {
6901 tree orig_field_type;
6903 /* If the field's type is justified modular, we would need to remove
6904 the wrapper to (better) meet the layout requirements. However we
6905 can do so only if the field is not aliased to preserve the unique
6906 layout and if the prescribed size is not greater than that of the
6907 packed array to preserve the justification. */
6915 gnu_field_type
6923 /* If a padding record was made, declare it now since it will never be
6924 declared otherwise. This is necessary to ensure that its subtrees
6925 are properly marked. */
6930 }
6932 /* Otherwise (or if there was an error), don't specify a position. */
6933 else
6939 /* Now create the decl for the field. */
6940 gnu_field
6951 }
6952 \f
6953 /* Return true if TYPE is a type with variable size, a padding type with a
6954 field of variable size or is a record that has a field such a field. */
6956 static bool
6958 {
6959 tree field;
6978 }
6979 \f
6980 /* qsort comparer for the bit positions of two record components. */
6982 static int
6984 {
6987 const int ret
6991 }
6993 /* Translate and chain the GNAT_COMPONENT_LIST to the GNU_FIELD_LIST, set
6994 the result as the field list of GNU_RECORD_TYPE and finish it up. When
6995 called from gnat_to_gnu_entity during the processing of a record type
6996 definition, the GCC node for the parent, if any, will be the single field
6997 of GNU_RECORD_TYPE and the GCC nodes for the discriminants will be on the
6998 GNU_FIELD_LIST. The other calls to this function are recursive calls for
6999 the component list of a variant and, in this case, GNU_FIELD_LIST is empty.
7001 PACKED is 1 if this is for a packed record, -1 if this is for a record
7002 with Component_Alignment of Storage_Unit, -2 if this is for a record
7003 with a specified alignment.
7005 DEFINITION is true if we are defining this record type.
7007 CANCEL_ALIGNMENT is true if the alignment should be zeroed before laying
7008 out the record. This means the alignment only serves to force fields to
7009 be bitfields, but not to require the record to be that aligned. This is
7010 used for variants.
7012 ALL_REP is true if a rep clause is present for all the fields.
7014 UNCHECKED_UNION is true if we are building this type for a record with a
7015 Pragma Unchecked_Union.
7017 DEBUG_INFO is true if we need to write debug information about the type.
7019 MAYBE_UNUSED is true if this type may be unused in the end; this doesn't
7020 mean that its contents may be unused as well, only the container itself.
7022 REORDER is true if we are permitted to reorder components of this type.
7024 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
7025 with a rep clause is to be added; in this case, that is all that should
7026 be done with such fields. */
7028 static void
7035 {
7045 /* For each component referenced in a component declaration create a GCC
7046 field and add it to the list, skipping pragmas in the GNAT list. */
7053 {
7057 /* If present, the _Parent field must have been created as the single
7058 field of the record type. Put it before any other fields. */
7060 {
7063 }
7064 else
7065 {
7069 /* If this is the _Tag field, put it before any other fields. */
7073 /* If this is the _Controller field, put it before the other
7074 fields except for the _Tag or _Parent field. */
7076 {
7079 }
7081 /* If this is a regular field, put it after the other fields. */
7082 else
7083 {
7088 }
7089 }
7092 }
7094 /* At the end of the component list there may be a variant part. */
7097 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
7098 mutually exclusive and should go in the same memory. To do this we need
7099 to treat each variant as a record whose elements are created from the
7100 component list for the variant. So here we create the records from the
7101 lists for the variants and put them all into the QUAL_UNION_TYPE.
7102 If this is an Unchecked_Union, we make a UNION_TYPE instead or
7103 use GNU_RECORD_TYPE if there are no fields so far. */
7105 {
7109 tree gnu_var_name
7118 gnu_union_name
7121 /* Reuse an enclosing union if all fields are in the variant part
7122 and there is no representation clause on the record, to match
7123 the layout of C unions. There is an associated check below. */
7128 else
7129 {
7130 gnu_union_type
7136 }
7141 {
7143 tree gnu_inner_name;
7144 tree gnu_qual;
7152 /* Set the alignment of the inner type in case we need to make
7153 inner objects into bitfields, but then clear it out so the
7154 record actually gets only the alignment required. */
7158 /* Similarly, if the outer record has a size specified and all
7159 fields have record rep clauses, we can propagate the size
7160 into the variant part. */
7162 {
7166 }
7168 /* Add the fields into the record type for the variant. Note that
7169 we aren't sure to really use it at this point, see below. */
7180 /* If this is an Unchecked_Union and we have exactly one field,
7181 use this field directly to match the layout of C unions. */
7186 else
7187 {
7188 /* Deal with packedness like in gnat_to_gnu_field. */
7189 int field_packed
7192 /* Finalize the record type now. We used to throw away
7193 empty records but we no longer do that because we need
7194 them to generate complete debug info for the variant;
7195 otherwise, the union type definition will be lacking
7196 the fields associated with these empty variants. */
7201 gnu_field
7203 gnu_union_type,
7204 all_rep_and_size
7206 all_rep_and_size
7214 }
7218 }
7220 /* Only make the QUAL_UNION_TYPE if there are non-empty variants. */
7222 {
7226 {
7230 }
7235 /* If GNU_UNION_TYPE is our record type, it means we must have an
7236 Unchecked_Union with no fields. Verify that and, if so, just
7237 return. */
7239 {
7241 && !gnu_field_list
7244 }
7249 /* Deal with packedness like in gnat_to_gnu_field. */
7250 union_field_packed
7253 gnu_variant_part
7262 }
7263 }
7265 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses and, if we are
7266 permitted to reorder components, self-referential sizes or variable sizes.
7267 If they do, pull them out and put them onto the appropriate list. We have
7268 to do this in a separate pass since we want to handle the discriminants
7269 but can't play with them until we've used them in debugging data above.
7271 ??? If we reorder them, debugging information will be wrong but there is
7272 nothing that can be done about this at the moment. */
7275 #define MOVE_FROM_FIELD_LIST_TO(LIST) \
7276 do { \
7277 if (gnu_last) \
7278 DECL_CHAIN (gnu_last) = gnu_next; \
7279 else \
7280 gnu_field_list = gnu_next; \
7281 \
7282 DECL_CHAIN (gnu_field) = (LIST); \
7283 (LIST) = gnu_field; \
7284 } while (0)
7287 {
7291 {
7294 }
7297 {
7298 /* Pull out the variant part and put it onto GNU_SELF_LIST. */
7300 {
7303 }
7305 /* Skip internal fields and fields with fixed size. */
7309 {
7313 {
7316 }
7319 {
7322 }
7323 }
7324 }
7327 }
7329 #undef MOVE_FROM_FIELD_LIST_TO
7331 /* If permitted, we reorder the components as follows:
7333 1) all fixed length fields,
7334 2) all fields whose length doesn't depend on discriminants,
7335 3) all fields whose length depends on discriminants,
7336 4) the variant part,
7338 within the record and within each variant recursively. */
7340 gnu_field_list
7344 /* If we have any fields in our rep'ed field list and it is not the case that
7345 all the fields in the record have rep clauses and P_REP_LIST is nonzero,
7346 set it and ignore these fields. */
7350 /* Otherwise, sort the fields by bit position and put them into their own
7351 record, before the others, if we also have fields without rep clauses. */
7353 {
7354 tree gnu_rep_type
7360 gnu_field;
7366 /* Put the fields in the list in order of increasing position, which
7367 means we start from the end. */
7370 {
7374 }
7377 {
7379 gnu_field
7384 }
7385 else
7386 {
7389 }
7390 }
7397 }
7398 \f
7399 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
7400 placed into an Esize, Component_Bit_Offset, or Component_Size value
7401 in the GNAT tree. */
7403 static Uint
7405 {
7406 TCode tcode;
7411 /* See if we've already saved the value for this node. */
7413 {
7424 }
7426 /* If we do not return inside this switch, TCODE will be set to the
7427 code to use for a Create_Node operand and LEN (set above) will be
7428 the number of recursive calls for us to make. */
7431 {
7436 /* This may come from a conversion from some smaller type, so ensure
7437 this is in bitsizetype. */
7440 /* For a negative value, build NEGATE_EXPR of the opposite. Such values
7441 appear in expressions containing aligning patterns. Note that, since
7442 sizetype is sign-extended but nonetheless unsigned, we don't directly
7443 use tree_int_cst_sgn. */
7445 {
7448 }
7453 /* The only case we handle here is a simple discriminant reference. */
7461 else
7467 /* Now just list the operations we handle. */
7498 {
7502 }
7504 /* Fall through... */
7508 }
7510 /* Now get each of the operands that's relevant for this code. If any
7511 cannot be expressed as a repinfo node, say we can't. */
7516 {
7520 }
7524 /* Save the result in the cache. */
7526 {
7530 }
7533 }
7535 /* Given GNAT_ENTITY, an object (constant, variable, parameter, exception)
7536 and GNU_TYPE, its corresponding GCC type, set Esize and Alignment to the
7537 size and alignment used by Gigi. Prefer SIZE over TYPE_SIZE if non-null.
7538 BY_REF is true if the object is used by reference and BY_DOUBLE_REF is
7539 true if the object is used by double reference. */
7541 void
7544 {
7546 {
7552 else
7554 }
7557 {
7566 }
7571 }
7573 /* Return first element of field list whose TREE_PURPOSE is the same as ELEM.
7574 Return NULL_TREE if there is no such element in the list. */
7576 static tree
7578 {
7580 {
7585 }
7587 }
7589 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding GCC type,
7590 set Component_Bit_Offset and Esize of the components to the position and
7591 size used by Gigi. */
7593 static void
7595 {
7596 Entity_Id gnat_field;
7597 tree gnu_list;
7599 /* We operate by first making a list of all fields and their position (we
7600 can get the size easily) and then update all the sizes in the tree. */
7601 gnu_list
7611 {
7613 gnu_list);
7615 {
7616 tree parent_offset;
7619 {
7620 /* In this mode the tag and parent components are not
7621 generated, so we add the appropriate offset to each
7622 component. For a component appearing in the current
7623 extension, the offset is the size of the parent. */
7626 parent_offset
7628 bitsizetype);
7629 else
7631 }
7632 else
7635 Set_Component_Bit_Offset
7637 annotate_value
7641 parent_offset)));
7645 }
7647 {
7648 /* If there is no entry, this is an inherited component whose
7649 position is the same as in the parent type. */
7650 Set_Component_Bit_Offset
7656 }
7657 }
7658 }
7659 \f
7660 /* Scan all fields in GNU_TYPE and return a TREE_LIST where TREE_PURPOSE is
7661 the FIELD_DECL and TREE_VALUE a TREE_VEC containing the byte position, the
7662 value to be placed into DECL_OFFSET_ALIGN and the bit position. The list
7663 of fields is flattened, except for variant parts if DO_NOT_FLATTEN_VARIANT
7664 is set to true. GNU_POS is to be added to the position, GNU_BITPOS to the
7665 bit position, OFFSET_ALIGN is the present offset alignment. GNU_LIST is a
7666 pre-existing list to be chained to the newly created entries. */
7668 static tree
7671 {
7672 tree gnu_field;
7675 gnu_field;
7677 {
7682 unsigned int our_offset_align
7691 /* Recurse on internal fields, flattening the nested fields except for
7692 those in the variant part, if requested. */
7694 {
7698 gnu_list
7702 else
7703 gnu_list
7707 }
7708 }
7711 }
7713 /* Return a VEC describing the substitutions needed to reflect the
7714 discriminant substitutions from GNAT_TYPE to GNAT_SUBTYPE. They can
7715 be in any order. The values in an element of the VEC are in the form
7716 of operands to SUBSTITUTE_IN_EXPR. DEFINITION is true if this is for
7717 a definition of GNAT_SUBTYPE. */
7721 {
7723 Entity_Id gnat_discrim;
7724 Node_Id gnat_value;
7731 /* Ignore access discriminants. */
7733 {
7736 elaborate_expression
7743 }
7746 }
7748 /* Scan all fields in QUAL_UNION_TYPE and return a VEC describing the
7749 variants of QUAL_UNION_TYPE that are still relevant after applying
7750 the substitutions described in SUBST_LIST. VARIANT_LIST is a
7751 pre-existing VEC onto which newly created entries should be
7752 pushed. */
7757 {
7758 tree gnu_field;
7761 gnu_field;
7763 {
7771 /* If the new qualifier is not unconditionally false, its variant may
7772 still be accessed. */
7774 {
7784 /* Recurse on the variant subpart of the variant, if any. */
7790 /* If the new qualifier is unconditionally true, the subsequent
7791 variants cannot be accessed. */
7794 }
7795 }
7798 }
7799 \f
7800 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
7801 corresponding to GNAT_OBJECT. If the size is valid, return an INTEGER_CST
7802 corresponding to its value. Otherwise, return NULL_TREE. KIND is set to
7803 VAR_DECL if we are specifying the size of an object, TYPE_DECL for the
7804 size of a type, and FIELD_DECL for the size of a field. COMPONENT_P is
7805 true if we are being called to process the Component_Size of GNAT_OBJECT;
7806 this is used only for error messages. ZERO_OK is true if a size of zero
7807 is permitted; if ZERO_OK is false, it means that a size of zero should be
7808 treated as an unspecified size. */
7810 static tree
7813 {
7814 Node_Id gnat_error_node;
7817 /* Return 0 if no size was specified. */
7821 /* Ignore a negative size since that corresponds to our back-annotation. */
7825 /* Find the node to use for error messages. */
7832 else
7835 /* Get the size as an INTEGER_CST. Issue an error if a size was specified
7836 but cannot be represented in bitsizetype. */
7839 {
7842 gnat_object);
7843 else
7845 gnat_object);
7847 }
7849 /* Ignore a zero size if it is not permitted. */
7853 /* The size of objects is always a multiple of a byte. */
7856 {
7860 else
7864 }
7866 /* If this is an integral type or a packed array type, the front-end has
7867 already verified the size, so we need not do it here (which would mean
7868 checking against the bounds). However, if this is an aliased object,
7869 it may not be smaller than the type of the object. */
7874 /* If the object is a record that contains a template, add the size of the
7875 template to the specified size. */
7881 /* If a type needs strict alignment, a component of this type in
7882 a packed record cannot be packed and thus uses the type size. */
7885 else
7888 /* Modify the size of a discriminated type to be the maximum size. */
7892 /* If this is an access type or a fat pointer, the minimum size is that given
7893 by the smallest integral mode that's valid for pointers. */
7895 {
7900 }
7902 /* Issue an error either if the default size of the object isn't a constant
7903 or if the new size is smaller than it. */
7907 {
7909 post_error_ne_tree
7912 else
7913 post_error_ne_tree
7917 }
7920 }
7921 \f
7922 /* Similarly, but both validate and process a value of RM size. This routine
7923 is only called for types. */
7925 static void
7927 {
7928 Node_Id gnat_attr_node;
7931 /* Do nothing if no size was specified. */
7935 /* Ignore a negative size since that corresponds to our back-annotation. */
7939 /* Only issue an error if a Value_Size clause was explicitly given.
7940 Otherwise, we'd be duplicating an error on the Size clause. */
7941 gnat_attr_node
7944 /* Get the size as an INTEGER_CST. Issue an error if a size was specified
7945 but cannot be represented in bitsizetype. */
7948 {
7951 gnat_entity);
7953 }
7955 /* Ignore a zero size unless a Value_Size clause exists, or a size clause
7956 exists, or this is an integer type, in which case the front-end will
7957 have always set it. */
7966 /* If the old size is self-referential, get the maximum size. */
7970 /* Issue an error either if the old size of the object isn't a constant or
7971 if the new size is smaller than it. The front-end has already verified
7972 this for scalar and packed array types. */
7980 && TYPE_PACKED_ARRAY_TYPE_P
7983 {
7985 post_error_ne_tree
7989 }
7991 /* Otherwise, set the RM size proper for integral types... */
7998 /* ...or the Ada size for record and union types. */
8004 }
8005 \f
8006 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
8007 If TYPE is the best type, return it. Otherwise, make a new type. We
8008 only support new integral and pointer types. FOR_BIASED is true if
8009 we are making a biased type. */
8011 static tree
8013 {
8016 tree new_type;
8018 /* If size indicates an error, just return TYPE to avoid propagating
8019 the error. Likewise if it's too large to represent. */
8026 {
8033 /* Integer types with precision 0 are forbidden. */
8037 /* Only do something if the type is not a packed array type and
8038 doesn't already have the proper size. */
8049 else
8058 /* Copy the name to show that it's essentially the same type and
8059 not a subrange type. */
8066 /* Do something if this is a fat pointer, in which case we
8067 may need to return the thin pointer. */
8069 {
8073 return
8074 build_pointer_type_for_mode
8077 }
8081 /* Only do something if this is a thin pointer, in which case we
8082 may need to return the fat pointer. */
8084 return
8090 }
8093 }
8094 \f
8095 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
8096 a type or object whose present alignment is ALIGN. If this alignment is
8097 valid, return it. Otherwise, give an error and return ALIGN. */
8099 static unsigned int
8101 {
8104 Node_Id gnat_error_node;
8106 /* Don't worry about checking alignment if alignment was not specified
8107 by the source program and we already posted an error for this entity. */
8111 /* Post the error on the alignment clause if any. Note, for the implicit
8112 base type of an array type, the alignment clause is on the first
8113 subtype. */
8121 gnat_error_node =
8124 else
8127 /* Within GCC, an alignment is an integer, so we must make sure a value is
8128 specified that fits in that range. Also, there is an upper bound to
8129 alignments we can support/allow. */
8137 {
8141 /* If the default alignment of "double" or larger scalar types is
8142 specifically capped and the new alignment is above the cap, do
8143 not post an error and change the alignment only if there is an
8144 alignment clause; this makes it possible to have the associated
8145 GCC type overaligned by default for performance reasons. */
8147 {
8148 Entity_Id gnat_type
8150 is_capped_double
8152 }
8154 {
8155 Entity_Id gnat_type
8157 is_capped_double
8159 }
8160 else
8164 {
8167 }
8168 else
8169 {
8176 }
8177 }
8178 else
8179 {
8183 }
8186 }
8188 /* Return the smallest alignment not less than SIZE. */
8190 static unsigned int
8192 {
8194 }
8195 \f
8196 /* Verify that OBJECT, a type or decl, is something we can implement
8197 atomically. If not, give an error for GNAT_ENTITY. COMP_P is true
8198 if we require atomic components. */
8200 static void
8202 {
8204 Node_Id gnat_node;
8207 tree size;
8209 /* There are three case of what OBJECT can be. It can be a type, in which
8210 case we take the size, alignment and mode from the type. It can be a
8211 declaration that was indirect, in which case the relevant values are
8212 that of the type being pointed to, or it can be a normal declaration,
8213 in which case the values are of the decl. The code below assumes that
8214 OBJECT is either a type or a decl. */
8216 {
8217 /* If this is an anonymous base type, nothing to check. Error will be
8218 reported on the source type. */
8225 }
8227 {
8231 }
8232 else
8233 {
8237 }
8239 /* Consider all floating-point types atomic and any types that that are
8240 represented by integers no wider than a machine word. */
8247 /* For the moment, also allow anything that has an alignment equal
8248 to its size and which is smaller than a word. */
8256 {
8265 }
8270 else
8273 }
8274 \f
8276 /* Helper for the intrin compatibility checks family. Evaluate whether
8277 two types are definitely incompatible. */
8279 static bool
8281 {
8296 {
8303 /* Assume designated types are ok. We'd need to account for char * and
8304 void * variants to do better, which could rapidly get messy and isn't
8305 clearly worth the effort. */
8310 }
8313 }
8315 /* Helper for intrin_profiles_compatible_p, to perform compatibility checks
8316 on the Ada/builtin argument lists for the INB binding. */
8318 static bool
8320 {
8324 /* Sequence position of the last argument we checked. */
8328 {
8331 /* If one list is shorter than the other, they fail to match. */
8338 /* If we're done with the Ada args and not with the internal builtin
8339 args, or the other way around, complain. */
8342 {
8345 }
8349 {
8353 }
8355 /* Otherwise, check that types match for the current argument. */
8356 argpos ++;
8358 {
8362 }
8366 }
8369 }
8371 /* Helper for intrin_profiles_compatible_p, to perform compatibility checks
8372 on the Ada/builtin return values for the INB binding. */
8374 static bool
8376 {
8380 /* Accept function imported as procedure, common and convenient. */
8385 /* Check return types compatibility otherwise. Note that this
8386 handles void/void as well. */
8388 {
8392 }
8395 }
8397 /* Check and return whether the Ada and gcc builtin profiles bound by INB are
8398 compatible. Issue relevant warnings when they are not.
8400 This is intended as a light check to diagnose the most obvious cases, not
8401 as a full fledged type compatibility predicate. It is the programmer's
8402 responsibility to ensure correctness of the Ada declarations in Imports,
8403 especially when binding straight to a compiler internal. */
8405 static bool
8407 {
8408 /* Check compatibility on return values and argument lists, each responsible
8409 for posting warnings as appropriate. Ensure use of the proper sloc for
8410 this purpose. */
8423 }
8424 \f
8425 /* Return a FIELD_DECL node modeled on OLD_FIELD. FIELD_TYPE is its type
8426 and RECORD_TYPE is the type of the parent. If SIZE is nonzero, it is the
8427 specified size for this field. POS_LIST is a position list describing
8428 the layout of OLD_FIELD and SUBST_LIST a substitution list to be applied
8429 to this layout. */
8431 static tree
8435 {
8447 /* If the position is now a constant, we can set it as the position of the
8448 field when we make it. Otherwise, we need to deal with it specially. */
8451 else
8454 new_field
8460 {
8470 }
8478 }
8480 /* Return the REP part of RECORD_TYPE, if any. Otherwise return NULL. */
8482 static tree
8484 {
8487 /* The REP part is the first field, internal, another record, and its name
8488 doesn't start with an underscore (i.e. is not generated by the FE). */
8495 }
8497 /* Return the variant part of RECORD_TYPE, if any. Otherwise return NULL. */
8499 static tree
8501 {
8502 tree field;
8504 /* The variant part is the only internal field that is a qualified union. */
8511 }
8513 /* Return a new variant part modeled on OLD_VARIANT_PART. VARIANT_LIST is
8514 the list of variants to be used and RECORD_TYPE is the type of the parent.
8515 POS_LIST is a position list describing the layout of fields present in
8516 OLD_VARIANT_PART and SUBST_LIST a substitution list to be applied to this
8517 layout. */
8519 static tree
8524 {
8532 /* First create the type of the variant part from that of the old one. */
8536 /* If the position of the variant part is constant, subtract it from the
8537 size of the type of the parent to get the new size. This manual CSE
8538 reduces the code size when not optimizing. */
8540 {
8550 first_bit));
8553 }
8554 else
8557 /* Now finish up the new variants and populate the union type. */
8559 {
8563 /* Skip variants that don't belong to this nesting level. */
8567 /* Retrieve the list of fields already added to the new variant. */
8571 /* If the old variant had a variant subpart, we need to create a new
8572 variant subpart and add it to the field list. */
8576 {
8577 tree new_variant_subpart
8582 }
8584 /* Finish up the new variant and create the field. No need for debug
8585 info thanks to the XVS type. */
8591 new_field
8599 }
8601 /* Finish up the union type and create the variant part. No need for debug
8602 info thanks to the XVS type. */
8608 new_variant_part
8614 /* With multiple discriminants it is possible for an inner variant to be
8615 statically selected while outer ones are not; in this case, the list
8616 of fields of the inner variant is not flattened and we end up with a
8617 qualified union with a single member. Drop the useless container. */
8619 {
8628 }
8631 }
8633 /* Copy the size (and alignment and alias set) from OLD_TYPE to NEW_TYPE,
8634 which are both RECORD_TYPE, after applying the substitutions described
8635 in SUBST_LIST. */
8637 static void
8640 {
8664 SET_TYPE_ADA_SIZE
8668 /* Finalize the size. */
8671 }
8672 \f
8673 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a
8674 type with all size expressions that contain F in a PLACEHOLDER_EXPR
8675 updated by replacing F with R.
8677 The function doesn't update the layout of the type, i.e. it assumes
8678 that the substitution is purely formal. That's why the replacement
8679 value R must itself contain a PLACEHOLDER_EXPR. */
8681 tree
8683 {
8684 tree nt;
8689 {
8695 /* First the domain types of arrays. */
8698 {
8710 SET_TYPE_INDEX_TYPE
8714 }
8716 /* Then the subtypes. */
8719 {
8731 }
8743 /* These should never show up here. */
8747 {
8764 }
8769 {
8771 tree field;
8773 /* Start out with no fields, make new fields, and chain them
8774 in. If we haven't actually changed the type of any field,
8775 discard everything we've done and return the old type. */
8780 {
8785 {
8788 }
8792 {
8795 }
8797 /* Do the substitution inside the qualifier, if any. */
8799 {
8802 {
8805 }
8806 }
8813 }
8823 }
8827 }
8828 }
8829 \f
8830 /* Return the RM size of GNU_TYPE. This is the actual number of bits
8831 needed to represent the object. */
8833 tree
8835 {
8836 /* For integral types, we store the RM size explicitly. */
8840 /* Return the RM size of the actual data plus the size of the template. */
8843 return
8848 /* For record types, we store the size explicitly. */
8856 /* For other types, this is just the size. */
8858 }
8859 \f
8860 /* Return the name to be used for GNAT_ENTITY. If a type, create a
8861 fully-qualified name, possibly with type information encoding.
8862 Otherwise, return the name. */
8864 tree
8866 {
8869 }
8871 /* Return an identifier representing the external name to be used for
8872 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
8873 and the specified suffix. */
8875 tree
8877 {
8881 {
8885 }
8886 else
8889 /* A variable using the Stdcall convention lives in a DLL. We adjust
8890 its name to use the jump table, the _imp__NAME contains the address
8891 for the NAME variable. */
8894 {
8900 }
8903 }
8905 /* Given GNU_NAME, an IDENTIFIER_NODE containing a name and SUFFIX, a
8906 string, return a new IDENTIFIER_NODE that is the concatenation of
8907 the name followed by "___" and the specified suffix. */
8909 tree
8911 {
8918 }