| blob | 0d722f273ea3c345c5facf83dff2fb0e8905145b |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2009, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
20 * *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
23 * *
24 ****************************************************************************/
56 #ifndef MAX_FIXED_MODE_SIZE
57 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
58 #endif
60 /* Convention_Stdcall should be processed in a specific way on Windows targets
61 only. The macro below is a helper to avoid having to check for a Windows
62 specific attribute throughout this unit. */
64 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
65 #define Has_Stdcall_Convention(E) (Convention (E) == Convention_Stdcall)
66 #else
67 #define Has_Stdcall_Convention(E) (0)
68 #endif
70 /* Stack realignment for functions with foreign conventions is provided on a
71 per back-end basis now, as it is handled by the prologue expanders and not
72 as part of the function's body any more. It might be requested by way of a
73 dedicated function type attribute on the targets that support it.
75 We need a way to avoid setting the attribute on the targets that don't
76 support it and use FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN for this purpose.
78 It is defined on targets where the circuitry is available, and indicates
79 whether the realignment is needed for 'main'. We use this to decide for
80 foreign subprograms as well.
82 It is not defined on targets where the circuitry is not implemented, and
83 we just never set the attribute in these cases.
85 Whether it is defined on all targets that would need it in theory is
86 not entirely clear. We currently trust the base GCC settings for this
87 purpose. */
89 #ifndef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN
90 #define FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN 0
91 #endif
93 struct incomplete
94 {
96 tree old_type;
97 Entity_Id full_type;
98 };
100 /* These variables are used to defer recursively expanding incomplete types
101 while we are processing an array, a record or a subprogram type. */
105 /* This variable is used to delay expanding From_With_Type types until the
106 end of the spec. */
109 /* These variables are used to defer finalizing types. The element of the
110 list is the TYPE_DECL associated with the type. */
114 /* A hash table used to cache the result of annotate_value. */
118 enum alias_set_op
119 {
120 ALIAS_SET_COPY,
121 ALIAS_SET_SUBSET,
122 ALIAS_SET_SUPERSET
123 };
156 /* Return true if GNAT_ADDRESS is a compile time known value.
157 In particular catch System'To_Address. */
159 static bool
161 {
165 }
167 /* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
168 GCC type corresponding to that entity. GNAT_ENTITY is assumed to
169 refer to an Ada type. */
171 tree
173 {
174 tree gnu_decl;
176 /* The back end never attempts to annotate generic types */
180 /* Convert the ada entity type into a GCC TYPE_DECL node. */
184 }
185 \f
186 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
187 entity, this routine returns the equivalent GCC tree for that entity
188 (an ..._DECL node) and associates the ..._DECL node with the input GNAT
189 defining identifier.
191 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
192 initial value (in GCC tree form). This is optional for variables.
193 For renamed entities, GNU_EXPR gives the object being renamed.
195 DEFINITION is nonzero if this call is intended for a definition. This is
196 used for separate compilation where it necessary to know whether an
197 external declaration or a definition should be created if the GCC equivalent
198 was not created previously. The value of 1 is normally used for a nonzero
199 DEFINITION, but a value of 2 is used in special circumstances, defined in
200 the code. */
202 tree
204 {
206 tree gnu_entity_id;
208 /* Contains the gnu XXXX_DECL tree node which is equivalent to the input
209 GNAT tree. This node will be associated with the GNAT node by calling
210 the save_gnu_tree routine at the end of the `switch' statement. */
212 /* true if we have already saved gnu_decl as a gnat association. */
214 /* Nonzero if we incremented defer_incomplete_level. */
216 /* Nonzero if we incremented force_global. */
218 /* Nonzero if we should check to see if elaborated during processing. */
220 /* Nonzero if we made GNU_DECL and its type here. */
226 Entity_Id gnat_temp;
227 unsigned int esize
237 bool imported_p
241 /* Since a use of an Itype is a definition, process it as such if it
242 is not in a with'ed unit. */
247 {
248 /* Ensure that we are in a subprogram mentioned in the Scope
249 chain of this entity, our current scope is global,
250 or that we encountered a task or entry (where we can't currently
251 accurately check scoping). */
254 {
257 }
261 {
266 gnat_temp
278 && (current_function_decl
280 {
283 }
284 }
286 /* This abort means the entity "gnat_entity" has an incorrect scope,
287 i.e. that its scope does not correspond to the subprogram in which
288 it is declared */
290 }
292 /* If this is entity 0, something went badly wrong. */
295 /* If we've already processed this entity, return what we got last time.
296 If we are defining the node, we should not have already processed it.
297 In that case, we will abort below when we try to save a new GCC tree for
298 this object. We also need to handle the case of getting a dummy type
299 when a Full_View exists. */
303 {
310 {
316 }
319 }
321 /* If this is a numeric or enumeral type, or an access type, a nonzero
322 Esize must be specified unless it was specified by the programmer. */
331 /* Likewise, RM_Size must be specified for all discrete and fixed-point
332 types. */
336 /* Get the name of the entity and set up the line number and filename of
337 the original definition for use in any decl we make. */
341 /* If we get here, it means we have not yet done anything with this
342 entity. If we are not defining it here, it must be external,
343 otherwise we should have defined it already. */
350 /* For cases when we are not defining (i.e., we are referencing from
351 another compilation unit) Public entities, show we are at global level
352 for the purpose of computing scopes. Don't do this for components or
353 discriminants since the relevant test is whether or not the record is
354 being defined. But do this for Imported functions or procedures in
355 all cases. */
363 /* Handle any attributes directly attached to the entity. */
367 /* Machine_Attributes on types are expected to be propagated to subtypes.
368 The corresponding Gigi_Rep_Items are only attached to the first subtype
369 though, so we handle the propagation here. */
376 {
378 /* If this is a use of a deferred constant without address clause,
379 get its full definition. */
383 {
384 gnu_decl
388 }
390 /* If we have an external constant that we are not defining, get the
391 expression that is was defined to represent. We may throw that
392 expression away later if it is not a constant. Do not retrieve the
393 expression if it is an aggregate or allocator, because in complex
394 instantiation contexts it may not be expanded */
404 /* Ignore deferred constant definitions without address clause since
405 they are processed fully in the front-end. If No_Initialization
406 is set, this is not a deferred constant but a constant whose value
407 is built manually. And constants that are renamings are handled
408 like variables. */
410 && !gnu_expr
414 {
418 }
420 /* Ignore constant definitions already marked with the error node. See
421 the N_Object_Declaration case of gnat_to_gnu for the rationale. */
423 && gnu_expr
426 {
429 }
434 /* We used to special case VMS exceptions here to directly map them to
435 their associated condition code. Since this code had to be masked
436 dynamically to strip off the severity bits, this caused trouble in
437 the GCC/ZCX case because the "type" pointers we store in the tables
438 have to be static. We now don't special case here anymore, and let
439 the regular processing take place, which leaves us with a regular
440 exception data object for VMS exceptions too. The condition code
441 mapping is taken care of by the front end and the bitmasking by the
442 runtime library. */
447 {
448 /* The GNAT record where the component was defined. */
451 /* If the variable is an inherited record component (in the case of
452 extended record types), just return the inherited entity, which
453 must be a FIELD_DECL. Likewise for discriminants.
454 For discriminants of untagged records which have explicit
455 stored discriminants, return the entity for the corresponding
456 stored discriminant. Also use Original_Record_Component
457 if the record has a private extension. */
461 {
462 gnu_decl
467 }
469 /* If the enclosing record has explicit stored discriminants,
470 then it is an untagged record. If the Corresponding_Discriminant
471 is not empty then this must be a renamed discriminant and its
472 Original_Record_Component must point to the corresponding explicit
473 stored discriminant (i.e., we should have taken the previous
474 branch). */
478 {
479 /* A tagged record has no explicit stored discriminants. */
483 gnu_decl
488 }
492 {
497 }
499 /* If the enclosing record has explicit stored discriminants, then
500 it is an untagged record. If the Corresponding_Discriminant
501 is not empty then this must be a renamed discriminant and its
502 Original_Record_Component must point to the corresponding explicit
503 stored discriminant (i.e., we should have taken the first
504 branch). */
511 /* Otherwise, if we are not defining this and we have no GCC type
512 for the containing record, make one for it. Then we should
513 have made our own equivalent. */
515 {
516 /* ??? If this is in a record whose scope is a protected
517 type and we have an Original_Record_Component, use it.
518 This is a workaround for major problems in protected type
519 handling. */
526 {
527 gnu_decl
533 }
539 }
541 else
542 /* Here we have no GCC type and this is a reference rather than a
543 definition. This should never happen. Most likely the cause is
544 reference before declaration in the gnat tree for gnat_entity. */
546 }
552 /* Simple variables, loop variables, Out parameters, and exceptions. */
553 object:
554 {
556 bool const_flag
569 tree gnu_object_size;
572 {
576 else
578 }
580 /* Get the type after elaborating the renamed object. */
583 /* For a debug renaming declaration, build a pure debug entity. */
585 {
586 rtx addr;
588 /* The (MEM (CONST (0))) pattern is prescribed by STABS. */
591 else
596 }
598 /* If this is a loop variable, its type should be the base type.
599 This is because the code for processing a loop determines whether
600 a normal loop end test can be done by comparing the bounds of the
601 loop against those of the base type, which is presumed to be the
602 size used for computation. But this is not correct when the size
603 of the subtype is smaller than the type. */
607 /* Reject non-renamed objects whose types are unconstrained arrays or
608 any object whose type is a dummy type or VOID_TYPE. */
614 {
617 force_global--;
619 }
621 /* If an alignment is specified, use it if valid. Note that
622 exceptions are objects but don't have alignments. We must do this
623 before we validate the size, since the alignment can affect the
624 size. */
626 {
632 }
634 /* If we are defining the object, see if it has a Size value and
635 validate it if so. If we are not defining the object and a Size
636 clause applies, simply retrieve the value. We don't want to ignore
637 the clause and it is expected to have been validated already. Then
638 get the new type, if any. */
647 {
648 gnu_type
654 }
656 /* If this object has self-referential size, it must be a record with
657 a default value. We are supposed to allocate an object of the
658 maximum size in this case unless it is a constant with an
659 initializing expression, in which case we can get the size from
660 that. Note that the resulting size may still be a variable, so
661 this may end up with an indirect allocation. */
664 {
666 {
669 {
670 /* If the initializing expression is itself a constant,
671 despite having a nominal type with self-referential
672 size, we can get the size directly from it. */
675 == RECORD_TYPE
676 && TYPE_IS_PADDING_P
680 || DECL_READONLY_ONCE_ELAB
683 else
684 gnu_size
686 }
687 else
689 }
690 /* We may have no GNU_EXPR because No_Initialization is
691 set even though there's an Expression. */
696 gnu_size
698 (Etype
700 else
701 {
704 }
705 }
707 /* If the size is zero bytes, make it one byte since some linkers have
708 trouble with zero-sized objects. If the object will have a
709 template, that will make it nonzero so don't bother. Also avoid
710 doing that for an object renaming or an object with an address
711 clause, as we would lose useful information on the view size
712 (e.g. for null array slices) and we are not allocating the object
713 here anyway. */
726 /* If this is an object with no specified size and alignment, and
727 if either it is atomic or we are not optimizing alignment for
728 space and it is composite and not an exception, an Out parameter
729 or a reference to another object, and the size of its type is a
730 constant, set the alignment to the smallest one which is not
731 smaller than the size, with an appropriate cap. */
739 && !imported_p
743 {
744 /* No point in jumping through all the hoops needed in order
745 to support BIGGEST_ALIGNMENT if we don't really have to.
746 So we cap to the smallest alignment that corresponds to
747 a known efficient memory access pattern of the target. */
749 ? BIGGEST_ALIGNMENT
755 else
758 /* But make sure not to under-align the object. */
762 /* And honor the minimum valid atomic alignment, if any. */
763 #ifdef MINIMUM_ATOMIC_ALIGNMENT
766 #endif
767 }
769 /* If the object is set to have atomic components, find the component
770 type and validate it.
772 ??? Note that we ignore Has_Volatile_Components on objects; it's
773 not at all clear what to do in that case. */
776 {
785 }
787 /* Now check if the type of the object allows atomic access. Note
788 that we must test the type, even if this object has size and
789 alignment to allow such access, because we will be going
790 inside the padded record to assign to the object. We could fix
791 this by always copying via an intermediate value, but it's not
792 clear it's worth the effort. */
796 /* If this is an aliased object with an unconstrained nominal subtype,
797 make a type that includes the template. */
801 {
802 tree gnu_fat
805 gnu_type
809 }
811 #ifdef MINIMUM_ATOMIC_ALIGNMENT
812 /* If the size is a constant and no alignment is specified, force
813 the alignment to be the minimum valid atomic alignment. The
814 restriction on constant size avoids problems with variable-size
815 temporaries; if the size is variable, there's no issue with
816 atomic access. Also don't do this for a constant, since it isn't
817 necessary and can interfere with constant replacement. Finally,
818 do not do it for Out parameters since that creates an
819 size inconsistency with In parameters. */
828 #endif
830 /* Make a new type with the desired size and alignment, if needed.
831 But do not take into account alignment promotions to compute the
832 size of the object. */
839 /* If this is a renaming, avoid as much as possible to create a new
840 object. However, in several cases, creating it is required.
841 This processing needs to be applied to the raw expression so
842 as to make it more likely to rename the underlying object. */
844 {
847 /* If the renamed object had padding, strip off the reference
848 to the inner object and reset our type. */
851 == RECORD_TYPE
853 /* Strip useless conversions around the object. */
855 && gnat_types_compatible_p
858 {
861 }
863 /* Case 1: If this is a constant renaming stemming from a function
864 call, treat it as a normal object whose initial value is what
865 is being renamed. RM 3.3 says that the result of evaluating a
866 function call is a constant object. As a consequence, it can
867 be the inner object of a constant renaming. In this case, the
868 renaming must be fully instantiated, i.e. it cannot be a mere
869 reference to (part of) an existing object. */
871 {
877 }
879 /* Otherwise, see if we can proceed with a stabilized version of
880 the renamed entity or if we need to make a new object. */
882 {
886 /* Case 2: If the renaming entity need not be materialized and
887 the renamed expression is something we can stabilize, use
888 that for the renaming. At the global level, we can only do
889 this if we know no SAVE_EXPRs need be made, because the
890 expression we return might be used in arbitrary conditional
891 branches so we must force the SAVE_EXPRs evaluation
892 immediately and this requires a function context. */
897 {
898 maybe_stable_expr
902 {
904 /* ??? No DECL_EXPR is created so we need to mark
905 the expression manually lest it is shared. */
911 }
913 /* The stabilization failed. Keep maybe_stable_expr
914 untouched here to let the pointer case below know
915 about that failure. */
916 }
918 /* Case 3: If this is a constant renaming and creating a
919 new object is allowed and cheap, treat it as a normal
920 object whose initial value is what is being renamed. */
922 ;
924 /* Case 4: Make this into a constant pointer to the object we
925 are to rename and attach the object to the pointer if it is
926 something we can stabilize.
928 From the proper scope, attached objects will be referenced
929 directly instead of indirectly via the pointer to avoid
930 subtle aliasing problems with non-addressable entities.
931 They have to be stable because we must not evaluate the
932 variables in the expression every time the renaming is used.
933 The pointer is called a "renaming" pointer in this case.
935 In the rare cases where we cannot stabilize the renamed
936 object, we just make a "bare" pointer, and the renamed
937 entity is always accessed indirectly through it. */
938 else
939 {
944 /* If the previous attempt at stabilizing failed, there
945 is no point in trying again and we reuse the result
946 without attaching it to the pointer. In this case it
947 will only be used as the initializing expression of
948 the pointer and thus needs no special treatment with
949 regard to multiple evaluations. */
951 ;
953 /* Otherwise, try to stabilize and attach the expression
954 to the pointer if the stabilization succeeds.
956 Note that this might introduce SAVE_EXPRs and we don't
957 check whether we're at the global level or not. This
958 is fine since we are building a pointer initializer and
959 neither the pointer nor the initializing expression can
960 be accessed before the pointer elaboration has taken
961 place in a correct program.
963 These SAVE_EXPRs will be evaluated at the right place
964 by either the evaluation of the initializer for the
965 non-global case or the elaboration code for the global
966 case, and will be attached to the elaboration procedure
967 in the latter case. */
968 else
969 {
970 maybe_stable_expr
976 /* Attaching is actually performed downstream, as soon
977 as we have a VAR_DECL for the pointer we make. */
978 }
980 gnu_expr
985 }
986 }
987 }
989 /* Make a volatile version of this object's type if we are to make
990 the object volatile. We also interpret 13.3(19) conservatively
991 and disallow any optimizations for an object covered by it. */
994 /* Exclude exported constants created by the compiler,
995 which should boil down to static dispatch tables and
996 make it possible to put them in read-only memory. */
1005 /* If we are defining an aliased object whose nominal subtype is
1006 unconstrained, the object is a record that contains both the
1007 template and the object. If there is an initializer, it will
1008 have already been converted to the right type, but we need to
1009 create the template if there is no initializer. */
1011 && !gnu_expr
1014 /* Beware that padding might have been introduced
1015 via maybe_pad_type above. */
1018 == RECORD_TYPE
1019 && TYPE_CONTAINS_TEMPLATE_P
1021 {
1022 tree template_field
1027 gnu_expr
1028 = gnat_build_constructor
1030 tree_cons
1034 NULL_TREE),
1035 NULL_TREE));
1036 }
1038 /* Convert the expression to the type of the object except in the
1039 case where the object's type is unconstrained or the object's type
1040 is a padded record whose field is of self-referential size. In
1041 the former case, converting will generate unnecessary evaluations
1042 of the CONSTRUCTOR to compute the size and in the latter case, we
1043 want to only copy the actual data. */
1049 && (CONTAINS_PLACEHOLDER_P
1053 /* If this is a pointer and it does not have an initializing
1054 expression, initialize it to NULL, unless the object is
1055 imported. */
1061 /* If we are defining the object and it has an Address clause, we must
1062 either get the address expression from the saved GCC tree for the
1063 object if it has a Freeze node, or elaborate the address expression
1064 here since the front-end has guaranteed that the elaboration has no
1065 effects in this case. */
1067 {
1068 tree gnu_address
1075 /* Ignore the size. It's either meaningless or was handled
1076 above. */
1078 /* Convert the type of the object to a reference type that can
1079 alias everything as per 13.3(19). */
1080 gnu_type
1088 /* If this is a deferred constant, the initializer is attached to
1089 the full view. */
1091 gnu_expr
1092 = gnat_to_gnu
1095 /* If we don't have an initializing expression for the underlying
1096 variable, the initializing expression for the pointer is the
1097 specified address. Otherwise, we have to make a COMPOUND_EXPR
1098 to assign both the address and the initial value. */
1101 else
1102 gnu_expr
1104 build_binary_op
1107 gnu_address),
1108 gnu_expr),
1109 gnu_address);
1110 }
1112 /* If it has an address clause and we are not defining it, mark it
1113 as an indirect object. Likewise for Stdcall objects that are
1114 imported. */
1118 {
1119 /* Convert the type of the object to a reference type that can
1120 alias everything as per 13.3(19). */
1121 gnu_type
1125 /* No point in taking the address of an initializing expression
1126 that isn't going to be used. */
1129 /* If it has an address clause whose value is known at compile
1130 time, make the object a CONST_DECL. This will avoid a
1131 useless dereference. */
1133 {
1134 Node_Id gnat_address
1138 {
1141 }
1142 }
1145 }
1147 /* If we are at top level and this object is of variable size,
1148 make the actual type a hidden pointer to the real type and
1149 make the initializer be a memory allocation and initialization.
1150 Likewise for objects we aren't defining (presumed to be
1151 external references from other packages), but there we do
1152 not set up an initialization.
1154 If the object's size overflows, make an allocator too, so that
1155 Storage_Error gets raised. Note that we will never free
1156 such memory, so we presume it never will get allocated. */
1161 || (gnu_size
1165 {
1171 /* In case this was a aliased object whose nominal subtype is
1172 unconstrained, the pointer above will be a thin pointer and
1173 build_allocator will automatically make the template.
1175 If we have a template initializer only (that we made above),
1176 pretend there is none and rely on what build_allocator creates
1177 again anyway. Otherwise (if we have a full initializer), get
1178 the data part and feed that to build_allocator.
1180 If we are elaborating a mutable object, tell build_allocator to
1181 ignore a possibly simpler size from the initializer, if any, as
1182 we must allocate the maximum possible size in this case. */
1185 {
1190 {
1191 gnu_alloc_type
1198 else
1199 gnu_expr
1200 = build_component_ref
1204 }
1210 gnat_entity);
1214 }
1215 else
1216 {
1219 }
1220 }
1222 /* If this object would go into the stack and has an alignment larger
1223 than the largest stack alignment the back-end can honor, resort to
1224 a variable of "aligning type". */
1227 {
1228 /* Create the new variable. No need for extra room before the
1229 aligned field as this is in automatic storage. */
1230 tree gnu_new_type
1234 tree gnu_new_var
1239 /* Initialize the aligned field if we have an initializer. */
1241 add_stmt_with_node
1243 build_component_ref
1246 gnu_expr),
1247 gnat_entity);
1249 /* And setup this entity as a reference to the aligned field. */
1251 gnu_expr
1252 = build_unary_op
1260 }
1266 /* Convert the expression to the type of the object except in the
1267 case where the object's type is unconstrained or the object's type
1268 is a padded record whose field is of self-referential size. In
1269 the former case, converting will generate unnecessary evaluations
1270 of the CONSTRUCTOR to compute the size and in the latter case, we
1271 want to only copy the actual data. */
1277 && (CONTAINS_PLACEHOLDER_P
1281 /* If this name is external or there was a name specified, use it,
1282 unless this is a VMS exception object since this would conflict
1283 with the symbol we need to export in addition. Don't use the
1284 Interface_Name if there is an address clause (see CD30005). */
1293 /* If this is constant initialized to a static constant and the
1294 object has an aggregate type, force it to be statically
1295 allocated. This will avoid an initialization copy. */
1314 {
1317 {
1320 }
1321 }
1333 gnat_entity);
1335 /* If we are defining an Out parameter and we're not optimizing,
1336 create a fake PARM_DECL for debugging purposes and make it
1337 point to the VAR_DECL. Suppress debug info for the latter
1338 but make sure it will still live on the stack so it can be
1339 accessed from within the debugger through the PARM_DECL. */
1341 {
1348 else
1351 }
1353 /* If this is a public constant or we're not optimizing and we're not
1354 making a VAR_DECL for it, make one just for export or debugger use.
1355 Likewise if the address is taken or if either the object or type is
1356 aliased. Make an external declaration for a reference, unless this
1357 is a Standard entity since there no real symbol at the object level
1358 for these. */
1363 || !optimize
1367 {
1368 tree gnu_corr_var
1372 gnat_entity);
1376 /* As debugging information will be generated for the variable,
1377 do not generate information for the constant. */
1379 }
1381 /* If this is declared in a block that contains a block with an
1382 exception handler, we must force this variable in memory to
1383 suppress an invalid optimization. */
1390 /* Back-annotate Alignment and Esize of the object if not already
1391 known, except for when the object is actually a pointer to the
1392 real object, since alignment and size of a pointer don't have
1393 anything to do with those of the designated object. Note that
1394 we pick the values of the type, not those of the object, to
1395 shield ourselves from low-level platform-dependent adjustments
1396 like alignment promotion. This is both consistent with all the
1397 treatment above, where alignment and size are set on the type of
1398 the object and not on the object directly, and makes it possible
1399 to support confirming representation clauses in all cases. */
1406 {
1409 gnu_object_size
1413 }
1414 }
1418 /* Return a TYPE_DECL for "void" that we previously made. */
1423 /* A special case, for the types Character and Wide_Character in
1424 Standard, we do not list all the literals. So if the literals
1425 are not specified, make this an unsigned type. */
1427 {
1431 /* Set TYPE_STRING_FLAG for Ada Character and Wide_Character types.
1432 This is needed by the DWARF-2 back-end to distinguish between
1433 unsigned integer types and character types. */
1436 }
1438 /* Normal case of non-character type, or non-Standard character type */
1439 {
1440 /* Here we have a list of enumeral constants in First_Literal.
1441 We make a CONST_DECL for each and build into GNU_LITERAL_LIST
1442 the list to be places into TYPE_FIELDS. Each node in the list
1443 is a TREE_LIST node whose TREE_VALUE is the literal name
1444 and whose TREE_PURPOSE is the value of the literal.
1446 Esize contains the number of bits needed to represent the enumeral
1447 type, Type_Low_Bound also points to the first literal and
1448 Type_High_Bound points to the last literal. */
1450 Entity_Id gnat_literal;
1455 else
1463 {
1465 gnu_type);
1466 tree gnu_literal
1474 }
1478 /* Note that the bounds are updated at the end of this function
1479 because to avoid an infinite recursion when we get the bounds of
1480 this type, since those bounds are objects of this type. */
1481 }
1487 /* For integer types, just make a signed type the appropriate number
1488 of bits. */
1493 /* For modular types, make the unsigned type of the proper number of
1494 bits and then set up the modulus, if required. */
1495 {
1497 tree gnu_modulus;
1503 /* Find the smallest mode at least ESIZE bits wide and make a class
1504 using that mode. */
1509 ;
1516 /* Get the modulus in this type. If it overflows, assume it is because
1517 it is equal to 2**Esize. Note that there is no overflow checking
1518 done on unsigned type, so we detect the overflow by looking for
1519 a modulus of zero, which is otherwise invalid. */
1523 {
1528 }
1530 /* If we have to set TYPE_PRECISION different from its natural value,
1531 make a subtype to do do. Likewise if there is a modulus and
1532 it is not one greater than TYPE_MAX_VALUE. */
1536 {
1554 }
1555 }
1564 /* For integral subtypes, we make a new INTEGER_TYPE. Note
1565 that we do not want to call build_range_type since we would
1566 like each subtype node to be distinct. This will be important
1567 when memory aliasing is implemented.
1569 The TREE_TYPE field of the INTEGER_TYPE we make points to the
1570 parent type; this fact is used by the arithmetic conversion
1571 functions.
1573 We elaborate the Ancestor_Subtype if it is not in the current
1574 unit and one of our bounds is non-static. We do this to ensure
1575 consistent naming in the case where several subtypes share the same
1576 bounds by always elaborating the first such subtype first, thus
1577 using its name. */
1590 /* Set the precision to the Esize except for bit-packed arrays and
1591 subtypes of Standard.Boolean. */
1594 {
1597 }
1606 gnat_entity,
1613 gnat_entity,
1617 /* One of the above calls might have caused us to be elaborated,
1618 so don't blow up if so. */
1620 {
1623 }
1628 /* This should be an unsigned type if the lower bound is constant
1629 and non-negative or if the base type is unsigned; a signed type
1630 otherwise. */
1640 /* Inherit our alias set from what we're a subtype of. Subtypes
1641 are not different types and a pointer can designate any instance
1642 within a subtype hierarchy. */
1645 /* If the type we are dealing with is to represent a packed array,
1646 we need to have the bits left justified on big-endian targets
1647 and right justified on little-endian targets. We also need to
1648 ensure that when the value is read (e.g. for comparison of two
1649 such values), we only get the good bits, since the unused bits
1650 are uninitialized. Both goals are accomplished by wrapping the
1651 modular value in an enclosing struct. */
1654 {
1656 tree gnu_field;
1663 /* Propagate the alignment of the modular type to the record.
1664 This means that bitpacked arrays have "ceil" alignment for
1665 their size, which may seem counter-intuitive but makes it
1666 possible to easily overlay them on modular types. */
1670 /* Create a stripped-down declaration of the original type, mainly
1671 for debugging. */
1675 /* Don't notify the field as "addressable", since we won't be taking
1676 it's address and it would prevent create_field_decl from making a
1677 bitfield. */
1686 }
1688 /* If the type we are dealing with has got a smaller alignment than the
1689 natural one, we need to wrap it up in a record type and under-align
1690 the latter. We reuse the padding machinery for this purpose. */
1695 {
1697 tree gnu_field;
1705 /* Create a stripped-down declaration of the original type, mainly
1706 for debugging. */
1710 /* Don't notify the field as "addressable", since we won't be taking
1711 it's address and it would prevent create_field_decl from making a
1712 bitfield. */
1721 }
1723 /* Otherwise reset the alignment lest we computed it above. */
1724 else
1730 /* If this is a VAX floating-point type, use an integer of the proper
1731 size. All the operations will be handled with ASM statements. */
1733 {
1738 sizetype));
1740 }
1742 /* The type of the Low and High bounds can be our type if this is
1743 a type from Standard, so set them at the end of the function. */
1751 {
1754 }
1756 {
1783 /* One of the above calls might have caused us to be elaborated,
1784 so don't blow up if so. */
1786 {
1789 }
1793 /* Inherit our alias set from what we're a subtype of, as for
1794 integer subtypes. */
1796 }
1799 /* Array and String Types and Subtypes
1801 Unconstrained array types are represented by E_Array_Type and
1802 constrained array types are represented by E_Array_Subtype. There
1803 are no actual objects of an unconstrained array type; all we have
1804 are pointers to that type.
1806 The following fields are defined on array types and subtypes:
1808 Component_Type Component type of the array.
1809 Number_Dimensions Number of dimensions (an int).
1810 First_Index Type of first index. */
1814 {
1820 int firstdim
1822 int nextdim
1829 tree gnu_max_size_unit;
1830 Entity_Id gnat_ind_subtype;
1831 Entity_Id gnat_ind_base_subtype;
1832 tree gnu_template_reference;
1833 tree tem;
1838 /* Make a node for the array. If we are not defining the array
1839 suppress expanding incomplete types. */
1845 /* Build the fat pointer type. Use a "void *" object instead of
1846 a pointer to the array type since we don't have the array type
1847 yet (it will reference the fat pointer via the bounds). */
1850 ptr_void_type_node,
1853 gnu_ptr_template,
1856 /* Make sure we can put this into a register. */
1859 /* Do not finalize this record type since the types of its fields
1860 are still incomplete at this point. */
1864 /* Build a reference to the template from a PLACEHOLDER_EXPR that
1865 is the fat pointer. This will be used to access the individual
1866 fields once we build them. */
1870 gnu_template_reference
1874 /* Now create the GCC type for each index and add the fields for
1875 that index to the template. */
1877 gnat_ind_base_subtype
1883 {
1885 tree gnu_ind_subtype
1887 tree gnu_base_subtype
1889 tree gnu_base_min
1891 tree gnu_base_max
1895 /* Make the FIELD_DECLs for the minimum and maximum of this
1896 type and then make extractions of that field from the
1897 template. */
1900 gnu_ind_subtype,
1904 gnu_ind_subtype,
1913 /* We can't use build_component_ref here since the template
1914 type isn't complete yet. */
1917 NULL_TREE);
1920 NULL_TREE);
1923 /* Make a range type with the new ranges, but using
1924 the Ada subtype. Then we convert to sizetype. */
1930 gnat_entity);
1931 /* Update the maximum size of the array, in elements. */
1932 gnu_max_size
1936 gnu_base_min)));
1940 }
1943 gnu_template_fields
1946 /* Install all the fields into the template. */
1950 /* Now make the array of arrays and update the pointer to the array
1951 in the fat pointer. Note that it is the first field. */
1954 /* Try to get a smaller form of the component if needed. */
1968 /* Get and validate any specified Component_Size, but if Packed,
1969 ignore it since the front end will have taken care of it. */
1970 gnu_comp_size
1972 gnat_entity,
1977 /* If the component type is a RECORD_TYPE that has a self-referential
1978 size, use the maximum size. */
1984 {
1985 tree orig_tem;
1990 /* If a padding record was made, declare it now since it will
1991 never be declared otherwise. This is necessary to ensure
1992 that its subtrees are properly marked. */
1996 }
2002 /* If Component_Size is not already specified, annotate it with the
2003 size of the component. */
2013 gnu_max_size),
2017 {
2022 }
2024 /* If an alignment is specified, use it if valid. But ignore it for
2025 types that represent the unpacked base type for packed arrays. If
2026 the alignment was requested with an explicit user alignment clause,
2027 state so. */
2030 {
2037 }
2043 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
2044 corresponding fat pointer. */
2051 /* If the maximum size doesn't overflow, use it. */
2066 /* Give the fat pointer type a name. */
2071 /* Create the type to be used as what a thin pointer designates: an
2072 record type for the object and its template with the field offsets
2073 shifted to have the template at a negative offset. */
2081 /* Give the thin pointer type a name. */
2085 gnat_entity);
2086 }
2092 /* This is the actual data type for array variables. Multidimensional
2093 arrays are implemented in the gnu tree as arrays of arrays. Note
2094 that for the moment arrays which have sparse enumeration subtypes as
2095 index components create sparse arrays, which is obviously space
2096 inefficient but so much easier to code for now.
2098 Also note that the subtype never refers to the unconstrained
2099 array type, which is somewhat at variance with Ada semantics.
2101 First check to see if this is simply a renaming of the array
2102 type. If so, the result is the array type. */
2107 else
2108 {
2111 int first_dim
2114 int next_dim
2116 Entity_Id gnat_ind_subtype;
2117 Entity_Id gnat_ind_base_subtype;
2122 tree gnu_max_size_unit;
2126 /* First create the gnu types for each index. Create types for
2127 debugging information to point to the index types if the
2128 are not integer types, have variable bounds, or are
2129 wider than sizetype. */
2132 gnat_ind_base_subtype
2138 {
2139 tree gnu_index_subtype
2141 tree gnu_min
2143 tree gnu_max
2145 tree gnu_base_subtype
2147 tree gnu_base_min
2149 tree gnu_base_max
2152 tree gnu_base_base_min
2154 tree gnu_base_base_max
2156 tree gnu_high;
2157 tree gnu_this_max;
2159 /* If the minimum and maximum values both overflow in
2160 SIZETYPE, but the difference in the original type
2161 does not overflow in SIZETYPE, ignore the overflow
2162 indications. */
2170 && (!TREE_OVERFLOW
2174 {
2177 }
2179 /* Similarly, if the range is null, use bounds of 1..0 for
2180 the sizetype bounds. */
2192 /* Now compute the size of this bound. We need to provide
2193 GCC with an upper bound to use but have to deal with the
2194 "superflat" case. There are three ways to do this. If we
2195 can prove that the array can never be superflat, we can
2196 just use the high bound of the index subtype. If we can
2197 prove that the low bound minus one can't overflow, we
2198 can do this as MAX (hb, lb - 1). Otherwise, we have to use
2199 the expression hb >= lb ? hb : lb - 1. */
2202 /* See if the base array type is already flat. If it is, we
2203 are probably compiling an ACVC test, but it will cause the
2204 code below to malfunction if we don't handle it specially. */
2212 /* If gnu_high is now an integer which overflowed, the array
2213 cannot be superflat. */
2220 else
2221 gnu_high
2222 = build_cond_expr
2229 gnat_entity);
2231 /* Also compute the maximum size of the array. Here we
2232 see if any constraint on the index type of the base type
2233 can be used in the case of self-referential bound on
2234 the index type of the subtype. We look for a non-"infinite"
2235 and non-self-referential bound from any type involved and
2236 handle each bound separately. */
2265 gnu_this_max
2269 gnu_base_min)),
2270 size_zero_node);
2276 gnu_max_size
2290 }
2292 /* Then flatten: create the array of arrays. For an array type
2293 used to implement a packed array, get the component type from
2294 the original array type since the representation clauses that
2295 can affect it are on the latter. */
2298 {
2303 /* One of the above calls might have caused us to be elaborated,
2304 so don't blow up if so. */
2306 {
2309 }
2310 }
2311 else
2312 {
2315 /* One of the above calls might have caused us to be elaborated,
2316 so don't blow up if so. */
2318 {
2321 }
2323 /* Try to get a smaller form of the component if needed. */
2334 /* Get and validate any specified Component_Size, but if Packed,
2335 ignore it since the front end will have taken care of it. */
2336 gnu_comp_size
2338 gnat_entity,
2343 /* If the component type is a RECORD_TYPE that has a
2344 self-referential size, use the maximum size. */
2351 {
2352 tree orig_gnu_type;
2353 gnu_type
2359 /* If a padding record was made, declare it now since it
2360 will never be declared otherwise. This is necessary
2361 to ensure that its subtrees are properly marked. */
2365 }
2371 }
2380 {
2385 }
2387 /* If we are at file level and this is a multi-dimensional array, we
2388 need to make a variable corresponding to the stride of the
2389 inner dimensions. */
2391 {
2393 tree gnu_arr_type;
2399 {
2407 /* ??? For now, store the size as a multiple of the
2408 alignment of the element type in bytes so that we
2409 can see the alignment from the tree. */
2411 = build_binary_op
2413 elaborate_expression_1
2423 /* ??? create_type_decl is not invoked on the inner types so
2424 the MULT_EXPR node built above will never be marked. */
2426 }
2427 }
2429 /* If we need to write out a record type giving the names of
2430 the bounds, do it now. */
2432 {
2435 tree gnu_field;
2441 {
2442 tree gnu_type_name
2449 integer_type_node,
2450 gnu_bound_rec_type,
2454 }
2462 add_parallel_type
2464 }
2472 /* If our size depends on a placeholder and the maximum size doesn't
2473 overflow, use it. */
2480 {
2486 }
2488 /* Set our alias set to that of our base type. This gives all
2489 array subtypes the same alias set. */
2491 }
2493 /* If this is a packed type, make this type the same as the packed
2494 array type, but do some adjusting in the type first. */
2497 {
2498 Entity_Id gnat_index;
2499 tree gnu_inner_type;
2501 /* First finish the type we had been making so that we output
2502 debugging information for it */
2503 gnu_type
2506 | (TYPE_QUAL_VOLATILE
2514 /* Save it as our equivalent in case the call below elaborates
2515 this type again. */
2530 /* We need to point the type we just made to our index type so
2531 the actual bounds can be put into a template. */
2537 {
2539 {
2540 /* The TYPE_ACTUAL_BOUNDS field is also used for the modulus.
2541 If it is, we need to make another type. */
2543 {
2544 tree gnu_subtype;
2561 }
2564 }
2570 SET_TYPE_ACTUAL_BOUNDS
2577 SET_TYPE_ACTUAL_BOUNDS
2584 }
2585 }
2587 /* Abort if packed array with no packed array type field set. */
2588 else
2594 /* Create the type for a string literal. */
2595 {
2596 Entity_Id gnat_full_type
2601 tree gnu_string_array_type
2603 tree gnu_string_index_type
2606 tree gnu_lower_bound
2611 tree gnu_upper_bound
2613 gnu_lower_bound,
2615 tree gnu_range_type
2618 tree gnu_index_type
2625 gnu_type
2627 gnu_index_type);
2631 }
2634 /* Record Types and Subtypes
2636 The following fields are defined on record types:
2638 Has_Discriminants True if the record has discriminants
2639 First_Discriminant Points to head of list of discriminants
2640 First_Entity Points to head of list of fields
2641 Is_Tagged_Type True if the record is tagged
2643 Implementation of Ada records and discriminated records:
2645 A record type definition is transformed into the equivalent of a C
2646 struct definition. The fields that are the discriminants which are
2647 found in the Full_Type_Declaration node and the elements of the
2648 Component_List found in the Record_Type_Definition node. The
2649 Component_List can be a recursive structure since each Variant of
2650 the Variant_Part of the Component_List has a Component_List.
2652 Processing of a record type definition comprises starting the list of
2653 field declarations here from the discriminants and the calling the
2654 function components_to_record to add the rest of the fields from the
2655 component list and return the gnu type node. The function
2656 components_to_record will call itself recursively as it traverses
2657 the tree. */
2661 {
2662 gnu_type
2663 = build_complex_type
2664 (get_unpadded_type
2667 (Component_List
2668 (Type_Definition
2672 }
2674 {
2677 Entity_Id gnat_field;
2678 tree gnu_field;
2680 tree gnu_get_parent;
2681 /* Set PACKED in keeping with gnat_to_gnu_field. */
2682 int packed
2694 bool is_extension
2698 /* See if all fields have a rep clause. Stop when we find one
2699 that doesn't. */
2708 /* If this is a record extension, go a level further to find the
2709 record definition. Also, verify we have a Parent_Subtype. */
2711 {
2718 }
2720 /* Make a node for the record. If we are not defining the record,
2721 suppress expanding incomplete types. */
2729 /* If both a size and rep clause was specified, put the size in
2730 the record type now so that it can get the proper mode. */
2734 /* Always set the alignment here so that it can be used to
2735 set the mode, if it is making the alignment stricter. If
2736 it is invalid, it will be checked again below. If this is to
2737 be Atomic, choose a default alignment of a word unless we know
2738 the size and it's smaller. */
2745 /* If a type needs strict alignment, the minimum size will be the
2746 type size instead of the RM size (see validate_size). Cap the
2747 alignment, lest it causes this type size to become too large. */
2750 {
2755 }
2756 else
2759 /* If we have a Parent_Subtype, make a field for the parent. If
2760 this record has rep clauses, force the position to zero. */
2762 {
2764 tree gnu_parent;
2766 /* A major complexity here is that the parent subtype will
2767 reference our discriminants in its Discriminant_Constraint
2768 list. But those must reference the parent component of this
2769 record which is of the parent subtype we have not built yet!
2770 To break the circle we first build a dummy COMPONENT_REF which
2771 represents the "get to the parent" operation and initialize
2772 each of those discriminants to a COMPONENT_REF of the above
2773 dummy parent referencing the corresponding discriminant of the
2774 base type of the parent subtype. */
2778 void_type_node),
2779 NULL_TREE);
2786 save_gnu_tree
2790 gnu_get_parent,
2793 NULL_TREE),
2796 /* Then we build the parent subtype. */
2799 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
2800 initially built. The discriminants must reference the fields
2801 of the parent subtype and not those of its base type for the
2802 placeholder machinery to properly work. */
2808 {
2818 }
2820 /* The "get to the parent" COMPONENT_REF must be given its
2821 proper type... */
2824 /* ...and reference the _parent field of this record. */
2825 gnu_field_list
2833 }
2835 /* Make the fields for the discriminants and put them into the record
2836 unless it's an Unchecked_Union. */
2841 {
2842 /* If this is a record extension and this discriminant
2843 is the renaming of another discriminant, we've already
2844 handled the discriminant above. */
2849 gnu_field
2852 /* Make an expression using a PLACEHOLDER_EXPR from the
2853 FIELD_DECL node just created and link that with the
2854 corresponding GNAT defining identifier. Then add to the
2855 list of fields. */
2864 {
2867 }
2868 }
2870 /* Put the discriminants into the record (backwards), so we can
2871 know the appropriate discriminant to use for the names of the
2872 variants. */
2875 /* Add the listed fields into the record and finish it up. */
2881 /* We used to remove the associations of the discriminants and
2882 _Parent for validity checking, but we may need them if there's
2883 Freeze_Node for a subtype used in this record. */
2887 /* If it is a tagged record force the type to BLKmode to insure
2888 that these objects will always be placed in memory. Do the
2889 same thing for limited record types. */
2893 /* Fill in locations of fields. */
2896 /* If there are any entities in the chain corresponding to
2897 components that we did not elaborate, ensure we elaborate their
2898 types if they are Itypes. */
2906 }
2910 /* If an equivalent type is present, that is what we should use.
2911 Otherwise, fall through to handle this like a record subtype
2912 since it may have constraints. */
2914 {
2918 }
2920 /* ... fall through ... */
2924 /* If Cloned_Subtype is Present it means this record subtype has
2925 identical layout to that type or subtype and we should use
2926 that GCC type for this one. The front end guarantees that
2927 the component list is shared. */
2929 {
2933 }
2935 /* Otherwise, first ensure the base type is elaborated. Then, if we are
2936 changing the type, make a new type with each field having the
2937 type of the field in the new subtype but having the position
2938 computed by transforming every discriminant reference according
2939 to the constraints. We don't see any difference between
2940 private and nonprivate type here since derivations from types should
2941 have been deferred until the completion of the private type. */
2942 else
2943 {
2945 tree gnu_base_type;
2946 tree gnu_orig_type;
2951 /* Get the base type initially for its alignment and sizes. But
2952 if it is a padded type, we do all the other work with the
2953 unpadded type. */
2959 else
2963 {
2966 }
2968 /* When the type has discriminants, and these discriminants
2969 affect the shape of what it built, factor them in.
2971 If we are making a subtype of an Unchecked_Union (must be an
2972 Itype), just return the type.
2974 We can't just use Is_Constrained because private subtypes without
2975 discriminants of full types with discriminants with default
2976 expressions are Is_Constrained but aren't constrained! */
2984 {
2985 Entity_Id gnat_field;
2987 tree gnu_pos_list
2990 BIGGEST_ALIGNMENT);
2991 tree gnu_subst_list
2993 definition);
2994 tree gnu_temp;
3000 /* Set the size, alignment and alias set of the new type to
3001 match that of the old one, doing required substitutions.
3002 We do it this early because we need the size of the new
3003 type below to discard old fields if necessary. */
3029 SET_TYPE_ADA_SIZE
3043 {
3044 tree gnu_old_field
3047 tree gnu_offset
3049 gnu_pos_list));
3052 tree gnu_field_type
3056 unsigned int offset_align
3059 tree gnu_field;
3061 /* If there was a component clause, the field types must be
3062 the same for the type and subtype, so copy the data from
3063 the old field to avoid recomputation here. Also if the
3064 field is justified modular and the optimization in
3065 gnat_to_gnu_field was applied. */
3072 {
3075 }
3077 /* If the old field was packed and of constant size, we
3078 have to get the old size here, as it might differ from
3079 what the Etype conveys and the latter might overlap
3080 onto the following field. Try to arrange the type for
3081 possible better packing along the way. */
3085 {
3090 gnu_field_type
3092 }
3101 /* If the position is now a constant, we can set it as the
3102 position of the field when we make it. Otherwise, we need
3103 to deal with it specially below. */
3105 {
3108 /* Discard old fields that are outside the new type.
3109 This avoids confusing code scanning it to decide
3110 how to pass it to functions on some platforms. */
3117 }
3119 gnu_field
3120 = create_field_decl
3126 {
3135 bitsize_unit_node));
3137 }
3141 SET_DECL_ORIGINAL_FIELD
3150 /* To match the layout crafted in components_to_record, if
3151 this is the _Tag field, put it before any discriminants
3152 instead of after them as for all other fields. */
3155 else
3156 {
3159 }
3162 }
3164 /* Now go through the entities again looking for Itypes that
3165 we have not elaborated but should (e.g., Etypes of fields
3166 that have Original_Components). */
3174 /* Do not finalize it since we're going to modify it below. */
3178 /* Finalize size and mode. */
3185 /* Fill in locations of fields. */
3188 /* We've built a new type, make an XVS type to show what this
3189 is a subtype of. Some debuggers require the XVS type to be
3190 output first, so do it in that order. */
3192 {
3203 integer_type_node,
3204 gnu_subtype_marker,
3210 gnu_subtype_marker);
3211 }
3213 /* Now we can finalize it. */
3215 }
3217 /* Otherwise, go down all the components in the new type and
3218 make them equivalent to those in the base type. */
3219 else
3226 gnat_to_gnu_field_decl
3228 }
3232 /* Use the special descriptor type for dispatch tables if needed,
3233 that is to say for the Prim_Ptr of a-tags.ads and its clones.
3234 Note that we are only required to do so for static tables in
3235 order to be compatible with the C++ ABI, but Ada 2005 allows
3236 to extend library level tagged types at the local level so
3237 we do it in the non-static case as well. */
3240 {
3244 }
3246 /* ... fall through ... */
3249 /* If we are not defining this entity, and we have incomplete
3250 entities being processed above us, make a dummy type and
3251 fill it in later. */
3253 {
3257 gnu_type
3258 = build_pointer_type
3273 }
3275 /* ... fall through ... */
3282 {
3285 bool is_from_limited_with
3289 /* Get the "full view" of this entity. If this is an incomplete
3290 entity from a limited with, treat its non-limited view as the full
3291 view. Otherwise, if this is an incomplete or private type, use the
3292 full view. In the former case, we might point to a private type,
3293 in which case, we need its full view. Also, we want to look at the
3294 actual type used for the representation, so this takes a total of
3295 three steps. */
3296 Entity_Id gnat_desig_full_direct_first
3300 Entity_Id gnat_desig_full_direct
3301 = ((is_from_limited_with
3306 Entity_Id gnat_desig_full
3309 /* This the type actually used to represent the designated type,
3310 either gnat_desig_full or gnat_desig_equiv. */
3311 Entity_Id gnat_desig_rep;
3313 /* Nonzero if this is a pointer to an unconstrained array. */
3316 /* We want to know if we'll be seeing the freeze node for any
3317 incomplete type we may be pointing to. */
3318 bool in_main_unit
3323 /* Nonzero if we make a dummy type here. */
3325 /* Nonzero if the dummy is a fat pointer. */
3333 /* If either the designated type or its full view is an unconstrained
3334 array subtype, replace it with the type it's a subtype of. This
3335 avoids problems with multiple copies of unconstrained array types.
3336 Likewise, if the designated type is a subtype of an incomplete
3337 record type, use the parent type to avoid order of elaboration
3338 issues. This can lose some code efficiency, but there is no
3339 alternative. */
3350 /* Now set the type that actually marks the representation of
3351 the designated type and also flag whether we have a unconstrained
3352 array. */
3354 is_unconstrained_array
3358 /* If we are pointing to an incomplete type whose completion is an
3359 unconstrained array, make a fat pointer type. The two types in our
3360 fields will be pointers to dummy nodes and will be replaced in
3361 update_pointer_to. Similarly, if the type itself is a dummy type or
3362 an unconstrained array. Also make a dummy TYPE_OBJECT_RECORD_TYPE
3363 in case we have any thin pointers to it. */
3374 {
3375 tree gnu_old
3379 tree fields;
3381 /* Show the dummy we get will be a fat pointer. */
3384 /* If the call above got something that has a pointer, that
3385 pointer is our type. This could have happened either
3386 because the type was elaborated or because somebody
3387 else executed the code below. */
3390 {
3411 fields
3413 create_field_decl
3415 gnu_ptr_array,
3418 gnu_ptr_template,
3421 /* Make sure we can place this into a register. */
3426 /* Do not finalize this record type since the types of
3427 its fields are incomplete. */
3435 }
3436 }
3438 /* If we already know what the full type is, use it. */
3443 /* Get the type of the thing we are to point to and build a pointer
3444 to it. If it is a reference to an incomplete or private type with a
3445 full view that is a record, make a dummy type node and get the
3446 actual type later when we have verified it is safe. */
3452 /* Likewise if we are pointing to a record or array and we
3453 are to defer elaborating incomplete types. We do this
3454 since this access type may be the full view of some
3455 private type. Note that the unconstrained array case is
3456 handled above. */
3462 /* If this is a reference from a limited_with type back to our
3463 main unit and there's a Freeze_Node for it, either we have
3464 already processed the declaration and made the dummy type,
3465 in which case we just reuse the latter, or we have not yet,
3466 in which case we make the dummy type and it will be reused
3467 when the declaration is processed. In both cases, the
3468 pointer eventually created below will be automatically
3469 adjusted when the Freeze_Node is processed. Note that the
3470 unconstrained array case is handled above. */
3473 {
3476 }
3478 /* Otherwise handle the case of a pointer to itself. */
3480 {
3481 gnu_type
3485 }
3487 /* If expansion is disabled, the equivalent type of a concurrent
3488 type is absent, so build a dummy pointer type. */
3492 /* Finally, handle the straightforward case where we can just
3493 elaborate our designated type and point to it. */
3494 else
3497 /* It is possible that a call to gnat_to_gnu_type above resolved our
3498 type. If so, just return it. */
3500 {
3503 }
3505 /* If we have a GCC type for the designated type, possibly modify it
3506 if we are pointing only to constant objects and then make a pointer
3507 to it. Don't do this for unconstrained arrays. */
3509 {
3512 {
3513 gnu_desig_type
3514 = build_qualified_type
3518 /* Some extra processing is required if we are building a
3519 pointer to an incomplete type (in the GCC sense). We might
3520 have such a type if we just made a dummy, or directly out
3521 of the call to gnat_to_gnu_type above if we are processing
3522 an access type for a record component designating the
3523 record type itself. */
3525 {
3526 /* We must ensure that the pointer to variant we make will
3527 be processed by update_pointer_to when the initial type
3528 is completed. Pretend we made a dummy and let further
3529 processing act as usual. */
3532 /* We must ensure that update_pointer_to will not retrieve
3533 the dummy variant when building a properly qualified
3534 version of the complete type. We take advantage of the
3535 fact that get_qualified_type is requiring TYPE_NAMEs to
3536 match to influence build_qualified_type and then also
3537 update_pointer_to here. */
3540 }
3541 }
3543 gnu_type
3546 }
3548 /* If we are not defining this object and we made a dummy pointer,
3549 save our current definition, evaluate the actual type, and replace
3550 the tentative type we made with the actual one. If we are to defer
3551 actually looking up the actual type, make an entry in the
3552 deferred list. If this is from a limited with, we have to defer
3553 to the end of the current spec in two cases: first if the
3554 designated type is in the current unit and second if the access
3555 type is. */
3557 {
3558 tree gnu_old_type
3564 gnu_type
3565 = build_pointer_type
3566 (TYPE_OBJECT_RECORD_TYPE
3578 && ! (is_from_limited_with
3579 && (in_main_unit
3584 /* Note that the call to gnat_to_gnu_type here might have
3585 updated gnu_old_type directly, in which case it is not a
3586 dummy type any more when we get into update_pointer_to.
3588 This may happen for instance when the designated type is a
3589 record type, because their elaboration starts with an
3590 initial node from make_dummy_type, which may yield the same
3591 node as the one we got.
3593 Besides, variants of this non-dummy type might have been
3594 created along the way. update_pointer_to is expected to
3595 properly take care of those situations. */
3596 else
3597 {
3602 = (is_from_limited_with
3603 && (in_main_unit
3611 }
3612 }
3613 }
3620 else
3621 {
3622 /* The runtime representation is the equivalent type. */
3625 }
3638 /* We treat this as identical to its base type; any constraint is
3639 meaningful only to the front end.
3641 The designated type must be elaborated as well, if it does
3642 not have its own freeze node. Designated (sub)types created
3643 for constrained components of records with discriminants are
3644 not frozen by the front end and thus not elaborated by gigi,
3645 because their use may appear before the base type is frozen,
3646 and because it is not clear that they are needed anywhere in
3647 Gigi. With the current model, there is no correct place where
3648 they could be elaborated. */
3655 {
3656 /* If we are not defining this entity, and we have incomplete
3657 entities being processed above us, make a dummy type and
3658 elaborate it later. */
3660 {
3663 tree gnu_ptr_type
3664 = build_pointer_type
3671 }
3674 Incomplete_Or_Private_Kind))
3677 }
3682 /* Subprogram Entities
3684 The following access functions are defined for subprograms (functions
3685 or procedures):
3687 First_Formal The first formal parameter.
3688 Is_Imported Indicates that the subprogram has appeared in
3689 an INTERFACE or IMPORT pragma. For now we
3690 assume that the external language is C.
3691 Is_Exported Likewise but for an EXPORT pragma.
3692 Is_Inlined True if the subprogram is to be inlined.
3694 In addition for function subprograms we have:
3696 Etype Return type of the function.
3698 Each parameter is first checked by calling must_pass_by_ref on its
3699 type to determine if it is passed by reference. For parameters which
3700 are copied in, if they are Ada In Out or Out parameters, their return
3701 value becomes part of a record which becomes the return type of the
3702 function (C function - note that this applies only to Ada procedures
3703 so there is no Ada return type). Additional code to store back the
3704 parameters will be generated on the caller side. This transformation
3705 is done here, not in the front-end.
3707 The intended result of the transformation can be seen from the
3708 equivalent source rewritings that follow:
3710 struct temp {int a,b};
3711 procedure P (A,B: In Out ...) is temp P (int A,B)
3712 begin {
3713 .. ..
3714 end P; return {A,B};
3715 }
3717 temp t;
3718 P(X,Y); t = P(X,Y);
3719 X = t.a , Y = t.b;
3721 For subprogram types we need to perform mainly the same conversions to
3722 GCC form that are needed for procedures and function declarations. The
3723 only difference is that at the end, we make a type declaration instead
3724 of a function declaration. */
3729 {
3730 /* The first GCC parameter declaration (a PARM_DECL node). The
3731 PARM_DECL nodes are chained through the TREE_CHAIN field, so this
3732 actually is the head of this parameter list. */
3734 /* Likewise for the stub associated with an exported procedure. */
3736 /* The type returned by a function. If the subprogram is a procedure
3737 this type should be void_type_node. */
3739 /* List of fields in return type of procedure with copy-in copy-out
3740 parameters. */
3742 /* Non-null for subprograms containing parameters passed by copy-in
3743 copy-out (Ada In Out or Out parameters not passed by reference),
3744 in which case it is the list of nodes used to specify the values of
3745 the in out/out parameters that are returned as a record upon
3746 procedure return. The TREE_PURPOSE of an element of this list is
3747 a field of the record and the TREE_VALUE is the PARM_DECL
3748 corresponding to that field. This list will be saved in the
3749 TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
3751 /* If an import pragma asks to map this subprogram to a GCC builtin,
3752 this is the builtin DECL node. */
3754 /* For the stub associated with an exported procedure. */
3757 Entity_Id gnat_param;
3760 bool extern_flag
3763 /* The semantics of "pure" in Ada essentially matches that of "const"
3764 in the back-end. In particular, both properties are orthogonal to
3765 the "nothrow" property if the EH circuitry is explicit in the
3766 internal representation of the back-end. If we are to completely
3767 hide the EH circuitry from it, we need to declare that calls to pure
3768 Ada subprograms that can throw have side effects since they can
3769 trigger an "abnormal" transfer of control flow; thus they can be
3770 neither "const" nor "pure" in the back-end sense. */
3771 bool const_flag
3784 /* A parameter may refer to this type, so defer completion
3785 of any incomplete types. */
3788 /* If the subprogram has an alias, it is probably inherited, so
3789 we can use the original one. If the original "subprogram"
3790 is actually an enumeration literal, it may be the first use
3791 of its type, so we must elaborate that type now. */
3793 {
3800 /* Elaborate any Itypes in the parameters of this entity. */
3808 }
3810 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
3811 corresponding DECL node.
3813 We still want the parameter associations to take place because the
3814 proper generation of calls depends on it (a GNAT parameter without
3815 a corresponding GCC tree has a very specific meaning), so we don't
3816 just break here. */
3820 /* ??? What if we don't find the builtin node above ? warn ? err ?
3821 In the current state we neither warn nor err, and calls will just
3822 be handled as for regular subprograms. */
3827 /* If this function returns by reference, make the actual
3828 return type of this function the pointer and mark the decl. */
3830 {
3833 }
3835 /* If the Mechanism is By_Reference, ensure the return type uses
3836 the machine's by-reference mechanism, which may not the same
3837 as above (e.g., it might be by passing a fake parameter). */
3840 {
3843 /* We expect this bit to be reset by gigi shortly, so can avoid a
3844 type node copy here. This actually also prevents troubles with
3845 the generation of debug information for the function, because
3846 we might have issued such info for this type already, and would
3847 be attaching a distinct type node to the function if we made a
3848 copy here. */
3849 }
3851 /* If we are supposed to return an unconstrained array,
3852 actually return a fat pointer and make a note of that. Return
3853 a pointer to an unconstrained record of variable size. */
3855 {
3858 }
3860 /* If the type requires a transient scope, the result is allocated
3861 on the secondary stack, so the result type of the function is
3862 just a pointer. */
3864 {
3867 }
3869 /* If the type is a padded type and the underlying type would not
3870 be passed by reference or this function has a foreign convention,
3871 return the underlying type. */
3879 /* If the return type has a non-constant size, we convert the function
3880 into a procedure and its caller will pass a pointer to an object as
3881 the first parameter when we call the function. This can happen for
3882 an unconstrained type with a maximum size or a constrained type with
3883 a size not known at compile time. */
3886 {
3888 gnu_param_list
3893 }
3895 /* If the return type has a size that overflows, we cannot have
3896 a function that returns that type. This usage doesn't make
3897 sense anyway, so give an error here. */
3901 {
3903 gnat_entity);
3909 }
3911 /* Look at all our parameters and get the type of
3912 each. While doing this, build a copy-out structure if
3913 we need one. */
3915 /* Loop over the parameters and get their associated GCC tree.
3916 While doing this, build a copy-out structure if we need one. */
3920 {
3927 /* Builtins are expanded inline and there is no real call sequence
3928 involved. So the type expected by the underlying expander is
3929 always the type of each argument "as is". */
3932 /* Handle the first parameter of a valued procedure specially. */
3935 /* Otherwise, see if a Mechanism was supplied that forced this
3936 parameter to be passed one way or another. */
3939 ;
3948 {
3952 mech))
3954 else
3956 }
3957 else
3958 {
3961 }
3963 gnu_param
3968 /* We are returned either a PARM_DECL or a type if no parameter
3969 needs to be passed; in either case, adjust the type. */
3972 else
3973 {
3976 }
3979 {
3980 /* If it's an exported subprogram, we build a parameter list
3981 in parallel, in case we need to emit a stub for it. */
3983 {
3984 gnu_stub_param_list
3986 /* Change By_Descriptor parameter to By_Reference for
3987 the internal version of an exported subprogram. */
3989 {
3990 gnu_param
3995 }
3996 else
3998 }
4005 /* If a parameter is a pointer, this function may modify
4006 memory through it and thus shouldn't be considered
4007 a const function. Also, the memory may be modified
4008 between two calls, so they can't be CSE'ed. The latter
4009 case also handles by-ref parameters. */
4013 }
4016 {
4018 {
4023 }
4032 gnu_return_list);
4033 }
4034 }
4036 /* Do not compute record for out parameters if subprogram is
4037 stubbed since structures are incomplete for the back-end. */
4042 /* If we have a CICO list but it has only one entry, we convert
4043 this function into a function that simply returns that one
4044 object. */
4049 prepend_one_attribute_to
4052 gnat_entity);
4054 /* If we are on a target where stack realignment is needed for 'main'
4055 to honor GCC's implicit expectations (stack alignment greater than
4056 what the base ABI guarantees), ensure we do the same for foreign
4057 convention subprograms as they might be used as callbacks from code
4058 breaking such expectations. Note that this applies to task entry
4059 points in particular. */
4062 prepend_one_attribute_to
4065 gnat_entity);
4067 /* The lists have been built in reverse. */
4077 gnu_type
4083 gnu_stub_type
4088 /* A subprogram (something that doesn't return anything) shouldn't
4089 be considered const since there would be no reason for such a
4090 subprogram. Note that procedures with Out (or In Out) parameters
4091 have already been converted into a function with a return type. */
4095 gnu_type
4104 gnu_stub_type
4110 /* If we have a builtin decl for that function, check the signatures
4111 compatibilities. If the signatures are compatible, use the builtin
4112 decl. If they are not, we expect the checker predicate to have
4113 posted the appropriate errors, and just continue with what we have
4114 so far. */
4116 {
4120 {
4124 }
4125 }
4127 /* If there was no specified Interface_Name and the external and
4128 internal names of the subprogram are the same, only use the
4129 internal name to allow disambiguation of nested subprograms. */
4133 /* If we are defining the subprogram and it has an Address clause
4134 we must get the address expression from the saved GCC tree for the
4135 subprogram if it has a Freeze_Node. Otherwise, we elaborate
4136 the address expression here since the front-end has guaranteed
4137 in that case that the elaboration has no effects. If there is
4138 an Address clause and we are not defining the object, just
4139 make it a constant. */
4141 {
4145 gnu_address
4152 /* Convert the type of the object to a reference type that can
4153 alias everything as per 13.3(19). */
4154 gnu_type
4159 gnu_decl
4164 }
4170 else
4171 {
4173 {
4177 }
4183 gnat_entity);
4185 {
4186 tree gnu_stub_decl
4191 gnat_entity);
4193 }
4195 /* This is unrelated to the stub built right above. */
4198 }
4199 }
4210 {
4211 /* Get the "full view" of this entity. If this is an incomplete
4212 entity from a limited with, treat its non-limited view as the
4213 full view. Otherwise, use either the full view or the underlying
4214 full view, whichever is present. This is used in all the tests
4215 below. */
4216 Entity_Id full_view
4224 /* If this is an incomplete type with no full view, it must be a Taft
4225 Amendment type, in which case we return a dummy type. Otherwise,
4226 just get the type from its Etype. */
4228 {
4231 else
4232 {
4236 }
4238 }
4240 /* If we already made a type for the full view, reuse it. */
4242 {
4245 }
4247 /* Otherwise, if we are not defining the type now, get the type
4248 from the full view. But always get the type from the full view
4249 for define on use types, since otherwise we won't see them! */
4255 {
4259 }
4261 /* For incomplete types, make a dummy type entry which will be
4262 replaced later. */
4265 /* Save this type as the full declaration's type so we can do any
4266 needed updates when we see it. */
4272 }
4274 /* Simple class_wide types are always viewed as their root_type
4275 by Gigi unless an Equivalent_Type is specified. */
4287 else
4299 /* Nothing at all to do here, so just return an ERROR_MARK and claim
4300 we've already saved it, so we don't try to. */
4307 }
4309 /* If we had a case where we evaluated another type and it might have
4310 defined this one, handle it here. */
4312 {
4315 }
4317 /* If we are processing a type and there is either no decl for it or
4318 we just made one, do some common processing for the type, such as
4319 handling alignment and possible padding. */
4322 {
4330 /* ??? Don't set the size for a String_Literal since it is either
4331 confirming or we don't handle it properly (if the low bound is
4332 non-constant). */
4338 /* If a size was specified, see if we can make a new type of that size
4339 by rearranging the type, for example from a fat to a thin pointer. */
4341 {
4342 gnu_type
4349 }
4351 /* If the alignment hasn't already been processed and this is
4352 not an unconstrained array, see if an alignment is specified.
4353 If not, we pick a default alignment for atomic objects. */
4355 ;
4357 {
4361 /* Warn on suspiciously large alignments. This should catch
4362 errors about the (alignment,byte)/(size,bit) discrepancy. */
4364 {
4365 tree size;
4367 /* If a size was specified, take it into account. Otherwise
4368 use the RM size for records as the type size has already
4369 been adjusted to the alignment. */
4377 else
4380 /* Consider an alignment as suspicious if the alignment/size
4381 ratio is greater or equal to the byte/bit ratio. */
4386 gnat_entity);
4387 }
4388 }
4399 /* See if we need to pad the type. If we did, and made a record,
4400 the name of the new type may be changed. So get it back for
4401 us when we make the new TYPE_DECL below. */
4408 {
4412 }
4416 /* If we are at global level, GCC will have applied variable_size to
4417 the type, but that won't have done anything. So, if it's not
4418 a constant or self-referential, call elaborate_expression_1 to
4419 make a variable for the size rather than calculating it each time.
4420 Handle both the RM size and the actual size. */
4425 {
4429 {
4436 }
4437 else
4438 {
4445 /* ??? For now, store the size as a multiple of the alignment
4446 in bytes so that we can see the alignment from the tree. */
4448 = build_binary_op
4450 elaborate_expression_1
4461 SET_TYPE_ADA_SIZE
4464 gnat_entity,
4468 }
4469 }
4471 /* If this is a record type or subtype, call elaborate_expression_1 on
4472 any field position. Do this for both global and local types.
4473 Skip any fields that we haven't made trees for to avoid problems with
4474 class wide types. */
4479 {
4482 /* ??? Unfortunately, GCC needs to be able to prove the
4483 alignment of this offset and if it's a variable, it can't.
4484 In GCC 3.4, we'll use DECL_OFFSET_ALIGN in some way, but
4485 right now, we have to put in an explicit multiply and
4486 divide by that value. */
4488 {
4490 = build_binary_op
4492 elaborate_expression_1
4502 /* ??? The context of gnu_field is not necessarily gnu_type so
4503 the MULT_EXPR node built above may not be marked by the call
4504 to create_type_decl below. */
4507 }
4508 }
4512 | (TYPE_QUAL_VOLATILE
4528 else
4530 }
4533 {
4536 /* If this is a derived type, relate its alias set to that of its parent
4537 to avoid troubles when a call to an inherited primitive is inlined in
4538 a context where a derived object is accessed. The inlined code works
4539 on the parent view so the resulting code may access the same object
4540 using both the parent and the derived alias sets, which thus have to
4541 conflict. As the same issue arises with component references, the
4542 parent alias set also has to conflict with composite types enclosing
4543 derived components. For instance, if we have:
4545 type D is new T;
4546 type R is record
4547 Component : D;
4548 end record;
4550 we want T to conflict with both D and R, in addition to R being a
4551 superset of D by record/component construction.
4553 One way to achieve this is to perform an alias set copy from the
4554 parent to the derived type. This is not quite appropriate, though,
4555 as we don't want separate derived types to conflict with each other:
4557 type I1 is new Integer;
4558 type I2 is new Integer;
4560 We want I1 and I2 to both conflict with Integer but we do not want
4561 I1 to conflict with I2, and an alias set copy on derivation would
4562 have that effect.
4564 The option chosen is to make the alias set of the derived type a
4565 superset of that of its parent type. It trivially fulfills the
4566 simple requirement for the Integer derivation example above, and
4567 the component case as well by superset transitivity:
4569 superset superset
4570 R ----------> D ----------> T
4572 The language rules ensure the parent type is already frozen here. */
4574 {
4577 }
4579 /* Back-annotate the Alignment of the type if not already in the
4580 tree. Likewise for sizes. */
4586 {
4587 /* If the size is self-referential, we annotate the maximum
4588 value of that size. */
4597 {
4598 /* In this mode the tag and the parent components are not
4599 generated by the front-end, so the sizes must be adjusted
4600 explicitly now. */
4604 {
4605 size_offset
4609 }
4610 else
4618 }
4619 }
4623 }
4633 /* If we haven't already, associate the ..._DECL node that we just made with
4634 the input GNAT entity node. */
4638 /* If this is an enumeral or floating-point type, we were not able to set
4639 the bounds since they refer to the type. These bounds are always static.
4641 For enumeration types, also write debugging information and declare the
4642 enumeration literal table, if needed. */
4646 {
4649 /* If this is a padded type, we need to use the underlying type. */
4654 /* If this is a floating point type and we haven't set a floating
4655 point type yet, use this in the evaluation of the bounds. */
4665 {
4666 /* Since this has both a typedef and a tag, avoid outputting
4667 the name twice. */
4670 }
4671 }
4673 /* If we deferred processing of incomplete types, re-enable it. If there
4674 were no other disables and we have some to process, do so. */
4676 {
4678 {
4681 /* We are back to level 0 for the deferring of incomplete types.
4682 But processing these incomplete types below may itself require
4683 deferring, so preserve what we have and restart from scratch. */
4687 /* For finalization, however, all types must be complete so we
4688 cannot do the same because deferred incomplete types may end up
4689 referencing each other. Process them all recursively first. */
4690 defer_finalize_level++;
4693 {
4700 }
4702 defer_finalize_level--;
4703 }
4705 /* All the deferred incomplete types have been processed so we can
4706 now proceed with the finalization of the deferred types. */
4708 {
4710 tree t;
4716 }
4717 }
4719 /* If we are not defining this type, see if it's in the incomplete list.
4720 If so, handle that list entry now. */
4722 {
4727 {
4731 }
4732 }
4735 force_global--;
4744 }
4746 /* Similar, but if the returned value is a COMPONENT_REF, return the
4747 FIELD_DECL. */
4749 tree
4751 {
4758 }
4760 /* Wrap up compilation of DECL, a TYPE_DECL, possibly deferring it.
4761 Every TYPE_DECL generated for a type definition must be passed
4762 to this function once everything else has been done for it. */
4764 void
4766 {
4767 /* We need to defer finalizing the type if incomplete types
4768 are being deferred or if they are being processed. */
4771 else
4773 }
4775 /* Same as above but without deferring the compilation. This
4776 function should not be invoked directly on a TYPE_DECL. */
4778 static void
4780 {
4786 /* Now process all the variants. This is needed for STABS. */
4788 {
4793 {
4796 }
4799 }
4800 }
4802 /* Finalize any From_With_Type incomplete types. We do this after processing
4803 our compilation unit and after processing its spec, if this is a body. */
4805 void
4807 {
4813 {
4820 }
4821 }
4823 /* Return the equivalent type to be used for GNAT_ENTITY, if it's a
4824 kind of type (such E_Task_Type) that has a different type which Gigi
4825 uses for its representation. If the type does not have a special type
4826 for its representation, return GNAT_ENTITY. If a type is supposed to
4827 exist, but does not, abort unless annotating types, in which case
4828 return Empty. If GNAT_ENTITY is Empty, return Empty. */
4830 Entity_Id
4832 {
4839 {
4865 }
4869 }
4871 /* Return a GCC tree for a parameter corresponding to GNAT_PARAM and
4872 using MECH as its passing mechanism, to be placed in the parameter
4873 list built for GNAT_SUBPROG. Assume a foreign convention for the
4874 latter if FOREIGN is true. Also set CICO to true if the parameter
4875 must use the copy-in copy-out implementation mechanism.
4877 The returned tree is a PARM_DECL, except for those cases where no
4878 parameter needs to be actually passed to the subprogram; the type
4879 of this "shadow" parameter is then returned instead. */
4881 static tree
4884 {
4889 /* The parameter can be indirectly modified if its address is taken. */
4892 tree gnu_param;
4894 /* Copy-return is used only for the first parameter of a valued procedure.
4895 It's a copy mechanism for which a parameter is never allocated. */
4897 {
4901 }
4903 /* If this is either a foreign function or if the underlying type won't
4904 be passed by reference, strip off possible padding type. */
4907 {
4911 || foreign
4915 }
4917 /* If this is a read-only parameter, make a variant of the type that is
4918 read-only. ??? However, if this is an unconstrained array, that type
4919 can be very complex, so skip it for now. Likewise for any other
4920 self-referential type. */
4928 /* For foreign conventions, pass arrays as pointers to the element type.
4929 First check for unconstrained array and get the underlying array. */
4931 gnu_param_type
4934 /* VMS descriptors are themselves passed by reference. */
4937 gnu_param_type
4940 gnat_subprog));
4942 {
4943 /* Build both a 32-bit and 64-bit descriptor, one of which will be
4944 chosen in fill_vms_descriptor. */
4945 gnu_param_type_alt
4948 gnat_subprog));
4949 gnu_param_type
4952 gnat_subprog));
4953 }
4955 /* Arrays are passed as pointers to element type for foreign conventions. */
4959 {
4960 /* Strip off any multi-dimensional entries, then strip
4961 off the last array to get the component type. */
4975 }
4977 /* Fat pointers are passed as thin pointers for foreign conventions. */
4979 gnu_param_type
4982 /* If we must pass or were requested to pass by reference, do so.
4983 If we were requested to pass by copy, do so.
4984 Otherwise, for foreign conventions, pass In Out or Out parameters
4985 or aggregates by reference. For COBOL and Fortran, pass all
4986 integer and FP types that way too. For Convention Ada, use
4987 the standard Ada default. */
4991 && ((foreign
4993 || (foreign
4998 || (!foreign
5000 {
5003 }
5005 /* Pass In Out or Out parameters using copy-in copy-out mechanism. */
5012 /* If this is an Out parameter that isn't passed by reference and isn't
5013 a pointer or aggregate, we don't make a PARM_DECL for it. Instead,
5014 it will be a VAR_DECL created when we process the procedure, so just
5015 return its type. For the special parameter of a valued procedure,
5016 never pass it in.
5018 An exception is made to cover the RM-6.4.1 rule requiring "by copy"
5019 Out parameters with discriminants or implicit initial values to be
5020 handled like In Out parameters. These type are normally built as
5021 aggregates, hence passed by reference, except for some packed arrays
5022 which end up encoded in special integer types.
5024 The exception we need to make is then for packed arrays of records
5025 with discriminants or implicit initial values. We have no light/easy
5026 way to check for the latter case, so we merely check for packed arrays
5027 of records. This may lead to useless copy-in operations, but in very
5028 rare cases only, as these would be exceptions in a set of already
5029 exceptional situations. */
5031 && !by_ref
5032 && (by_return
5051 /* Save the alternate descriptor type, if any. */
5055 /* If no Mechanism was specified, indicate what we're using, then
5056 back-annotate it. */
5062 }
5064 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
5066 static bool
5068 {
5075 return
5077 }
5079 /* Return true if the array type specified by GNAT_TYPE and GNU_TYPE has
5080 a non-aliased component in the back-end sense. */
5082 static bool
5084 {
5085 /* If the type below this is a multi-array type, then
5086 this does not have aliased components. */
5095 }
5096 \f
5097 /* Given GNAT_ENTITY, elaborate all expressions that are required to
5098 be elaborated at the point of its definition, but do nothing else. */
5100 void
5102 {
5104 {
5111 {
5115 /* ??? Tests for avoiding static constraint error expression
5116 is needed until the front stops generating bogus conversions
5117 on bounds of real types. */
5126 }
5129 {
5133 /* If this is a record extension, go a level further to find the
5134 record definition. */
5137 }
5147 {
5148 Node_Id gnat_discriminant_expr;
5149 Entity_Id gnat_field;
5152 gnat_discriminant_expr
5157 /* ??? For now, ignore access discriminants. */
5160 gnat_entity,
5162 }
5165 }
5166 }
5167 \f
5168 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
5169 any entities on its entity chain similarly. */
5171 void
5173 {
5174 Entity_Id gnat_sub_entity;
5177 /* If this has an entity list, process all in the list. */
5194 /* Now clear this if it has been defined, but only do so if it isn't
5195 a subprogram or parameter. We could refine this, but it isn't
5196 worth it. If this is statically allocated, it is supposed to
5197 hang around out of cope. */
5200 {
5203 }
5204 }
5205 \f
5206 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
5207 If this is a multi-dimensional array type, do this recursively.
5209 OP may be
5210 - ALIAS_SET_COPY: the new set is made a copy of the old one.
5211 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
5212 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
5214 static void
5216 {
5217 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
5218 of a one-dimensional array, since the padding has the same alias set
5219 as the field type, but if it's a multi-dimensional array, we need to
5220 see the inner types. */
5226 /* Unconstrained array types are deemed incomplete and would thus be given
5227 alias set 0. Retrieve the underlying array type. */
5229 gnu_old_type
5232 gnu_new_type
5241 {
5243 /* The alias set shouldn't be copied between array types with different
5244 aliasing settings because this can break the aliasing relationship
5245 between the array type and its element type. */
5246 #ifndef ENABLE_CHECKING
5248 #endif
5259 {
5263 /* Do nothing if the alias sets conflict. This ensures that we
5264 never call record_alias_subset several times for the same pair
5265 or at all for alias set 0. */
5267 {
5270 else
5272 }
5273 }
5278 }
5281 }
5282 \f
5283 /* Return a TREE_LIST describing the substitutions needed to reflect
5284 discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
5285 them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
5286 of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
5287 gives the tree for the discriminant and TREE_VALUES is the replacement
5288 value. They are in the form of operands to substitute_in_expr.
5289 DEFINITION is as in gnat_to_gnu_entity. */
5291 static tree
5294 {
5295 Entity_Id gnat_discrim;
5296 Node_Id gnat_value;
5307 /* Ignore access discriminants. */
5310 elaborate_expression
5314 gnu_list);
5317 }
5318 \f
5319 /* Return true if the size represented by GNU_SIZE can be handled by an
5320 allocation. If STATIC_P is true, consider only what can be done with a
5321 static allocation. */
5323 static bool
5325 {
5326 HOST_WIDE_INT our_size;
5328 /* If this is not a static allocation, the only case we want to forbid
5329 is an overflowing size. That will be converted into a raise a
5330 Storage_Error. */
5335 /* Otherwise, we need to deal with both variable sizes and constant
5336 sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
5337 since assemblers may not like very large sizes. */
5343 }
5344 \f
5345 /* Prepend to ATTR_LIST an entry for an attribute with provided TYPE,
5346 NAME, ARGS and ERROR_POINT. */
5348 static void
5351 tree attr_name,
5352 tree attr_args,
5353 Node_Id attr_error_point)
5354 {
5364 }
5366 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
5368 static void
5370 {
5371 Node_Id gnat_temp;
5376 {
5385 {
5387 (gnat_to_gnu
5394 (gnat_to_gnu
5395 (Expression
5398 }
5401 {
5428 }
5431 /* Prepend to the list now. Make a list of the argument we might
5432 have, as GCC expects it. */
5433 prepend_one_attribute_to
5440 }
5441 }
5442 \f
5443 /* Get the unpadded version of a GNAT type. */
5445 tree
5447 {
5454 }
5455 \f
5456 /* Called when we need to protect a variable object using a save_expr. */
5458 tree
5460 {
5467 {
5475 }
5476 else
5478 }
5479 \f
5480 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
5481 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
5482 return the GCC tree to use for that expression. GNU_NAME is the
5483 qualification to use if an external name is appropriate and DEFINITION is
5484 nonzero if this is a definition of GNAT_ENTITY. If NEED_VALUE is nonzero,
5485 we need a result. Otherwise, we are just elaborating this for
5486 side-effects. If NEED_DEBUG is nonzero we need the symbol for debugging
5487 purposes even if it isn't needed for code generation. */
5489 static tree
5493 {
5494 tree gnu_expr;
5496 /* If we already elaborated this expression (e.g., it was involved
5497 in the definition of a private type), use the old value. */
5501 /* If we don't need a value and this is static or a discriminant, we
5502 don't need to do anything. */
5509 /* Otherwise, convert this tree to its GCC equivalent. */
5510 gnu_expr
5514 /* Save the expression in case we try to elaborate this entity again. Since
5515 it's not a DECL, don't check it. Don't save if it's a discriminant. */
5520 }
5522 /* Similar, but take a GNU expression. */
5524 static tree
5528 {
5530 /* Skip any conversions and simple arithmetics to see if the expression
5531 is a read-only variable.
5532 ??? This really should remain read-only, but we have to think about
5533 the typing of the tree here. */
5534 tree gnu_inner_expr
5539 /* In most cases, we won't see a naked FIELD_DECL here because a
5540 discriminant reference will have been replaced with a COMPONENT_REF
5541 when the type is being elaborated. However, there are some cases
5542 involving child types where we will. So convert it to a COMPONENT_REF
5543 here. We have to hope it will be at the highest level of the
5544 expression in these cases. */
5550 /* If GNU_EXPR is neither a placeholder nor a constant, nor a variable
5551 that is read-only, make a variable that is initialized to contain the
5552 bound when the package containing the definition is elaborated. If
5553 this entity is defined at top level and a bound or discriminant value
5554 isn't a constant or a reference to a discriminant, replace the bound
5555 by the variable; otherwise use a SAVE_EXPR if needed. Note that we
5556 rely here on the fact that an expression cannot contain both the
5557 discriminant and some other variable. */
5565 /* If this is a static expression or contains a discriminant, we don't
5566 need the variable for debugging (and can't elaborate anyway if a
5567 discriminant). */
5573 /* Now create the variable if we need it. */
5575 gnu_decl
5582 /* We only need to use this variable if we are in global context since GCC
5583 can do the right thing in the local case. */
5588 else
5590 }
5591 \f
5592 /* Create a record type that contains a SIZE bytes long field of TYPE with a
5593 starting bit position so that it is aligned to ALIGN bits, and leaving at
5594 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
5595 record is guaranteed to get. */
5597 tree
5600 {
5601 /* We will be crafting a record type with one field at a position set to be
5602 the next multiple of ALIGN past record'address + room bytes. We use a
5603 record placeholder to express record'address. */
5608 tree record_addr_st
5611 /* The diagram below summarizes the shape of what we manipulate:
5613 <--------- pos ---------->
5614 { +------------+-------------+-----------------+
5615 record =>{ |############| ... | field (type) |
5616 { +------------+-------------+-----------------+
5617 |<-- room -->|<- voffset ->|<---- size ----->|
5618 o o
5619 | |
5620 record_addr vblock_addr
5622 Every length is in sizetype bytes there, except "pos" which has to be
5623 set as a bit position in the GCC tree for the record. */
5636 /* Compute VOFFSET and then POS. The next byte position multiple of some
5637 alignment after some address is obtained by "and"ing the alignment minus
5638 1 with the two's complement of the address. */
5644 /* POS = (ROOM + VOFFSET) * BIT_PER_UNIT, in bitsizetype. */
5649 bitsize_unit_node);
5651 /* Craft the GCC record representation. We exceptionally do everything
5652 manually here because 1) our generic circuitry is not quite ready to
5653 handle the complex position/size expressions we are setting up, 2) we
5654 have a strong simplifying factor at hand: we know the maximum possible
5655 value of voffset, and 3) we have to set/reset at least the sizes in
5656 accordance with this maximum value anyway, as we need them to convey
5657 what should be "alloc"ated for this type.
5659 Use -1 as the 'addressable' indication for the field to prevent the
5660 creation of a bitfield. We don't need one, it would have damaging
5661 consequences on the alignment computation, and create_field_decl would
5662 make one without this special argument, for instance because of the
5663 complex position expression. */
5675 bitsize_unit_node),
5685 }
5686 \f
5687 /* Return the result of rounding T up to ALIGN. */
5691 {
5696 }
5698 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
5699 as the field type of a packed record if IN_RECORD is true, or as the
5700 component type of a packed array if IN_RECORD is false. See if we can
5701 rewrite it either as a type that has a non-BLKmode, which we can pack
5702 tighter in the packed record case, or as a smaller type. If so, return
5703 the new type. If not, return the original type. */
5705 static tree
5707 {
5712 /* No point in doing anything if the size is zero. */
5718 /* Copy the name and flags from the old type to that of the new.
5719 Note that we rely on the pointer equality created here for
5720 TYPE_NAME to look through conversions in various places. */
5727 /* If we are in a record and have a small size, set the alignment to
5728 try for an integral mode. Otherwise set it to try for a smaller
5729 type with BLKmode. */
5731 {
5734 }
5735 else
5736 {
5739 /* Do not try to shrink the size if the RM size is not constant. */
5744 /* Round the RM size up to a unit boundary to get the minimal size
5745 for a BLKmode record. Give up if it's already the size. */
5753 }
5757 /* Now copy the fields, keeping the position and size as we don't want
5758 to change the layout by propagating the packedness downwards. */
5761 {
5772 /* However, for the last field in a not already packed record type
5773 that is of an aggregate type, we need to use the RM_Size in the
5774 packable version of the record type, see finish_record_type. */
5784 else
5793 SET_DECL_ORIGINAL_FIELD
5802 }
5807 /* If this is a padding record, we never want to make the size smaller
5808 than what was specified. For QUAL_UNION_TYPE, also copy the size. */
5811 {
5814 }
5815 else
5816 {
5820 }
5827 /* Try harder to get a packable type if necessary, for example
5828 in case the record itself contains a BLKmode field. */
5833 /* If neither the mode nor the size has shrunk, return the old type. */
5838 }
5839 \f
5840 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
5841 if needed. We have already verified that SIZE and TYPE are large enough.
5843 GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
5844 to issue a warning.
5846 IS_USER_TYPE is true if we must complete the original type.
5848 DEFINITION is true if this type is being defined.
5850 SAME_RM_SIZE is true if the RM_Size of the resulting type is to be set
5851 to SIZE too; otherwise, it's set to the RM_Size of the original type. */
5853 tree
5857 {
5863 /* If TYPE is a padded type, see if it agrees with any size and alignment
5864 we were given. If so, return the original type. Otherwise, strip
5865 off the padding, since we will either be returning the inner type
5866 or repadding it. If no size or alignment is specified, use that of
5867 the original padded type. */
5869 {
5886 }
5888 /* If the size is either not being changed or is being made smaller (which
5889 is not done here (and is only valid for bitfields anyway), show the size
5890 isn't changing. Likewise, clear the alignment if it isn't being
5891 changed. Then return if we aren't doing anything. */
5904 /* If requested, complete the original type and give it a name. */
5911 gnat_entity);
5913 /* We used to modify the record in place in some cases, but that could
5914 generate incorrect debugging information. So make a new record
5915 type and name. */
5933 bitsize_unit_node));
5935 /* If we are changing the alignment and the input type is a record with
5936 BLKmode and a small constant size, try to make a form that has an
5937 integral mode. This might allow the padding record to also have an
5938 integral mode, which will be much more efficient. There is no point
5939 in doing so if a size is specified unless it is also a small constant
5940 size and it is incorrect to do so if we cannot guarantee that the mode
5941 will be naturally aligned since the field must always be addressable.
5943 ??? This might not always be a win when done for a stand-alone object:
5944 since the nominal and the effective type of the object will now have
5945 different modes, a VIEW_CONVERT_EXPR will be required for converting
5946 between them and it might be hard to overcome afterwards, including
5947 at the RTL level when the stand-alone object is accessed as a whole. */
5954 && (!size
5957 {
5962 }
5964 /* Now create the field with the original size. */
5969 /* Do not finalize it until after the auxiliary record is built. */
5972 /* Set the same size for its RM_size if requested; otherwise reuse
5973 the RM_size of the original type. */
5976 /* Unless debugging information isn't being written for the input type,
5977 write a record that shows what we are a subtype of and also make a
5978 variable that indicates our size, if still variable. */
5984 {
6008 }
6012 /* If the size was widened explicitly, maybe give a warning. Take the
6013 original size as the maximum size of the input if there was an
6014 unconstrained record involved and round it up to the specified alignment,
6015 if one was specified. */
6027 {
6040 /* Generate message only for entities that come from source, since
6041 if we have an entity created by expansion, the message will be
6042 generated for some other corresponding source entity. */
6045 gnat_entity,
6052 }
6055 }
6056 \f
6057 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
6058 the value passed against the list of choices. */
6060 tree
6062 {
6063 Node_Id choice;
6064 Node_Id gnat_temp;
6069 {
6071 {
6076 /* There's no good type to use here, so we might as well use
6077 integer_type_node. */
6078 this_test
6092 this_test
6102 /* This represents either a subtype range, an enumeration
6103 literal, or a constant Ekind says which. If an enumeration
6104 literal or constant, fall through to the next case. */
6107 {
6113 this_test
6120 }
6122 /* ... fall through ... */
6128 single);
6137 }
6141 }
6144 }
6145 \f
6146 /* Adjust PACKED setting as passed to gnat_to_gnu_field for a field of
6147 type FIELD_TYPE to be placed in RECORD_TYPE. Return the result. */
6149 static int
6151 {
6152 /* If the field contains an item of variable size, we cannot pack it
6153 because we cannot create temporaries of non-fixed size in case
6154 we need to take the address of the field. See addressable_p and
6155 the notes on the addressability issues for further details. */
6159 /* If the alignment of the record is specified and the field type
6160 is over-aligned, request Storage_Unit alignment for the field. */
6162 {
6165 else
6167 }
6170 }
6172 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
6173 placed in GNU_RECORD_TYPE.
6175 PACKED is 1 if the enclosing record is packed, -1 if the enclosing
6176 record has Component_Alignment of Storage_Unit, -2 if the enclosing
6177 record has a specified alignment.
6179 DEFINITION is true if this field is for a record being defined. */
6181 static tree
6184 {
6188 bool needs_strict_alignment
6192 /* If this field requires strict alignment, we cannot pack it because
6193 it would very likely be under-aligned in the record. */
6196 else
6199 /* If a size is specified, use it. Otherwise, if the record type is packed,
6200 use the official RM size. See "Handling of Type'Size Values" in Einfo
6201 for further details. */
6208 else
6211 /* If we have a specified size that's smaller than that of the field type,
6212 or a position is specified, and the field type is a record, see if we can
6213 get either an integral mode form of the type or a smaller form. If we
6214 can, show a size was specified for the field if there wasn't one already,
6215 so we know to make this a bitfield and avoid making things wider.
6217 Doing this is first useful if the record is packed because we may then
6218 place the field at a non-byte-aligned position and so achieve tighter
6219 packing.
6221 This is in addition *required* if the field shares a byte with another
6222 field and the front-end lets the back-end handle the references, because
6223 GCC does not handle BLKmode bitfields properly.
6225 We avoid the transformation if it is not required or potentially useful,
6226 as it might entail an increase of the field's alignment and have ripple
6227 effects on the outer record type. A typical case is a field known to be
6228 byte aligned and not to share a byte with another field.
6230 Besides, we don't even look the possibility of a transformation in cases
6231 known to be in error already, for instance when an invalid size results
6232 from a component clause. */
6238 || (gnu_size
6241 {
6242 /* See what the alternate type and size would be. */
6245 bool has_byte_aligned_clause
6250 /* Compute whether we should avoid the substitution. */
6251 bool reject
6252 /* There is no point substituting if there is no change... */
6254 /* ... nor when the field is known to be byte aligned and not to
6255 share a byte with another field. */
6256 || (has_byte_aligned_clause
6258 /* The size of an aliased field must be an exact multiple of the
6259 type's alignment, which the substitution might increase. Reject
6260 substitutions that would so invalidate a component clause when the
6261 specified position is byte aligned, as the change would have no
6262 real benefit from the packing standpoint anyway. */
6264 && has_byte_aligned_clause
6267 /* Substitute unless told otherwise. */
6269 {
6274 }
6275 }
6277 /* If we are packing the record and the field is BLKmode, round the
6278 size up to a byte boundary. */
6283 {
6288 /* Ensure the position does not overlap with the parent subtype,
6289 if there is one. */
6291 {
6292 tree gnu_parent
6298 {
6299 post_error_ne_tree
6303 }
6304 }
6306 /* If this field needs strict alignment, ensure the record is
6307 sufficiently aligned and that that position and size are
6308 consistent with the alignment. */
6310 {
6316 {
6318 post_error_ne_tree
6324 post_error_ne_tree
6330 post_error_ne_tree
6336 }
6341 {
6343 post_error_ne_num
6349 post_error_ne_num
6355 post_error_ne_num
6360 else
6364 }
6365 }
6369 }
6371 /* If the record has rep clauses and this is the tag field, make a rep
6372 clause for it as well. */
6375 {
6378 }
6380 else
6383 /* We need to make the size the maximum for the type if it is
6384 self-referential and an unconstrained type. In that case, we can't
6385 pack the field since we can't make a copy to align it. */
6387 && !gnu_size
6390 {
6393 }
6395 /* If a size is specified, adjust the field's type to it. */
6397 {
6398 /* If the field's type is justified modular, we would need to remove
6399 the wrapper to (better) meet the layout requirements. However we
6400 can do so only if the field is not aliased to preserve the unique
6401 layout and if the prescribed size is not greater than that of the
6402 packed array to preserve the justification. */
6410 gnu_field_type
6415 }
6417 /* Otherwise (or if there was an error), don't specify a position. */
6418 else
6424 /* Now create the decl for the field. */
6436 }
6437 \f
6438 /* Return true if TYPE is a type with variable size, a padding type with a
6439 field of variable size or is a record that has a field such a field. */
6441 static bool
6443 {
6444 tree field;
6464 }
6465 \f
6466 /* qsort comparer for the bit positions of two record components. */
6468 static int
6470 {
6473 const int ret
6477 }
6479 /* Return a GCC tree for a record type given a GNAT Component_List and a chain
6480 of GCC trees for fields that are in the record and have already been
6481 processed. When called from gnat_to_gnu_entity during the processing of a
6482 record type definition, the GCC nodes for the discriminants will be on
6483 the chain. The other calls to this function are recursive calls from
6484 itself for the Component_List of a variant and the chain is empty.
6486 PACKED is 1 if this is for a packed record, -1 if this is for a record
6487 with Component_Alignment of Storage_Unit, -2 if this is for a record
6488 with a specified alignment.
6490 DEFINITION is true if we are defining this record.
6492 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
6493 with a rep clause is to be added. If it is nonzero, that is all that
6494 should be done with such fields.
6496 CANCEL_ALIGNMENT, if true, means the alignment should be zeroed before
6497 laying out the record. This means the alignment only serves to force fields
6498 to be bitfields, but not require the record to be that aligned. This is
6499 used for variants.
6501 ALL_REP, if true, means a rep clause was found for all the fields. This
6502 simplifies the logic since we know we're not in the mixed case.
6504 DO_NOT_FINALIZE, if true, means that the record type is expected to be
6505 modified afterwards so it will not be sent to the back-end for finalization.
6507 UNCHECKED_UNION, if true, means that we are building a type for a record
6508 with a Pragma Unchecked_Union.
6510 The processing of the component list fills in the chain with all of the
6511 fields of the record and then the record type is finished. */
6513 static void
6518 {
6519 Node_Id component_decl;
6520 Entity_Id gnat_field;
6521 Node_Id variant_part;
6527 /* For each variable within each component declaration create a GCC field
6528 and add it to the list, skipping any pragmas in the list. */
6533 {
6538 else
6539 {
6543 /* If this is the _Tag field, put it before any discriminants,
6544 instead of after them as is the case for all other fields. */
6547 else
6548 {
6551 }
6552 }
6555 }
6557 /* At the end of the component list there may be a variant part. */
6560 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
6561 mutually exclusive and should go in the same memory. To do this we need
6562 to treat each variant as a record whose elements are created from the
6563 component list for the variant. So here we create the records from the
6564 lists for the variants and put them all into the QUAL_UNION_TYPE.
6565 If this is an Unchecked_Union, we make a UNION_TYPE instead or
6566 use GNU_RECORD_TYPE if there are no fields so far. */
6568 {
6570 Node_Id variant;
6572 tree gnu_var_name
6576 tree gnu_union_type;
6577 tree gnu_union_name;
6578 tree gnu_union_field;
6587 /* Reuse an enclosing union if all fields are in the variant part
6588 and there is no representation clause on the record, to match
6589 the layout of C unions. There is an associated check below. */
6594 else
6595 {
6596 gnu_union_type
6602 }
6607 {
6609 tree gnu_inner_name;
6610 tree gnu_qual;
6618 /* Set the alignment of the inner type in case we need to make
6619 inner objects into bitfields, but then clear it out
6620 so the record actually gets only the alignment required. */
6624 /* Similarly, if the outer record has a size specified and all fields
6625 have record rep clauses, we can propagate the size into the
6626 variant part. */
6628 {
6632 }
6634 /* Create the record type for the variant. Note that we defer
6635 finalizing it until after we are sure to actually use it. */
6646 /* If this is an Unchecked_Union and we have exactly one field,
6647 use this field directly to match the layout of C unions. */
6652 else
6653 {
6654 /* Deal with packedness like in gnat_to_gnu_field. */
6655 int field_packed
6658 /* Finalize the record type now. We used to throw away
6659 empty records but we no longer do that because we need
6660 them to generate complete debug info for the variant;
6661 otherwise, the union type definition will be lacking
6662 the fields associated with these empty variants. */
6667 (all_rep_and_size
6670 (all_rep_and_size
6678 }
6682 }
6684 /* Only make the QUAL_UNION_TYPE if there are any non-empty variants. */
6686 {
6690 {
6694 }
6699 /* If GNU_UNION_TYPE is our record type, it means we must have an
6700 Unchecked_Union with no fields. Verify that and, if so, just
6701 return. */
6703 {
6705 && !gnu_field_list
6708 }
6710 /* Deal with packedness like in gnat_to_gnu_field. */
6711 union_field_packed
6714 gnu_union_field
6716 union_field_packed,
6723 }
6724 }
6726 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses. If they
6727 do, pull them out and put them into GNU_OUR_REP_LIST. We have to do this
6728 in a separate pass since we want to handle the discriminants but can't
6729 play with them until we've used them in debugging data above.
6731 ??? Note: if we then reorder them, debugging information will be wrong,
6732 but there's nothing that can be done about this at the moment. */
6734 {
6736 {
6741 else
6747 }
6748 else
6749 {
6752 }
6753 }
6755 /* If we have any items in our rep'ed field list, it is not the case that all
6756 the fields in the record have rep clauses, and P_REP_LIST is nonzero,
6757 set it and ignore the items. */
6761 {
6762 /* Otherwise, sort the fields by bit position and put them into their
6763 own record if we have any fields without rep clauses. */
6764 tree gnu_rep_type
6776 /* Put the fields in the list in order of increasing position, which
6777 means we start from the end. */
6780 {
6784 }
6787 {
6793 }
6794 else
6795 {
6798 }
6799 }
6806 }
6807 \f
6808 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
6809 placed into an Esize, Component_Bit_Offset, or Component_Size value
6810 in the GNAT tree. */
6812 static Uint
6814 {
6816 TCode tcode;
6822 /* See if we've already saved the value for this node. */
6824 {
6835 }
6837 /* If we do not return inside this switch, TCODE will be set to the
6838 code to use for a Create_Node operand and LEN (set above) will be
6839 the number of recursive calls for us to make. */
6842 {
6847 /* This may have come from a conversion from some smaller type,
6848 so ensure this is in bitsizetype. */
6851 /* For negative values, use NEGATE_EXPR of the supplied value. */
6853 {
6854 /* The ridiculous code below is to handle the case of the largest
6855 negative integer. */
6858 tree temp;
6861 {
6862 negative_size
6865 bitsize_one_node));
6867 }
6874 }
6881 /* This peculiar test is to make sure that the size fits in an int
6882 on machines where HOST_WIDE_INT is not "int". */
6885 else
6889 /* The only case we handle here is a simple discriminant reference. */
6897 else
6903 /* Now just list the operations we handle. */
6935 }
6937 /* Now get each of the operands that's relevant for this code. If any
6938 cannot be expressed as a repinfo node, say we can't. */
6943 {
6947 }
6951 /* Save the result in the cache. */
6953 {
6957 }
6960 }
6962 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding
6963 GCC type, set Component_Bit_Offset and Esize to the position and size
6964 used by Gigi. */
6966 static void
6968 {
6969 tree gnu_list;
6970 tree gnu_entry;
6971 Entity_Id gnat_field;
6973 /* We operate by first making a list of all fields and their positions
6974 (we can get the sizes easily at any time) by a recursive call
6975 and then update all the sizes into the tree. */
6978 BIGGEST_ALIGNMENT);
6985 {
6989 gnu_list);
6992 {
6994 {
6995 /* In this mode the tag and parent components have not been
6996 generated, so we add the appropriate offset to each
6997 component. For a component appearing in the current
6998 extension, the offset is the size of the parent. */
7001 parent_offset
7003 bitsizetype);
7004 else
7006 }
7008 Set_Component_Bit_Offset
7010 annotate_value
7015 parent_offset)));
7019 }
7022 {
7023 /* If there is no gnu_entry, this is an inherited component whose
7024 position is the same as in the parent type. */
7025 Set_Component_Bit_Offset
7030 }
7031 }
7032 }
7034 /* Scan all fields in GNU_TYPE and build entries where TREE_PURPOSE is the
7035 FIELD_DECL and TREE_VALUE a TREE_LIST with TREE_PURPOSE being the byte
7036 position and TREE_VALUE being a TREE_LIST with TREE_PURPOSE the value to be
7037 placed into DECL_OFFSET_ALIGN and TREE_VALUE the bit position. GNU_POS is
7038 to be added to the position, GNU_BITPOS to the bit position, OFFSET_ALIGN is
7039 the present value of DECL_OFFSET_ALIGN and GNU_LIST is a list of the entries
7040 so far. */
7042 static tree
7045 {
7046 tree gnu_field;
7051 {
7056 unsigned int our_offset_align
7059 gnu_result
7064 NULL_TREE),
7065 gnu_result);
7068 gnu_result
7071 our_offset_align);
7072 }
7075 }
7076 \f
7077 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
7078 corresponding to GNAT_OBJECT. If size is valid, return a tree corresponding
7079 to its value. Otherwise return 0. KIND is VAR_DECL is we are specifying
7080 the size for an object, TYPE_DECL for the size of a type, and FIELD_DECL
7081 for the size of a field. COMPONENT_P is true if we are being called
7082 to process the Component_Size of GNAT_OBJECT. This is used for error
7083 message handling and to indicate to use the object size of GNU_TYPE.
7084 ZERO_OK is true if a size of zero is permitted; if ZERO_OK is false,
7085 it means that a size of zero should be treated as an unspecified size. */
7087 static tree
7090 {
7091 Node_Id gnat_error_node;
7095 /* If a type needs strict alignment, a component of this type in
7096 a packed record cannot be packed and thus uses the type size. */
7099 else
7102 /* Find the node to use for errors. */
7109 else
7112 /* Return 0 if no size was specified, either because Esize was not Present or
7113 the specified size was zero. */
7117 /* Get the size as a tree. Give an error if a size was specified, but cannot
7118 be represented as in sizetype. */
7121 {
7126 }
7128 /* Ignore a negative size since that corresponds to our back-annotation.
7129 Also ignore a zero size unless a size clause exists. */
7133 /* The size of objects is always a multiple of a byte. */
7136 {
7140 else
7144 }
7146 /* If this is an integral type or a packed array type, the front-end has
7147 verified the size, so we need not do it here (which would entail
7148 checking against the bounds). However, if this is an aliased object, it
7149 may not be smaller than the type of the object. */
7154 /* If the object is a record that contains a template, add the size of
7155 the template to the specified size. */
7160 /* Modify the size of the type to be that of the maximum size if it has a
7161 discriminant. */
7165 /* If this is an access type or a fat pointer, the minimum size is that given
7166 by the smallest integral mode that's valid for pointers. */
7168 {
7174 ;
7177 }
7179 /* If the size of the object is a constant, the new size must not be
7180 smaller. */
7184 {
7186 post_error_ne_tree
7189 else
7196 post_error_ne_tree_2
7206 }
7209 }
7210 \f
7211 /* Similarly, but both validate and process a value of RM_Size. This
7212 routine is only called for types. */
7214 static void
7216 {
7217 /* Only give an error if a Value_Size clause was explicitly given.
7218 Otherwise, we'd be duplicating an error on the Size clause. */
7219 Node_Id gnat_attr_node
7222 tree size;
7224 /* Get the size as a tree. Do nothing if none was specified, either
7225 because RM_Size was not Present or if the specified size was zero.
7226 Give an error if a size was specified, but cannot be represented as
7227 in sizetype. */
7233 {
7236 gnat_entity);
7239 }
7241 /* Ignore a negative size since that corresponds to our back-annotation.
7242 Also ignore a zero size unless a size clause exists, a Value_Size
7243 clause exists, or this is an integer type, in which case the
7244 front end will have always set it. */
7251 /* If the old size is self-referential, get the maximum size. */
7255 /* If the size of the object is a constant, the new size must not be
7256 smaller (the front end checks this for scalar types). */
7261 {
7263 post_error_ne_tree
7268 }
7270 /* Otherwise, set the RM_Size. */
7282 }
7283 \f
7284 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
7285 If TYPE is the best type, return it. Otherwise, make a new type. We
7286 only support new integral and pointer types. FOR_BIASED is nonzero if
7287 we are making a biased type. */
7289 static tree
7291 {
7294 tree new_type;
7296 /* If size indicates an error, just return TYPE to avoid propagating
7297 the error. Likewise if it's too large to represent. */
7304 {
7311 /* Only do something if the type is not a packed array type and
7312 doesn't already have the proper size. */
7322 else
7329 /* Propagate the name to avoid creating a fake subrange type. */
7331 {
7334 else
7336 }
7342 /* Do something if this is a fat pointer, in which case we
7343 may need to return the thin pointer. */
7345 {
7349 return
7350 build_pointer_type_for_mode
7353 }
7357 /* Only do something if this is a thin pointer, in which case we
7358 may need to return the fat pointer. */
7360 return
7366 }
7369 }
7370 \f
7371 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
7372 a type or object whose present alignment is ALIGN. If this alignment is
7373 valid, return it. Otherwise, give an error and return ALIGN. */
7375 static unsigned int
7377 {
7380 Node_Id gnat_error_node;
7382 /* Don't worry about checking alignment if alignment was not specified
7383 by the source program and we already posted an error for this entity. */
7387 /* Post the error on the alignment clause if any. */
7390 else
7393 /* Within GCC, an alignment is an integer, so we must make sure a value is
7394 specified that fits in that range. Also, there is an upper bound to
7395 alignments we can support/allow. */
7406 else
7407 {
7411 }
7414 }
7416 /* Return the smallest alignment not less than SIZE. */
7418 static unsigned int
7420 {
7422 }
7423 \f
7424 /* Verify that OBJECT, a type or decl, is something we can implement
7425 atomically. If not, give an error for GNAT_ENTITY. COMP_P is true
7426 if we require atomic components. */
7428 static void
7430 {
7432 Node_Id gnat_node;
7435 tree size;
7437 /* There are three case of what OBJECT can be. It can be a type, in which
7438 case we take the size, alignment and mode from the type. It can be a
7439 declaration that was indirect, in which case the relevant values are
7440 that of the type being pointed to, or it can be a normal declaration,
7441 in which case the values are of the decl. The code below assumes that
7442 OBJECT is either a type or a decl. */
7444 {
7448 }
7450 {
7454 }
7455 else
7456 {
7460 }
7462 /* Consider all floating-point types atomic and any types that that are
7463 represented by integers no wider than a machine word. */
7470 /* For the moment, also allow anything that has an alignment equal
7471 to its size and which is smaller than a word. */
7479 {
7488 }
7493 else
7496 }
7497 \f
7498 /* Check if FTYPE1 and FTYPE2, two potentially different function type nodes,
7499 have compatible signatures so that a call using one type may be safely
7500 issued if the actual target function type is the other. Return 1 if it is
7501 the case, 0 otherwise, and post errors on the incompatibilities.
7503 This is used when an Ada subprogram is mapped onto a GCC builtin, to ensure
7504 that calls to the subprogram will have arguments suitable for the later
7505 underlying builtin expansion. */
7507 static int
7509 {
7510 /* As of now, we only perform very trivial tests and consider it's the
7511 programmer's responsibility to ensure the type correctness in the Ada
7512 declaration, as in the regular Import cases.
7514 Mismatches typically result in either error messages from the builtin
7515 expander, internal compiler errors, or in a real call sequence. This
7516 should be refined to issue diagnostics helping error detection and
7517 correction. */
7519 /* Almost fake test, ensuring a use of each argument. */
7524 }
7525 \f
7526 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new
7527 type with all size expressions that contain F updated by replacing F
7528 with R. If F is NULL_TREE, always make a new RECORD_TYPE, even if
7529 nothing has changed. */
7531 tree
7533 {
7535 tree tem;
7538 {
7544 {
7553 SET_TYPE_INDEX_TYPE
7556 }
7563 {
7577 }
7591 /* Don't know how to do these yet. */
7595 {
7611 /* If we had bounded the sizes of T by a constant, bound the sizes of
7612 NEW by the same constant. */
7622 }
7627 {
7628 tree field;
7629 bool changed_field
7636 /* Start out with no fields, make new fields, and chain them
7637 in. If we haven't actually changed the type of any field,
7638 discard everything we've done and return the old type. */
7644 {
7655 /* If this is an internal field and the type of this field is
7656 a UNION_TYPE or RECORD_TYPE with no elements, ignore it. If
7657 the type just has one element, treat that as the field.
7658 But don't do this if we are processing a QUAL_UNION_TYPE. */
7663 {
7668 {
7669 tree next_new_field
7672 /* Make sure omitting the union doesn't change
7673 the layout. */
7676 }
7677 }
7684 /* If the size of the old field was set at a constant,
7685 propagate the size in case the type's size was variable.
7686 (This occurs in the case of a variant or discriminated
7687 record with a default size used as a field of another
7688 record.) */
7697 {
7703 /* Do the substitution inside the qualifier and if we find
7704 that this field will not be present, omit it. */
7709 }
7713 else
7718 /* If this is a qualified type and this field will always be
7719 present, we are done. */
7723 }
7725 /* If this used to be a qualified union type, but we now know what
7726 field will be present, make this a normal union. */
7737 /* If the size was originally a constant use it. */
7740 {
7744 }
7747 }
7751 }
7752 }
7753 \f
7754 /* Return the "RM size" of GNU_TYPE. This is the actual number of bits
7755 needed to represent the object. */
7757 tree
7759 {
7760 /* For integer types, this is the precision. For record types, we store
7761 the size explicitly. For other types, this is just the size. */
7767 /* Return the rm_size of the actual data plus the size of the template. */
7768 return
7778 else
7780 }
7781 \f
7782 /* Return an identifier representing the external name to be used for
7783 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
7784 and the specified suffix. */
7786 tree
7788 {
7797 /* A variable using the Stdcall convention (meaning we are running
7798 on a Windows box) live in a DLL. Here we adjust its name to use
7799 the jump-table, the _imp__NAME contains the address for the NAME
7800 variable. */
7803 {
7810 }
7813 }
7815 /* Return the name to be used for GNAT_ENTITY. If a type, create a
7816 fully-qualified name, possibly with type information encoding.
7817 Otherwise, return the name. */
7819 tree
7821 {
7824 }
7826 /* Given GNU_ID, an IDENTIFIER_NODE containing a name and SUFFIX, a
7827 string, return a new IDENTIFIER_NODE that is the concatenation of
7828 the name in GNU_ID and SUFFIX. */
7830 tree
7832 {
7840 }