| blob | 6b14064641591f7ed022d3389373c49a03838248 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2007, 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 2, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License distributed with GNAT; see file COPYING. If not, write *
19 * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, *
20 * Boston, MA 02110-1301, USA. *
21 * *
22 * GNAT was originally developed by the GNAT team at New York University. *
23 * Extensive contributions were provided by Ada Core Technologies Inc. *
24 * *
25 ****************************************************************************/
57 /* Convention_Stdcall should be processed in a specific way on Windows targets
58 only. The macro below is a helper to avoid having to check for a Windows
59 specific attribute throughout this unit. */
61 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
62 #define Has_Stdcall_Convention(E) (Convention (E) == Convention_Stdcall)
63 #else
64 #define Has_Stdcall_Convention(E) (0)
65 #endif
67 /* These two variables are used to defer recursively expanding incomplete
68 types while we are processing a record or subprogram type. */
71 static struct incomplete
72 {
74 tree old_type;
75 Entity_Id full_type;
78 /* These two variables are used to defer emission of debug information for
79 nested incomplete record types */
84 /* A hash table used as to cache the result of annotate_value. */
86 htab_t annotate_value_cache;
112 /* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
113 GCC type corresponding to that entity. GNAT_ENTITY is assumed to
114 refer to an Ada type. */
116 tree
118 {
119 tree gnu_decl;
121 /* The back end never attempts to annotate generic types */
125 /* Convert the ada entity type into a GCC TYPE_DECL node. */
129 }
130 \f
131 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
132 entity, this routine returns the equivalent GCC tree for that entity
133 (an ..._DECL node) and associates the ..._DECL node with the input GNAT
134 defining identifier.
136 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
137 initial value (in GCC tree form). This is optional for variables.
138 For renamed entities, GNU_EXPR gives the object being renamed.
140 DEFINITION is nonzero if this call is intended for a definition. This is
141 used for separate compilation where it necessary to know whether an
142 external declaration or a definition should be created if the GCC equivalent
143 was not created previously. The value of 1 is normally used for a nonzero
144 DEFINITION, but a value of 2 is used in special circumstances, defined in
145 the code. */
147 tree
149 {
150 tree gnu_entity_id;
152 /* Contains the gnu XXXX_DECL tree node which is equivalent to the input
153 GNAT tree. This node will be associated with the GNAT node by calling
154 the save_gnu_tree routine at the end of the `switch' statement. */
156 /* true if we have already saved gnu_decl as a gnat association. */
158 /* Nonzero if we incremented defer_incomplete_level. */
160 /* Nonzero if we incremented defer_debug_level. */
162 /* Nonzero if we incremented force_global. */
164 /* Nonzero if we should check to see if elaborated during processing. */
166 /* Nonzero if we made GNU_DECL and its type here. */
172 Entity_Id gnat_temp;
173 unsigned int esize
183 bool imported_p
187 /* Since a use of an Itype is a definition, process it as such if it
188 is not in a with'ed unit. */
193 {
194 /* Ensure that we are in a subprogram mentioned in the Scope
195 chain of this entity, our current scope is global,
196 or that we encountered a task or entry (where we can't currently
197 accurately check scoping). */
200 {
203 }
207 {
212 gnat_temp
224 && (current_function_decl
226 {
229 }
230 }
232 /* This abort means the entity "gnat_entity" has an incorrect scope,
233 i.e. that its scope does not correspond to the subprogram in which
234 it is declared */
236 }
238 /* If this is entity 0, something went badly wrong. */
241 /* If we've already processed this entity, return what we got last time.
242 If we are defining the node, we should not have already processed it.
243 In that case, we will abort below when we try to save a new GCC tree for
244 this object. We also need to handle the case of getting a dummy type
245 when a Full_View exists. */
248 && (! definition
250 {
257 {
263 }
266 }
268 /* If this is a numeric or enumeral type, or an access type, a nonzero
269 Esize must be specified unless it was specified by the programmer. */
277 /* Likewise, RM_Size must be specified for all discrete and fixed-point
278 types. */
282 /* Get the name of the entity and set up the line number and filename of
283 the original definition for use in any decl we make. */
287 /* If we get here, it means we have not yet done anything with this
288 entity. If we are not defining it here, it must be external,
289 otherwise we should have defined it already. */
296 /* For cases when we are not defining (i.e., we are referencing from
297 another compilation unit) Public entities, show we are at global level
298 for the purpose of computing scopes. Don't do this for components or
299 discriminants since the relevant test is whether or not the record is
300 being defined. But do this for Imported functions or procedures in
301 all cases. */
309 /* Handle any attributes directly attached to the entity. */
313 /* Machine_Attributes on types are expected to be propagated to subtypes.
314 The corresponding Gigi_Rep_Items are only attached to the first subtype
315 though, so we handle the propagation here. */
322 {
324 /* If this is a use of a deferred constant, get its full
325 declaration. */
327 {
332 }
334 /* If we have an external constant that we are not defining,
335 get the expression that is was defined to represent. We
336 may throw that expression away later if it is not a
337 constant.
338 Do not retrieve the expression if it is an aggregate, because
339 in complex instantiation contexts it may not be expanded */
348 /* Ignore deferred constant definitions; they are processed fully in the
349 front-end. For deferred constant references, get the full
350 definition. On the other hand, constants that are renamings are
351 handled like variable renamings. If No_Initialization is set, this is
352 not a deferred constant but a constant whose value is built
353 manually. */
358 {
362 }
365 {
370 }
375 /* We used to special case VMS exceptions here to directly map them to
376 their associated condition code. Since this code had to be masked
377 dynamically to strip off the severity bits, this caused trouble in
378 the GCC/ZCX case because the "type" pointers we store in the tables
379 have to be static. We now don't special case here anymore, and let
380 the regular processing take place, which leaves us with a regular
381 exception data object for VMS exceptions too. The condition code
382 mapping is taken care of by the front end and the bitmasking by the
383 runtime library. */
388 {
389 /* The GNAT record where the component was defined. */
392 /* If the variable is an inherited record component (in the case of
393 extended record types), just return the inherited entity, which
394 must be a FIELD_DECL. Likewise for discriminants.
395 For discriminants of untagged records which have explicit
396 stored discriminants, return the entity for the corresponding
397 stored discriminant. Also use Original_Record_Component
398 if the record has a private extension. */
402 {
403 gnu_decl
408 }
410 /* If the enclosing record has explicit stored discriminants,
411 then it is an untagged record. If the Corresponding_Discriminant
412 is not empty then this must be a renamed discriminant and its
413 Original_Record_Component must point to the corresponding explicit
414 stored discriminant (i.e., we should have taken the previous
415 branch). */
419 {
420 /* A tagged record has no explicit stored discriminants. */
424 gnu_decl
429 }
433 {
438 }
440 /* If the enclosing record has explicit stored discriminants,
441 then it is an untagged record. If the Corresponding_Discriminant
442 is not empty then this must be a renamed discriminant and its
443 Original_Record_Component must point to the corresponding explicit
444 stored discriminant (i.e., we should have taken the first
445 branch). */
452 /* Otherwise, if we are not defining this and we have no GCC type
453 for the containing record, make one for it. Then we should
454 have made our own equivalent. */
456 {
457 /* ??? If this is in a record whose scope is a protected
458 type and we have an Original_Record_Component, use it.
459 This is a workaround for major problems in protected type
460 handling. */
468 {
469 gnu_decl
475 }
481 }
483 else
484 /* Here we have no GCC type and this is a reference rather than a
485 definition. This should never happen. Most likely the cause is a
486 reference before declaration in the gnat tree for gnat_entity. */
488 }
494 /* Simple variables, loop variables, OUT parameters, and exceptions. */
495 object:
496 {
498 bool const_flag
513 {
517 else
519 }
521 /* Get the type after elaborating the renamed object. */
524 /* If this is a loop variable, its type should be the base type.
525 This is because the code for processing a loop determines whether
526 a normal loop end test can be done by comparing the bounds of the
527 loop against those of the base type, which is presumed to be the
528 size used for computation. But this is not correct when the size
529 of the subtype is smaller than the type. */
533 /* Reject non-renamed objects whose types are unconstrained arrays or
534 any object whose type is a dummy type or VOID_TYPE. */
540 {
543 force_global--;
545 }
547 /* If an alignment is specified, use it if valid. Note that
548 exceptions are objects but don't have alignments. We must do this
549 before we validate the size, since the alignment can affect the
550 size. */
552 {
558 }
560 /* If we are defining the object, see if it has a Size value and
561 validate it if so. If we are not defining the object and a Size
562 clause applies, simply retrieve the value. We don't want to ignore
563 the clause and it is expected to have been validated already. Then
564 get the new type, if any. */
573 {
574 gnu_type
580 }
582 /* If this object has self-referential size, it must be a record with
583 a default value. We are supposed to allocate an object of the
584 maximum size in this case unless it is a constant with an
585 initializing expression, in which case we can get the size from
586 that. Note that the resulting size may still be a variable, so
587 this may end up with an indirect allocation. */
591 {
593 gnu_size
594 = SUBSTITUTE_PLACEHOLDER_IN_EXPR
597 /* We may have no GNU_EXPR because No_Initialization is
598 set even though there's an Expression. */
603 gnu_size
605 (Etype
607 else
608 {
611 }
612 }
614 /* If the size is zero bytes, make it one byte since some linkers have
615 trouble with zero-sized objects. If the object will have a
616 template, that will make it nonzero so don't bother. Also avoid
617 doing that for an object renaming or an object with an address
618 clause, as we would lose useful information on the view size
619 (e.g. for null array slices) and we are not allocating the object
620 here anyway. */
629 /* If this is an atomic object with no specified size and alignment,
630 but where the size of the type is a constant, set the alignment to
631 the lowest power of two greater than the size, or to the
632 biggest meaningful alignment, whichever is smaller. */
636 {
639 BIGGEST_ALIGNMENT))
641 else
646 }
648 /* If the object is set to have atomic components, find the component
649 type and validate it.
651 ??? Note that we ignore Has_Volatile_Components on objects; it's
652 not at all clear what to do in that case. */
655 {
664 }
666 /* Now check if the type of the object allows atomic access. Note
667 that we must test the type, even if this object has size and
668 alignment to allow such access, because we will be going
669 inside the padded record to assign to the object. We could fix
670 this by always copying via an intermediate value, but it's not
671 clear it's worth the effort. */
675 /* If this is an aliased object with an unconstrained nominal subtype,
676 make a type that includes the template. */
680 {
681 tree gnu_fat
684 gnu_type
688 }
690 #ifdef MINIMUM_ATOMIC_ALIGNMENT
691 /* If the size is a constant and no alignment is specified, force
692 the alignment to be the minimum valid atomic alignment. The
693 restriction on constant size avoids problems with variable-size
694 temporaries; if the size is variable, there's no issue with
695 atomic access. Also don't do this for a constant, since it isn't
696 necessary and can interfere with constant replacement. Finally,
697 do not do it for Out parameters since that creates an
698 size inconsistency with In parameters. */
707 #endif
709 /* Make a new type with the desired size and alignment, if needed. */
713 /* Make a volatile version of this object's type if we are to
714 make the object volatile. Note that 13.3(19) says that we
715 should treat other types of objects as volatile as well. */
725 /* Convert the expression to the type of the object except in the
726 case where the object's type is unconstrained or the object's type
727 is a padded record whose field is of self-referential size. In
728 the former case, converting will generate unnecessary evaluations
729 of the CONSTRUCTOR to compute the size and in the latter case, we
730 want to only copy the actual data. */
736 && (CONTAINS_PLACEHOLDER_P
740 /* See if this is a renaming, and handle appropriately depending on
741 what is renamed and in which context. There are three major
742 cases:
744 1/ This is a constant renaming and we can just make an object
745 with what is renamed as its initial value,
747 2/ We can reuse a stabilized version of what is renamed in place
748 of the renaming,
750 3/ If neither 1 or 2 applies, we make the renaming entity a constant
751 pointer to what is being renamed. */
754 {
755 /* If the renamed object had padding, strip off the reference
756 to the inner object and reset our type. */
760 && (TYPE_IS_PADDING_P
762 {
765 }
767 /* Case 1: If this is a constant renaming, treat it as a normal
768 object whose initial value is what is being renamed. We cannot
769 do this if the type is unconstrained or class-wide. */
776 ;
778 /* Otherwise, see if we can proceed with a stabilized version of
779 the renamed entity or if we need to make a pointer. */
780 else
781 {
785 /* Case 2: If the renaming entity need not be materialized and
786 the renamed expression is something we can stabilize, use
787 that for the renaming. At the global level, we can only do
788 this if we know no SAVE_EXPRs need be made, because the
789 expression we return might be used in arbitrary conditional
790 branches so we must force the SAVE_EXPRs evaluation
791 immediately and this requires a function context. */
796 {
797 maybe_stable_expr
802 {
807 }
809 /* The stabilization failed. Keep maybe_stable_expr
810 untouched here to let the pointer case below know
811 about that failure. */
812 }
814 /* Case 3: Make this into a constant pointer to the object we
815 are to rename and attach the object to the pointer if it is
816 an lvalue that can be stabilized.
818 From the proper scope, attached objects will be referenced
819 directly instead of indirectly via the pointer to avoid
820 subtle aliasing problems with non addressable entities.
821 They have to be stable because we must not evaluate the
822 variables in the expression every time the renaming is used.
823 They also have to be lvalues because the context in which
824 they are reused sometimes requires so. We call pointers
825 with an attached object "renaming" pointers.
827 In the rare cases where we cannot stabilize the renamed
828 object, we just make a "bare" pointer, and the renamed
829 entity is always accessed indirectly through it. */
830 {
835 /* If a previous attempt at unrestricted stabilization
836 failed, there is no point trying again and we can reuse
837 the result without attaching it to the pointer. In this
838 case it will only be used as the initializing expression
839 of the pointer and thus needs no special treatment with
840 regard to multiple evaluations. */
842 ;
844 /* Otherwise, try to stabilize now, restricting to lvalues
845 only, and attach the expression to the pointer if the
846 stabilization succeeds.
848 Note that this might introduce SAVE_EXPRs and we don't
849 check whether we're at the global level or not. This is
850 fine since we are building a pointer initializer and
851 neither the pointer nor the initializing expression can
852 be accessed before the pointer elaboration has taken
853 place in a correct program.
855 SAVE_EXPRs will be evaluated at the right spots by either
856 create_var_decl->expand_decl_init for the non-global case
857 or build_unit_elab for the global case, and will be
858 attached to the elaboration procedure by the RTL expander
859 in the latter case. We have no need to force an early
860 evaluation here. */
861 else
862 {
863 maybe_stable_expr
870 /* Attaching is actually performed downstream, as soon
871 as we have a VAR_DECL for the pointer we make. */
872 }
874 gnu_expr
879 }
880 }
881 }
883 /* If this is an aliased object whose nominal subtype is unconstrained,
884 the object is a record that contains both the template and
885 the object. If there is an initializer, it will have already
886 been converted to the right type, but we need to create the
887 template if there is no initializer. */
890 /* Beware that padding might have been introduced
891 via maybe_pad_type above. */
894 == RECORD_TYPE
895 && TYPE_CONTAINS_TEMPLATE_P
898 {
899 tree template_field
904 gnu_expr
905 = gnat_build_constructor
907 tree_cons
911 NULL_TREE),
912 NULL_TREE));
913 }
915 /* If this is a pointer and it does not have an initializing
916 expression, initialize it to NULL, unless the object is
917 imported. */
923 /* If we are defining the object and it has an Address clause we must
924 get the address expression from the saved GCC tree for the
925 object if the object has a Freeze_Node. Otherwise, we elaborate
926 the address expression here since the front-end has guaranteed
927 in that case that the elaboration has no effects. Note that
928 only the latter mechanism is currently in use. */
930 {
931 tree gnu_address
937 /* Ignore the size. It's either meaningless or was handled
938 above. */
940 /* The address expression contains a conversion from pointer type
941 to the system__address integer type, which means the address
942 of the underlying object escapes. We therefore have no other
943 choice than forcing the type of the object being defined to
944 alias everything in order to make type-based alias analysis
945 aware that it will dereference the escaped address.
946 ??? This uncovers problems in ACATS at -O2 with the volatility
947 of the original type: it may not be correctly propagated, thus
948 causing PRE to enter an infinite loop creating value numbers
949 out of volatile expressions. Disable it for now. */
950 gnu_type
956 /* If we don't have an initializing expression for the underlying
957 variable, the initializing expression for the pointer is the
958 specified address. Otherwise, we have to make a COMPOUND_EXPR
959 to assign both the address and the initial value. */
962 else
963 gnu_expr
965 build_binary_op
968 gnu_address),
969 gnu_expr),
970 gnu_address);
971 }
973 /* If it has an address clause and we are not defining it, mark it
974 as an indirect object. Likewise for Stdcall objects that are
975 imported. */
979 {
980 /* See the definition case above for the rationale. */
981 gnu_type
986 /* No point in taking the address of an initializing expression
987 that isn't going to be used. */
990 }
992 /* If we are at top level and this object is of variable size,
993 make the actual type a hidden pointer to the real type and
994 make the initializer be a memory allocation and initialization.
995 Likewise for objects we aren't defining (presumed to be
996 external references from other packages), but there we do
997 not set up an initialization.
999 If the object's size overflows, make an allocator too, so that
1000 Storage_Error gets raised. Note that we will never free
1001 such memory, so we presume it never will get allocated. */
1006 || (gnu_size
1010 {
1016 /* In case this was a aliased object whose nominal subtype is
1017 unconstrained, the pointer above will be a thin pointer and
1018 build_allocator will automatically make the template.
1020 If we have a template initializer only (that we made above),
1021 pretend there is none and rely on what build_allocator creates
1022 again anyway. Otherwise (if we have a full initializer), get
1023 the data part and feed that to build_allocator.
1025 If we are elaborating a mutable object, tell build_allocator to
1026 ignore a possibly simpler size from the initializer, if any, as
1027 we must allocate the maximum possible size in this case. */
1030 {
1035 {
1036 gnu_alloc_type
1043 else
1044 gnu_expr
1045 = build_component_ref
1049 }
1055 gnat_entity);
1059 }
1060 else
1061 {
1064 }
1065 }
1067 /* If this object would go into the stack and has an alignment
1068 larger than the default largest alignment, make a variable
1069 to hold the "aligning type" with a modified initial value,
1070 if any, then point to it and make that the value of this
1071 variable, which is now indirect. */
1074 {
1075 tree gnu_new_type
1078 tree gnu_new_var;
1080 gnu_new_var
1086 add_stmt_with_node
1088 build_component_ref
1091 gnu_expr),
1092 gnat_entity);
1095 gnu_expr
1096 = build_unary_op
1104 }
1110 /* Convert the expression to the type of the object except in the
1111 case where the object's type is unconstrained or the object's type
1112 is a padded record whose field is of self-referential size. In
1113 the former case, converting will generate unnecessary evaluations
1114 of the CONSTRUCTOR to compute the size and in the latter case, we
1115 want to only copy the actual data. */
1121 && (CONTAINS_PLACEHOLDER_P
1125 /* If this name is external or there was a name specified, use it,
1126 unless this is a VMS exception object since this would conflict
1127 with the symbol we need to export in addition. Don't use the
1128 Interface_Name if there is an address clause (see CD30005). */
1137 /* If this is constant initialized to a static constant and the
1138 object has an aggregate type, force it to be statically
1139 allocated. */
1155 {
1158 {
1161 }
1162 }
1169 STACK_CHECK_MAX_VAR_SIZE))))
1174 gnat_entity);
1176 /* If this is a public constant or we're not optimizing and we're not
1177 making a VAR_DECL for it, make one just for export or debugger
1178 use. Likewise if the address is taken or if the object or type is
1179 aliased. */
1186 {
1187 tree gnu_corr_var
1193 }
1195 /* If this is declared in a block that contains a block with an
1196 exception handler, we must force this variable in memory to
1197 suppress an invalid optimization. */
1202 /* Back-annotate the Alignment of the object if not already in the
1203 tree. Likewise for Esize if the object is of a constant size.
1204 But if the "object" is actually a pointer to an object, the
1205 alignment and size are the same as the type, so don't back-annotate
1206 the values for the pointer. */
1213 {
1218 gnu_back_size
1223 }
1224 }
1228 /* Return a TYPE_DECL for "void" that we previously made. */
1233 /* A special case, for the types Character and Wide_Character in
1234 Standard, we do not list all the literals. So if the literals
1235 are not specified, make this an unsigned type. */
1237 {
1241 /* Set the TYPE_STRING_FLAG for Ada Character and
1242 Wide_Character types. This is needed by the dwarf-2 debug writer to
1243 distinguish between unsigned integer types and character types. */
1246 }
1248 /* Normal case of non-character type, or non-Standard character type */
1249 {
1250 /* Here we have a list of enumeral constants in First_Literal.
1251 We make a CONST_DECL for each and build into GNU_LITERAL_LIST
1252 the list to be places into TYPE_FIELDS. Each node in the list
1253 is a TREE_LIST node whose TREE_VALUE is the literal name
1254 and whose TREE_PURPOSE is the value of the literal.
1256 Esize contains the number of bits needed to represent the enumeral
1257 type, Type_Low_Bound also points to the first literal and
1258 Type_High_Bound points to the last literal. */
1260 Entity_Id gnat_literal;
1265 else
1273 {
1275 gnu_type);
1276 tree gnu_literal
1284 }
1288 /* Note that the bounds are updated at the end of this function
1289 because to avoid an infinite recursion when we get the bounds of
1290 this type, since those bounds are objects of this type. */
1291 }
1297 /* For integer types, just make a signed type the appropriate number
1298 of bits. */
1303 /* For modular types, make the unsigned type of the proper number of
1304 bits and then set up the modulus, if required. */
1305 {
1307 tree gnu_modulus;
1313 /* Find the smallest mode at least ESIZE bits wide and make a class
1314 using that mode. */
1319 ;
1325 /* Get the modulus in this type. If it overflows, assume it is because
1326 it is equal to 2**Esize. Note that there is no overflow checking
1327 done on unsigned type, so we detect the overflow by looking for
1328 a modulus of zero, which is otherwise invalid. */
1332 {
1337 }
1339 /* If we have to set TYPE_PRECISION different from its natural value,
1340 make a subtype to do do. Likewise if there is a modulus and
1341 it is not one greater than TYPE_MAX_VALUE. */
1345 {
1362 }
1363 }
1372 /* For integral subtypes, we make a new INTEGER_TYPE. Note
1373 that we do not want to call build_range_type since we would
1374 like each subtype node to be distinct. This will be important
1375 when memory aliasing is implemented.
1377 The TREE_TYPE field of the INTEGER_TYPE we make points to the
1378 parent type; this fact is used by the arithmetic conversion
1379 functions.
1381 We elaborate the Ancestor_Subtype if it is not in the current
1382 unit and one of our bounds is non-static. We do this to ensure
1383 consistent naming in the case where several subtypes share the same
1384 bounds by always elaborating the first such subtype first, thus
1385 using its name. */
1397 {
1400 }
1408 gnat_entity,
1415 gnat_entity,
1419 /* One of the above calls might have caused us to be elaborated,
1420 so don't blow up if so. */
1422 {
1425 }
1430 /* This should be an unsigned type if the lower bound is constant
1431 and non-negative or if the base type is unsigned; a signed type
1432 otherwise. */
1442 /* Inherit our alias set from what we're a subtype of. Subtypes
1443 are not different types and a pointer can designate any instance
1444 within a subtype hierarchy. */
1447 /* If the type we are dealing with is to represent a packed array,
1448 we need to have the bits left justified on big-endian targets
1449 and right justified on little-endian targets. We also need to
1450 ensure that when the value is read (e.g. for comparison of two
1451 such values), we only get the good bits, since the unused bits
1452 are uninitialized. Both goals are accomplished by wrapping the
1453 modular value in an enclosing struct. */
1455 {
1457 tree gnu_field;
1466 /* Create a stripped-down declaration of the original type, mainly
1467 for debugging. */
1471 /* Don't notify the field as "addressable", since we won't be taking
1472 it's address and it would prevent create_field_decl from making a
1473 bitfield. */
1482 }
1487 /* If this is a VAX floating-point type, use an integer of the proper
1488 size. All the operations will be handled with ASM statements. */
1490 {
1495 sizetype));
1497 }
1499 /* The type of the Low and High bounds can be our type if this is
1500 a type from Standard, so set them at the end of the function. */
1508 {
1511 }
1513 {
1540 /* One of the above calls might have caused us to be elaborated,
1541 so don't blow up if so. */
1543 {
1546 }
1550 /* Inherit our alias set from what we're a subtype of, as for
1551 integer subtypes. */
1553 }
1556 /* Array and String Types and Subtypes
1558 Unconstrained array types are represented by E_Array_Type and
1559 constrained array types are represented by E_Array_Subtype. There
1560 are no actual objects of an unconstrained array type; all we have
1561 are pointers to that type.
1563 The following fields are defined on array types and subtypes:
1565 Component_Type Component type of the array.
1566 Number_Dimensions Number of dimensions (an int).
1567 First_Index Type of first index. */
1571 {
1577 int firstdim
1579 int nextdim
1585 tree gnu_max_size_unit;
1587 Entity_Id gnat_ind_subtype;
1588 Entity_Id gnat_ind_base_subtype;
1589 tree gnu_template_reference;
1590 tree tem;
1598 /* Make a node for the array. If we are not defining the array
1599 suppress expanding incomplete types. */
1605 /* Build the fat pointer type. Use a "void *" object instead of
1606 a pointer to the array type since we don't have the array type
1607 yet (it will reference the fat pointer via the bounds). */
1610 ptr_void_type_node,
1613 gnu_ptr_template,
1616 /* Make sure we can put this into a register. */
1620 /* Build a reference to the template from a PLACEHOLDER_EXPR that
1621 is the fat pointer. This will be used to access the individual
1622 fields once we build them. */
1626 gnu_template_reference
1630 /* Now create the GCC type for each index and add the fields for
1631 that index to the template. */
1633 gnat_ind_base_subtype
1639 {
1641 tree gnu_ind_subtype
1643 tree gnu_base_subtype
1645 tree gnu_base_min
1647 tree gnu_base_max
1651 /* Make the FIELD_DECLs for the minimum and maximum of this
1652 type and then make extractions of that field from the
1653 template. */
1656 gnu_ind_subtype,
1660 gnu_ind_subtype,
1669 /* We can't use build_component_ref here since the template
1670 type isn't complete yet. */
1673 NULL_TREE);
1676 NULL_TREE);
1679 /* Make a range type with the new ranges, but using
1680 the Ada subtype. Then we convert to sizetype. */
1686 /* Update the maximum size of the array, in elements. */
1687 gnu_max_size
1691 gnu_base_min)));
1695 }
1698 gnu_template_fields
1701 /* Install all the fields into the template. */
1706 /* Now make the array of arrays and update the pointer to the array
1707 in the fat pointer. Note that it is the first field. */
1711 /* Get and validate any specified Component_Size, but if Packed,
1712 ignore it since the front end will have taken care of it. */
1713 gnu_comp_size
1715 gnat_entity,
1723 /* If the component type is a RECORD_TYPE that has a self-referential
1724 size, use the maxium size. */
1730 {
1734 }
1740 /* If Component_Size is not already specified, annotate it with the
1741 size of the component. */
1751 gnu_max_size),
1755 {
1759 /* If the type below this is a multi-array type, then this
1760 does not have aliased components. But we have to make
1761 them addressable if it must be passed by reference or
1762 if that is the default. */
1769 }
1771 /* If an alignment is specified, use it if valid. But ignore it for
1772 types that represent the unpacked base type for packed arrays. */
1775 {
1780 }
1786 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
1787 corresponding fat pointer. */
1794 /* If the maximum size doesn't overflow, use it. */
1809 /* Create a record type for the object and its template and
1810 set the template at a negative offset. */
1822 /* Give the thin pointer type a name. */
1826 gnat_entity);
1827 }
1833 /* This is the actual data type for array variables. Multidimensional
1834 arrays are implemented in the gnu tree as arrays of arrays. Note
1835 that for the moment arrays which have sparse enumeration subtypes as
1836 index components create sparse arrays, which is obviously space
1837 inefficient but so much easier to code for now.
1839 Also note that the subtype never refers to the unconstrained
1840 array type, which is somewhat at variance with Ada semantics.
1842 First check to see if this is simply a renaming of the array
1843 type. If so, the result is the array type. */
1848 else
1849 {
1852 int first_dim
1855 int next_dim
1857 Entity_Id gnat_ind_subtype;
1858 Entity_Id gnat_ind_base_subtype;
1863 tree gnu_max_size_unit;
1867 /* First create the gnu types for each index. Create types for
1868 debugging information to point to the index types if the
1869 are not integer types, have variable bounds, or are
1870 wider than sizetype. */
1873 gnat_ind_base_subtype
1879 {
1880 tree gnu_index_subtype
1882 tree gnu_min
1884 tree gnu_max
1886 tree gnu_base_subtype
1888 tree gnu_base_min
1890 tree gnu_base_max
1893 tree gnu_base_base_min
1895 tree gnu_base_base_max
1897 tree gnu_high;
1898 tree gnu_this_max;
1900 /* If the minimum and maximum values both overflow in
1901 SIZETYPE, but the difference in the original type
1902 does not overflow in SIZETYPE, ignore the overflow
1903 indications. */
1911 && (!TREE_OVERFLOW
1917 /* Similarly, if the range is null, use bounds of 1..0 for
1918 the sizetype bounds. */
1930 /* Now compute the size of this bound. We need to provide
1931 GCC with an upper bound to use but have to deal with the
1932 "superflat" case. There are three ways to do this. If we
1933 can prove that the array can never be superflat, we can
1934 just use the high bound of the index subtype. If we can
1935 prove that the low bound minus one can't overflow, we
1936 can do this as MAX (hb, lb - 1). Otherwise, we have to use
1937 the expression hb >= lb ? hb : lb - 1. */
1940 /* See if the base array type is already flat. If it is, we
1941 are probably compiling an ACVC test, but it will cause the
1942 code below to malfunction if we don't handle it specially. */
1950 /* If gnu_high is now an integer which overflowed, the array
1951 cannot be superflat. */
1958 else
1959 gnu_high
1960 = build_cond_expr
1968 /* Also compute the maximum size of the array. Here we
1969 see if any constraint on the index type of the base type
1970 can be used in the case of self-referential bound on
1971 the index type of the subtype. We look for a non-"infinite"
1972 and non-self-referential bound from any type involved and
1973 handle each bound separately. */
2002 gnu_this_max
2006 gnu_base_min)),
2007 size_zero_node);
2013 gnu_max_size
2027 }
2029 /* Then flatten: create the array of arrays. */
2033 /* One of the above calls might have caused us to be elaborated,
2034 so don't blow up if so. */
2036 {
2039 }
2041 /* Get and validate any specified Component_Size, but if Packed,
2042 ignore it since the front end will have taken care of it. */
2043 gnu_comp_size
2045 gnat_entity,
2050 /* If the component type is a RECORD_TYPE that has a self-referential
2051 size, use the maxium size. */
2057 {
2062 }
2076 {
2080 /* If the type below this is a multi-array type, then this
2081 does not have aliased components. But we have to make
2082 them addressable if it must be passed by reference or
2083 if that is the default. */
2090 }
2092 /* If we are at file level and this is a multi-dimensional array, we
2093 need to make a variable corresponding to the stride of the
2094 inner dimensions. */
2096 {
2098 tree gnu_arr_type;
2104 {
2112 /* ??? For now, store the size as a multiple of the
2113 alignment of the element type in bytes so that we
2114 can see the alignment from the tree. */
2116 = build_binary_op
2118 elaborate_expression_1
2127 }
2128 }
2130 /* If we need to write out a record type giving the names of
2131 the bounds, do it now. */
2133 {
2136 tree gnu_field;
2142 {
2143 tree gnu_type_name
2150 integer_type_node,
2151 gnu_bound_rec_type,
2155 }
2159 }
2166 /* If our size depends on a placeholder and the maximum size doesn't
2167 overflow, use it. */
2174 {
2180 }
2182 /* Set our alias set to that of our base type. This gives all
2183 array subtypes the same alias set. */
2185 }
2187 /* If this is a packed type, make this type the same as the packed
2188 array type, but do some adjusting in the type first. */
2191 {
2192 Entity_Id gnat_index;
2193 tree gnu_inner_type;
2195 /* First finish the type we had been making so that we output
2196 debugging information for it */
2197 gnu_type
2200 | (TYPE_QUAL_VOLATILE
2208 /* Save it as our equivalent in case the call below elaborates
2209 this type again. */
2223 /* We need to point the type we just made to our index type so
2224 the actual bounds can be put into a template. */
2230 {
2232 {
2233 /* The TYPE_ACTUAL_BOUNDS field is also used for the modulus.
2234 If it is, we need to make another type. */
2236 {
2237 tree gnu_subtype;
2254 }
2257 }
2263 SET_TYPE_ACTUAL_BOUNDS
2270 SET_TYPE_ACTUAL_BOUNDS
2277 }
2278 }
2280 /* Abort if packed array with no packed array type field set. */
2281 else
2287 /* Create the type for a string literal. */
2288 {
2289 Entity_Id gnat_full_type
2294 tree gnu_string_array_type
2296 tree gnu_string_index_type
2299 tree gnu_lower_bound
2304 tree gnu_upper_bound
2306 gnu_lower_bound,
2308 tree gnu_range_type
2311 tree gnu_index_type
2316 gnu_range_type);
2318 gnu_type
2320 gnu_index_type);
2322 }
2325 /* Record Types and Subtypes
2327 The following fields are defined on record types:
2329 Has_Discriminants True if the record has discriminants
2330 First_Discriminant Points to head of list of discriminants
2331 First_Entity Points to head of list of fields
2332 Is_Tagged_Type True if the record is tagged
2334 Implementation of Ada records and discriminated records:
2336 A record type definition is transformed into the equivalent of a C
2337 struct definition. The fields that are the discriminants which are
2338 found in the Full_Type_Declaration node and the elements of the
2339 Component_List found in the Record_Type_Definition node. The
2340 Component_List can be a recursive structure since each Variant of
2341 the Variant_Part of the Component_List has a Component_List.
2343 Processing of a record type definition comprises starting the list of
2344 field declarations here from the discriminants and the calling the
2345 function components_to_record to add the rest of the fields from the
2346 component list and return the gnu type node. The function
2347 components_to_record will call itself recursively as it traverses
2348 the tree. */
2352 {
2353 gnu_type
2354 = build_complex_type
2355 (get_unpadded_type
2358 (Component_List
2359 (Type_Definition
2363 }
2365 {
2368 Entity_Id gnat_field;
2369 tree gnu_field;
2371 tree gnu_get_parent;
2378 bool is_extension
2382 /* See if all fields have a rep clause. Stop when we find one
2383 that doesn't. */
2392 /* If this is a record extension, go a level further to find the
2393 record definition. Also, verify we have a Parent_Subtype. */
2395 {
2402 }
2404 /* Make a node for the record. If we are not defining the record,
2405 suppress expanding incomplete types. */
2408 /* ??? We should have create_type_decl like in the E_Record_Subtype
2409 case below. Unfortunately this would cause GNU_TYPE to be marked
2410 as visited, thus precluding the subtrees of the type that will be
2411 built below from being marked as visited when the real TYPE_DECL
2412 is eventually created. A solution could be to devise a special
2413 version of the function under the name create_type_stub_decl. */
2422 /* If both a size and rep clause was specified, put the size in
2423 the record type now so that it can get the proper mode. */
2427 /* Always set the alignment here so that it can be used to
2428 set the mode, if it is making the alignment stricter. If
2429 it is invalid, it will be checked again below. If this is to
2430 be Atomic, choose a default alignment of a word unless we know
2431 the size and it's smaller. */
2440 /* If we have a Parent_Subtype, make a field for the parent. If
2441 this record has rep clauses, force the position to zero. */
2443 {
2445 tree gnu_parent;
2447 /* A major complexity here is that the parent subtype will
2448 reference our discriminants in its Discriminant_Constraint
2449 list. But those must reference the parent component of this
2450 record which is of the parent subtype we have not built yet!
2451 To break the circle we first build a dummy COMPONENT_REF which
2452 represents the "get to the parent" operation and initialize
2453 each of those discriminants to a COMPONENT_REF of the above
2454 dummy parent referencing the corresponding discriminant of the
2455 base type of the parent subtype. */
2459 NULL_TREE),
2460 NULL_TREE);
2467 save_gnu_tree
2471 gnu_get_parent,
2474 NULL_TREE),
2477 /* Then we build the parent subtype. */
2480 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
2481 initially built. The discriminants must reference the fields
2482 of the parent subtype and not those of its base type for the
2483 placeholder machinery to properly work. */
2489 {
2499 }
2501 /* The "get to the parent" COMPONENT_REF must be given its
2502 proper type... */
2505 /* ...and reference the _parent field of this record. */
2506 gnu_field_list
2514 }
2516 /* Make the fields for the discriminants and put them into the record
2517 unless it's an Unchecked_Union. */
2522 {
2523 /* If this is a record extension and this discriminant
2524 is the renaming of another discriminant, we've already
2525 handled the discriminant above. */
2530 gnu_field
2533 /* Make an expression using a PLACEHOLDER_EXPR from the
2534 FIELD_DECL node just created and link that with the
2535 corresponding GNAT defining identifier. Then add to the
2536 list of fields. */
2545 {
2548 }
2549 }
2551 /* Put the discriminants into the record (backwards), so we can
2552 know the appropriate discriminant to use for the names of the
2553 variants. */
2556 /* Add the listed fields into the record and finish up. */
2563 {
2565 defer_debug_level++;
2567 defer_debug_incomplete_list
2569 defer_debug_incomplete_list);
2570 }
2572 /* We used to remove the associations of the discriminants and
2573 _Parent for validity checking, but we may need them if there's
2574 Freeze_Node for a subtype used in this record. */
2579 /* If it is a tagged record force the type to BLKmode to insure
2580 that these objects will always be placed in memory. Do the
2581 same thing for limited record types. */
2585 /* If this is a derived type, we must make the alias set of this type
2586 the same as that of the type we are derived from. We assume here
2587 that the other type is already frozen. */
2593 /* Fill in locations of fields. */
2596 /* If there are any entities in the chain corresponding to
2597 components that we did not elaborate, ensure we elaborate their
2598 types if they are Itypes. */
2606 }
2610 /* If an equivalent type is present, that is what we should use.
2611 Otherwise, fall through to handle this like a record subtype
2612 since it may have constraints. */
2615 {
2620 }
2622 /* ... fall through ... */
2626 /* If Cloned_Subtype is Present it means this record subtype has
2627 identical layout to that type or subtype and we should use
2628 that GCC type for this one. The front end guarantees that
2629 the component list is shared. */
2631 {
2635 }
2637 /* Otherwise, first ensure the base type is elaborated. Then, if we are
2638 changing the type, make a new type with each field having the
2639 type of the field in the new subtype but having the position
2640 computed by transforming every discriminant reference according
2641 to the constraints. We don't see any difference between
2642 private and nonprivate type here since derivations from types should
2643 have been deferred until the completion of the private type. */
2644 else
2645 {
2647 tree gnu_base_type;
2648 tree gnu_orig_type;
2653 /* Get the base type initially for its alignment and sizes. But
2654 if it is a padded type, we do all the other work with the
2655 unpadded type. */
2664 {
2667 }
2669 /* When the type has discriminants, and these discriminants
2670 affect the shape of what it built, factor them in.
2672 If we are making a subtype of an Unchecked_Union (must be an
2673 Itype), just return the type.
2675 We can't just use Is_Constrained because private subtypes without
2676 discriminants of full types with discriminants with default
2677 expressions are Is_Constrained but aren't constrained! */
2685 {
2686 Entity_Id gnat_field;
2688 tree gnu_pos_list
2691 BIGGEST_ALIGNMENT);
2692 tree gnu_subst_list
2694 definition);
2695 tree gnu_temp;
2701 gnat_entity);
2713 {
2714 tree gnu_old_field
2717 tree gnu_offset
2719 gnu_pos_list));
2722 tree gnu_field_type
2726 unsigned int offset_align
2729 tree gnu_field;
2731 /* If there was a component clause, the field types must be
2732 the same for the type and subtype, so copy the data from
2733 the old field to avoid recomputation here. Also if the
2734 field is justified modular and the optimization in
2735 gnat_to_gnu_field was applied. */
2742 {
2745 }
2747 /* If this was a bitfield, get the size from the old field.
2748 Also ensure the type can be placed into a bitfield. */
2750 {
2756 }
2765 /* If the size is now a constant, we can set it as the
2766 size of the field when we make it. Otherwise, we need
2767 to deal with it specially. */
2771 gnu_field
2772 = create_field_decl
2778 {
2787 bitsize_unit_node));
2789 }
2793 SET_DECL_ORIGINAL_FIELD
2804 }
2806 /* Now go through the entities again looking for Itypes that
2807 we have not elaborated but should (e.g., Etypes of fields
2808 that have Original_Components). */
2819 /* Now set the size, alignment and alias set of the new type to
2820 match that of the old one, doing any substitutions, as
2821 above. */
2847 SET_TYPE_ADA_SIZE
2852 /* Recompute the mode of this record type now that we know its
2853 actual size. */
2856 /* Fill in locations of fields. */
2858 }
2860 /* If we've made a new type, record it and make an XVS type to show
2861 what this is a subtype of. Some debuggers require the XVS
2862 type to be output first, so do it in that order. */
2864 {
2866 {
2877 integer_type_node,
2878 gnu_subtype_marker,
2882 }
2889 }
2891 /* Otherwise, go down all the components in the new type and
2892 make them equivalent to those in the base type. */
2893 else
2900 gnat_to_gnu_field_decl
2902 }
2907 /* If we are not defining this entity, and we have incomplete
2908 entities being processed above us, make a dummy type and
2909 fill it in later. */
2911 {
2915 gnu_type
2916 = build_pointer_type
2929 }
2931 /* ... fall through ... */
2938 {
2940 /* Get the "full view" of this entity. If this is an incomplete
2941 entity from a limited with, treat its non-limited view as the
2942 full view. Otherwise, if this is an incomplete or private
2943 type, use the full view. */
2944 Entity_Id gnat_desig_full
2951 /* We want to know if we'll be seeing the freeze node for any
2952 incomplete type we may be pointing to. */
2953 bool in_main_unit
2969 {
2971 {
2975 }
2977 Incomplete_Or_Private_Kind))
2979 }
2984 /* If either the designated type or its full view is an
2985 unconstrained array subtype, replace it with the type it's a
2986 subtype of. This avoids problems with multiple copies of
2987 unconstrained array types. */
2996 /* If the designated type is a subtype of an incomplete record type,
2997 use the parent type to avoid order of elaboration issues. This
2998 can lose some code efficiency, but there is no alternative. */
3004 /* If we are pointing to an incomplete type whose completion is an
3005 unconstrained array, make a fat pointer type instead of a pointer
3006 to VOID. The two types in our fields will be pointers to VOID and
3007 will be replaced in update_pointer_to. Similarly, if the type
3008 itself is a dummy type or an unconstrained array. Also make
3009 a dummy TYPE_OBJECT_RECORD_TYPE in case we have any thin
3010 pointers to it. */
3026 && defer_incomplete_level
3036 {
3037 tree gnu_old
3041 tree fields;
3043 /* Show the dummy we get will be a fat pointer. */
3046 /* If the call above got something that has a pointer, that
3047 pointer is our type. This could have happened either
3048 because the type was elaborated or because somebody
3049 else executed the code below. */
3052 {
3058 fields
3060 create_field_decl
3065 ptr_void_type_node,
3068 /* Make sure we can place this into a register. */
3079 }
3080 }
3082 /* If we already know what the full type is, use it. */
3087 /* Get the type of the thing we are to point to and build a pointer
3088 to it. If it is a reference to an incomplete or private type with a
3089 full view that is a record, make a dummy type node and get the
3090 actual type later when we have verified it is safe. */
3096 {
3099 }
3101 /* Likewise if we are pointing to a record or array and we are to defer
3102 elaborating incomplete types. We do this since this access type
3103 may be the full view of some private type. Note that the
3104 unconstrained array case is handled above. */
3112 {
3115 }
3117 /* If this is a reference from a limited_with type back to our
3118 main unit and there's a Freeze_Node for it, either we have
3119 already processed the declaration and made the dummy type,
3120 in which case we just reuse the latter, or we have not yet,
3121 in which case we make the dummy type and it will be reused
3122 when the declaration is processed. In both cases, the pointer
3123 eventually created below will be automatically adjusted when
3124 the Freeze_Node is processed. Note that the unconstrained
3125 array case is handled above. */
3130 {
3133 }
3136 {
3137 gnu_type
3139 p_mode,
3142 }
3144 else
3147 /* It is possible that the above call to gnat_to_gnu_type resolved our
3148 type. If so, just return it. */
3150 {
3153 }
3155 /* If we have a GCC type for the designated type, possibly modify it
3156 if we are pointing only to constant objects and then make a pointer
3157 to it. Don't do this for unconstrained arrays. */
3159 {
3162 {
3163 gnu_desig_type
3164 = build_qualified_type
3168 /* Some extra processing is required if we are building a
3169 pointer to an incomplete type (in the GCC sense). We might
3170 have such a type if we just made a dummy, or directly out
3171 of the call to gnat_to_gnu_type above if we are processing
3172 an access type for a record component designating the
3173 record type itself. */
3175 {
3176 /* We must ensure that the pointer to variant we make will
3177 be processed by update_pointer_to when the initial type
3178 is completed. Pretend we made a dummy and let further
3179 processing act as usual. */
3182 /* We must ensure that update_pointer_to will not retrieve
3183 the dummy variant when building a properly qualified
3184 version of the complete type. We take advantage of the
3185 fact that get_qualified_type is requiring TYPE_NAMEs to
3186 match to influence build_qualified_type and then also
3187 update_pointer_to here. */
3190 }
3191 }
3193 gnu_type
3196 }
3198 /* If we are not defining this object and we made a dummy pointer,
3199 save our current definition, evaluate the actual type, and replace
3200 the tentative type we made with the actual one. If we are to defer
3201 actually looking up the actual type, make an entry in the
3202 deferred list. */
3205 {
3206 tree gnu_old_type
3212 gnu_type
3213 = build_pointer_type
3214 (TYPE_OBJECT_RECORD_TYPE
3224 /* Note that the call to gnat_to_gnu_type here might have
3225 updated gnu_old_type directly, in which case it is not a
3226 dummy type any more when we get into update_pointer_to.
3228 This may happen for instance when the designated type is a
3229 record type, because their elaboration starts with an
3230 initial node from make_dummy_type, which may yield the same
3231 node as the one we got.
3233 Besides, variants of this non-dummy type might have been
3234 created along the way. update_pointer_to is expected to
3235 properly take care of those situations. */
3238 else
3239 {
3247 }
3248 }
3249 }
3256 else
3257 {
3258 /* The runtime representation is the equivalent type. */
3261 }
3274 /* We treat this as identical to its base type; any constraint is
3275 meaningful only to the front end.
3277 The designated type must be elaborated as well, if it does
3278 not have its own freeze node. Designated (sub)types created
3279 for constrained components of records with discriminants are
3280 not frozen by the front end and thus not elaborated by gigi,
3281 because their use may appear before the base type is frozen,
3282 and because it is not clear that they are needed anywhere in
3283 Gigi. With the current model, there is no correct place where
3284 they could be elaborated. */
3291 {
3292 /* If we are not defining this entity, and we have incomplete
3293 entities being processed above us, make a dummy type and
3294 elaborate it later. */
3296 {
3299 tree gnu_ptr_type
3300 = build_pointer_type
3307 }
3310 Incomplete_Or_Private_Kind))
3311 ;
3312 else
3315 }
3320 /* Subprogram Entities
3322 The following access functions are defined for subprograms (functions
3323 or procedures):
3325 First_Formal The first formal parameter.
3326 Is_Imported Indicates that the subprogram has appeared in
3327 an INTERFACE or IMPORT pragma. For now we
3328 assume that the external language is C.
3329 Is_Inlined True if the subprogram is to be inlined.
3331 In addition for function subprograms we have:
3333 Etype Return type of the function.
3335 Each parameter is first checked by calling must_pass_by_ref on its
3336 type to determine if it is passed by reference. For parameters which
3337 are copied in, if they are Ada IN OUT or OUT parameters, their return
3338 value becomes part of a record which becomes the return type of the
3339 function (C function - note that this applies only to Ada procedures
3340 so there is no Ada return type). Additional code to store back the
3341 parameters will be generated on the caller side. This transformation
3342 is done here, not in the front-end.
3344 The intended result of the transformation can be seen from the
3345 equivalent source rewritings that follow:
3347 struct temp {int a,b};
3348 procedure P (A,B: IN OUT ...) is temp P (int A,B) {
3349 .. ..
3350 end P; return {A,B};
3351 }
3352 procedure call
3354 {
3355 temp t;
3356 P(X,Y); t = P(X,Y);
3357 X = t.a , Y = t.b;
3358 }
3360 For subprogram types we need to perform mainly the same conversions to
3361 GCC form that are needed for procedures and function declarations. The
3362 only difference is that at the end, we make a type declaration instead
3363 of a function declaration. */
3368 {
3369 /* The first GCC parameter declaration (a PARM_DECL node). The
3370 PARM_DECL nodes are chained through the TREE_CHAIN field, so this
3371 actually is the head of this parameter list. */
3373 /* The type returned by a function. If the subprogram is a procedure
3374 this type should be void_type_node. */
3376 /* List of fields in return type of procedure with copy in copy out
3377 parameters. */
3379 /* Non-null for subprograms containing parameters passed by copy in
3380 copy out (Ada IN OUT or OUT parameters not passed by reference),
3381 in which case it is the list of nodes used to specify the values of
3382 the in out/out parameters that are returned as a record upon
3383 procedure return. The TREE_PURPOSE of an element of this list is
3384 a field of the record and the TREE_VALUE is the PARM_DECL
3385 corresponding to that field. This list will be saved in the
3386 TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
3388 /* If an import pragma asks to map this subprogram to a GCC builtin,
3389 this is the builtin DECL node. */
3391 Entity_Id gnat_param;
3394 bool extern_flag
3406 /* A parameter may refer to this type, so defer completion
3407 of any incomplete types. */
3410 /* If the subprogram has an alias, it is probably inherited, so
3411 we can use the original one. If the original "subprogram"
3412 is actually an enumeration literal, it may be the first use
3413 of its type, so we must elaborate that type now. */
3415 {
3422 /* Elaborate any Itypes in the parameters of this entity. */
3430 }
3432 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
3433 corresponding DECL node.
3435 We still want the parameter associations to take place because the
3436 proper generation of calls depends on it (a GNAT parameter without
3437 a corresponding GCC tree has a very specific meaning), so we don't
3438 just break here. */
3442 /* ??? What if we don't find the builtin node above ? warn ? err ?
3443 In the current state we neither warn nor err, and calls will just
3444 be handled as for regular subprograms. */
3449 /* If this function returns by reference, make the actual
3450 return type of this function the pointer and mark the decl. */
3452 {
3455 }
3457 /* If the Mechanism is By_Reference, ensure the return type uses
3458 the machine's by-reference mechanism, which may not the same
3459 as above (e.g., it might be by passing a fake parameter). */
3462 {
3465 /* We expect this bit to be reset by gigi shortly, so can avoid a
3466 type node copy here. This actually also prevents troubles with
3467 the generation of debug information for the function, because
3468 we might have issued such info for this type already, and would
3469 be attaching a distinct type node to the function if we made a
3470 copy here. */
3471 }
3473 /* If we are supposed to return an unconstrained array,
3474 actually return a fat pointer and make a note of that. Return
3475 a pointer to an unconstrained record of variable size. */
3477 {
3480 }
3482 /* If the type requires a transient scope, the result is allocated
3483 on the secondary stack, so the result type of the function is
3484 just a pointer. */
3486 {
3489 }
3491 /* If the type is a padded type and the underlying type would not
3492 be passed by reference or this function has a foreign convention,
3493 return the underlying type. */
3501 /* If the return type is unconstrained, that means it must have a
3502 maximum size. We convert the function into a procedure and its
3503 caller will pass a pointer to an object of that maximum size as the
3504 first parameter when we call the function. */
3506 {
3508 gnu_param_list
3513 }
3515 /* If the return type has a size that overflows, we cannot have
3516 a function that returns that type. This usage doesn't make
3517 sense anyway, so give an error here. */
3521 {
3523 gnat_entity);
3529 }
3531 /* Look at all our parameters and get the type of
3532 each. While doing this, build a copy-out structure if
3533 we need one. */
3538 {
3548 /* Builtins are expanded inline and there is no real call sequence
3549 involved. so the type expected by the underlying expander is
3550 always the type of each argument "as is". */
3554 /* Otherwise, see if a Mechanism was supplied that forced this
3555 parameter to be passed one way or another. */
3559 ;
3567 {
3573 else
3575 }
3576 else
3579 /* If this is either a foreign function or if the
3580 underlying type won't be passed by reference, strip off
3581 possible padding type. */
3587 && (req_by_copy
3589 (TYPE_FIELDS
3593 /* If this is an IN parameter it is read-only, so make a variant
3594 of the type that is read-only.
3596 ??? However, if this is an unconstrained array, that type can
3597 be very complex. So skip it for now. Likewise for any other
3598 self-referential type. */
3602 gnu_param_type
3607 /* For foreign conventions, pass arrays as a pointer to the
3608 underlying type. First check for unconstrained array and get
3609 the underlying array. Then get the component type and build
3610 a pointer to it. */
3613 gnu_param_type
3618 gnu_param_type
3619 = build_pointer_type
3624 && !req_by_copy
3626 {
3627 /* Strip off any multi-dimensional entries, then strip
3628 off the last array to get the component type. */
3637 gnu_param_type
3643 }
3645 /* Fat pointers are passed as thin pointers for foreign
3646 conventions. */
3649 gnu_param_type
3653 /* If we must pass or were requested to pass by reference, do so.
3654 If we were requested to pass by copy, do so.
3655 Otherwise, for foreign conventions, pass all in out parameters
3656 or aggregates by reference. For COBOL and Fortran, pass
3657 all integer and FP types that way too. For Convention Ada,
3658 use the standard Ada default. */
3660 || (!req_by_copy
3670 /* For convention Ada, see if we pass by reference
3671 by default. */
3674 {
3677 }
3685 /* If this is an OUT parameter that isn't passed by reference
3686 and isn't a pointer or aggregate, we don't make a PARM_DECL
3687 for it. Instead, it will be a VAR_DECL created when we process
3688 the procedure. For the special parameter of Valued_Procedure,
3689 never pass it in.
3691 An exception is made to cover the RM-6.4.1 rule requiring "by
3692 copy" out parameters with discriminants or implicit initial
3693 values to be handled like in out parameters. These type are
3694 normally built as aggregates, and hence passed by reference,
3695 except for some packed arrays which end up encoded in special
3696 integer types.
3698 The exception we need to make is then for packed arrays of
3699 records with discriminants or implicit initial values. We have
3700 no light/easy way to check for the latter case, so we merely
3701 check for packed arrays of records. This may lead to useless
3702 copy-in operations, but in very rare cases only, as these would
3703 be exceptions in a set of already exceptional situations. */
3706 || (!by_descr_p
3714 else
3715 {
3716 gnu_param
3717 = create_param_decl
3719 by_ref_p || by_component_ptr_p
3733 /* If a parameter is a pointer, this function may modify
3734 memory through it and thus shouldn't be considered
3735 a pure function. Also, the memory may be modified
3736 between two calls, so they can't be CSE'ed. The latter
3737 case also handles by-ref parameters. */
3741 }
3744 {
3746 {
3751 }
3760 gnu_return_list);
3761 }
3762 }
3764 /* Do not compute record for out parameters if subprogram is
3765 stubbed since structures are incomplete for the back-end. */
3768 {
3769 /* If all types are not complete, defer emission of debug
3770 information for this record types. Otherwise, we risk emitting
3771 debug information for a dummy type contained in the fields
3772 for that record. */
3777 {
3779 defer_debug_level++;
3781 defer_debug_incomplete_list
3783 defer_debug_incomplete_list);
3784 }
3785 }
3787 /* If we have a CICO list but it has only one entry, we convert
3788 this function into a function that simply returns that one
3789 object. */
3794 {
3804 }
3806 /* Both lists ware built in reverse. */
3810 gnu_type
3813 returns_by_ref,
3815 returns_by_target_ptr);
3817 /* A subprogram (something that doesn't return anything) shouldn't
3818 be considered Pure since there would be no reason for such a
3819 subprogram. Note that procedures with Out (or In Out) parameters
3820 have already been converted into a function with a return type. */
3824 /* The semantics of "pure" in Ada essentially matches that of "const"
3825 in the back-end. In particular, both properties are orthogonal to
3826 the "nothrow" property. But this is true only if the EH circuitry
3827 is explicit in the internal representation of the back-end. If we
3828 are to completely hide the EH circuitry from it, we need to declare
3829 that calls to pure Ada subprograms that can throw have side effects
3830 since they can trigger an "abnormal" transfer of control flow; thus
3831 they can be neither "const" nor "pure" in the back-end sense. */
3832 gnu_type
3841 /* If we have a builtin decl for that function, check the signatures
3842 compatibilities. If the signatures are compatible, use the builtin
3843 decl. If they are not, we expect the checker predicate to have
3844 posted the appropriate errors, and just continue with what we have
3845 so far. */
3847 {
3851 {
3855 }
3856 }
3858 /* If there was no specified Interface_Name and the external and
3859 internal names of the subprogram are the same, only use the
3860 internal name to allow disambiguation of nested subprograms. */
3864 /* If we are defining the subprogram and it has an Address clause
3865 we must get the address expression from the saved GCC tree for the
3866 subprogram if it has a Freeze_Node. Otherwise, we elaborate
3867 the address expression here since the front-end has guaranteed
3868 in that case that the elaboration has no effects. If there is
3869 an Address clause and we are not defining the object, just
3870 make it a constant. */
3872 {
3876 gnu_address
3887 gnu_decl
3892 }
3898 gnat_entity);
3899 else
3900 {
3905 gnat_entity);
3909 }
3910 }
3921 {
3922 /* Get the "full view" of this entity. If this is an incomplete
3923 entity from a limited with, treat its non-limited view as the
3924 full view. Otherwise, use either the full view or the underlying
3925 full view, whichever is present. This is used in all the tests
3926 below. */
3927 Entity_Id full_view
3935 /* If this is an incomplete type with no full view, it must be a Taft
3936 Amendment type, in which case we return a dummy type. Otherwise,
3937 just get the type from its Etype. */
3939 {
3942 else
3943 {
3947 }
3949 }
3951 /* If we already made a type for the full view, reuse it. */
3953 {
3956 }
3958 /* Otherwise, if we are not defining the type now, get the type
3959 from the full view. But always get the type from the full view
3960 for define on use types, since otherwise we won't see them! */
3966 {
3970 }
3972 /* For incomplete types, make a dummy type entry which will be
3973 replaced later. */
3976 /* Save this type as the full declaration's type so we can do any
3977 needed updates when we see it. */
3983 }
3985 /* Simple class_wide types are always viewed as their root_type
3986 by Gigi unless an Equivalent_Type is specified. */
3990 else
4002 else
4014 /* Nothing at all to do here, so just return an ERROR_MARK and claim
4015 we've already saved it, so we don't try to. */
4022 }
4024 /* If we had a case where we evaluated another type and it might have
4025 defined this one, handle it here. */
4027 {
4030 }
4032 /* If we are processing a type and there is either no decl for it or
4033 we just made one, do some common processing for the type, such as
4034 handling alignment and possible padding. */
4037 {
4045 /* ??? Don't set the size for a String_Literal since it is either
4046 confirming or we don't handle it properly (if the low bound is
4047 non-constant). */
4053 /* If a size was specified, see if we can make a new type of that size
4054 by rearranging the type, for example from a fat to a thin pointer. */
4056 {
4057 gnu_type
4064 }
4066 /* If the alignment hasn't already been processed and this is
4067 not an unconstrained array, see if an alignment is specified.
4068 If not, we pick a default alignment for atomic objects. */
4070 ;
4084 /* See if we need to pad the type. If we did, and made a record,
4085 the name of the new type may be changed. So get it back for
4086 us when we make the new TYPE_DECL below. */
4091 {
4095 }
4099 /* If we are at global level, GCC will have applied variable_size to
4100 the type, but that won't have done anything. So, if it's not
4101 a constant or self-referential, call elaborate_expression_1 to
4102 make a variable for the size rather than calculating it each time.
4103 Handle both the RM size and the actual size. */
4108 {
4112 {
4119 }
4120 else
4121 {
4128 /* ??? For now, store the size as a multiple of the alignment
4129 in bytes so that we can see the alignment from the tree. */
4131 = build_binary_op
4133 elaborate_expression_1
4144 SET_TYPE_ADA_SIZE
4147 gnat_entity,
4151 }
4152 }
4154 /* If this is a record type or subtype, call elaborate_expression_1 on
4155 any field position. Do this for both global and local types.
4156 Skip any fields that we haven't made trees for to avoid problems with
4157 class wide types. */
4162 {
4165 /* ??? Unfortunately, GCC needs to be able to prove the
4166 alignment of this offset and if it's a variable, it can't.
4167 In GCC 3.4, we'll use DECL_OFFSET_ALIGN in some way, but
4168 right now, we have to put in an explicit multiply and
4169 divide by that value. */
4172 = build_binary_op
4174 elaborate_expression_1
4183 }
4187 | (TYPE_QUAL_VOLATILE
4200 else
4202 }
4205 {
4208 /* Back-annotate the Alignment of the type if not already in the
4209 tree. Likewise for sizes. */
4215 {
4216 /* If the size is self-referential, we annotate the maximum
4217 value of that size. */
4226 {
4227 /* In this mode the tag and the parent components are not
4228 generated by the front-end, so the sizes must be adjusted
4229 explicitly now. */
4235 {
4236 size_offset
4240 }
4241 else
4249 }
4250 }
4254 }
4264 /* If we haven't already, associate the ..._DECL node that we just made with
4265 the input GNAT entity node. */
4269 /* If this is an enumeral or floating-point type, we were not able to set
4270 the bounds since they refer to the type. These bounds are always static.
4272 For enumeration types, also write debugging information and declare the
4273 enumeration literal table, if needed. */
4277 {
4280 /* If this is a padded type, we need to use the underlying type. */
4285 /* If this is a floating point type and we haven't set a floating
4286 point type yet, use this in the evaluation of the bounds. */
4296 {
4299 /* Since this has both a typedef and a tag, avoid outputting
4300 the name twice. */
4303 }
4304 }
4306 /* If we deferred processing of incomplete types, re-enable it. If there
4307 were no other disables and we have some to process, do so. */
4309 {
4315 {
4322 }
4323 }
4325 /* If we are not defining this type, see if it's in the incomplete list.
4326 If so, handle that list entry now. */
4328 {
4333 {
4337 }
4338 }
4340 /* If there are no incomplete types and we have deferred emission
4341 of debug information, check whether we have finished defining
4342 all nested records.
4343 If so, handle the list now. */
4346 defer_debug_level--;
4349 && !defer_incomplete_level
4351 {
4357 {
4360 }
4363 }
4366 force_global--;
4375 }
4377 /* Similar, but if the returned value is a COMPONENT_REF, return the
4378 FIELD_DECL. */
4380 tree
4382 {
4389 }
4391 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
4393 static
4395 {
4402 return
4404 }
4405 \f
4406 /* Given GNAT_ENTITY, elaborate all expressions that are required to
4407 be elaborated at the point of its definition, but do nothing else. */
4409 void
4411 {
4413 {
4420 {
4424 /* ??? Tests for avoiding static constraint error expression
4425 is needed until the front stops generating bogus conversions
4426 on bounds of real types. */
4435 }
4438 {
4442 /* If this is a record extension, go a level further to find the
4443 record definition. */
4446 }
4456 {
4457 Node_Id gnat_discriminant_expr;
4458 Entity_Id gnat_field;
4461 gnat_discriminant_expr
4466 /* ??? For now, ignore access discriminants. */
4469 gnat_entity,
4471 }
4474 }
4475 }
4476 \f
4477 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
4478 any entities on its entity chain similarly. */
4480 void
4482 {
4483 Entity_Id gnat_sub_entity;
4486 /* If this has an entity list, process all in the list. */
4503 /* Now clear this if it has been defined, but only do so if it isn't
4504 a subprogram or parameter. We could refine this, but it isn't
4505 worth it. If this is statically allocated, it is supposed to
4506 hang around out of cope. */
4509 {
4512 }
4513 }
4514 \f
4515 /* Set the alias set of GNU_NEW_TYPE to be that of GNU_OLD_TYPE. If this
4516 is a multi-dimensional array type, do this recursively. */
4518 static void
4520 {
4521 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
4522 of a one-dimensional array, since the padding has the same alias set
4523 as the field type, but if it's a multi-dimensional array, we need to
4524 see the inner types. */
4530 /* We need to be careful here in case GNU_OLD_TYPE is an unconstrained
4531 array. In that case, it doesn't have the same shape as GNU_NEW_TYPE,
4532 so we need to go down to what does. */
4534 gnu_old_type
4544 }
4545 \f
4546 /* Return a TREE_LIST describing the substitutions needed to reflect
4547 discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
4548 them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
4549 of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
4550 gives the tree for the discriminant and TREE_VALUES is the replacement
4551 value. They are in the form of operands to substitute_in_expr.
4552 DEFINITION is as in gnat_to_gnu_entity. */
4554 static tree
4557 {
4558 Entity_Id gnat_discrim;
4559 Node_Id gnat_value;
4570 /* Ignore access discriminants. */
4573 elaborate_expression
4577 gnu_list);
4580 }
4581 \f
4582 /* Return true if the size represented by GNU_SIZE can be handled by an
4583 allocation. If STATIC_P is true, consider only what can be done with a
4584 static allocation. */
4586 static bool
4588 {
4589 HOST_WIDE_INT our_size;
4591 /* If this is not a static allocation, the only case we want to forbid
4592 is an overflowing size. That will be converted into a raise a
4593 Storage_Error. */
4598 /* Otherwise, we need to deal with both variable sizes and constant
4599 sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
4600 since assemblers may not like very large sizes. */
4606 }
4607 \f
4608 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
4610 static void
4612 {
4613 Node_Id gnat_temp;
4618 {
4628 {
4630 (gnat_to_gnu
4637 (gnat_to_gnu
4638 (Expression
4641 }
4644 {
4671 }
4678 /* If we have an argument specified together with an attribute name,
4679 make it a single TREE_VALUE entry in a list of arguments, as GCC
4680 expects it. */
4683 else
4686 attr->error_point
4690 }
4691 }
4692 \f
4693 /* Get the unpadded version of a GNAT type. */
4695 tree
4697 {
4704 }
4705 \f
4706 /* Called when we need to protect a variable object using a save_expr. */
4708 tree
4710 {
4717 {
4725 }
4726 else
4728 }
4729 \f
4730 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
4731 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
4732 return the GCC tree to use for that expression. GNU_NAME is the
4733 qualification to use if an external name is appropriate and DEFINITION is
4734 nonzero if this is a definition of GNAT_ENTITY. If NEED_VALUE is nonzero,
4735 we need a result. Otherwise, we are just elaborating this for
4736 side-effects. If NEED_DEBUG is nonzero we need the symbol for debugging
4737 purposes even if it isn't needed for code generation. */
4739 static tree
4743 {
4744 tree gnu_expr;
4746 /* If we already elaborated this expression (e.g., it was involved
4747 in the definition of a private type), use the old value. */
4751 /* If we don't need a value and this is static or a discriminant, we
4752 don't need to do anything. */
4759 /* Otherwise, convert this tree to its GCC equivalent. */
4760 gnu_expr
4764 /* Save the expression in case we try to elaborate this entity again. Since
4765 this is not a DECL, don't check it. Don't save if it's a discriminant. */
4770 }
4772 /* Similar, but take a GNU expression. */
4774 static tree
4778 {
4780 /* Strip any conversions to see if the expression is a readonly variable.
4781 ??? This really should remain readonly, but we have to think about
4782 the typing of the tree here. */
4787 /* In most cases, we won't see a naked FIELD_DECL here because a
4788 discriminant reference will have been replaced with a COMPONENT_REF
4789 when the type is being elaborated. However, there are some cases
4790 involving child types where we will. So convert it to a COMPONENT_REF
4791 here. We have to hope it will be at the highest level of the
4792 expression in these cases. */
4798 /* If GNU_EXPR is neither a placeholder nor a constant, nor a variable
4799 that is a constant, make a variable that is initialized to contain the
4800 bound when the package containing the definition is elaborated. If
4801 this entity is defined at top level and a bound or discriminant value
4802 isn't a constant or a reference to a discriminant, replace the bound
4803 by the variable; otherwise use a SAVE_EXPR if needed. Note that we
4804 rely here on the fact that an expression cannot contain both the
4805 discriminant and some other variable. */
4813 /* If this is a static expression or contains a discriminant, we don't
4814 need the variable for debugging (and can't elaborate anyway if a
4815 discriminant). */
4821 /* Now create the variable if we need it. */
4823 gnu_decl
4830 /* We only need to use this variable if we are in global context since GCC
4831 can do the right thing in the local case. */
4836 else
4838 }
4839 \f
4840 /* Create a record type that contains a field of TYPE with a starting bit
4841 position so that it is aligned to ALIGN bits and is SIZE bytes long. */
4843 tree
4845 {
4850 place));
4859 /* The bit position is obtained by "and"ing the alignment minus 1
4860 with the two's complement of the address and multiplying
4861 by the number of bits per unit. Do all this in sizetype. */
4866 size_addr_place),
4869 bitsize_unit_node);
4871 /* Create the field, with -1 as the 'addressable' indication to avoid the
4872 creation of a bitfield. We don't need one, it would have damaging
4873 consequences on the alignment computation, and create_field_decl would
4874 make one without this special argument, for instance because of the
4875 complex position expression. */
4884 bitsize_unit_node),
4890 }
4891 \f
4892 /* TYPE is a RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE, with BLKmode that's
4893 being used as the field type of a packed record. See if we can rewrite it
4894 as a record that has a non-BLKmode type, which we can pack tighter. If so,
4895 return the new type. If not, return the original type. */
4897 static tree
4899 {
4902 tree old_field;
4904 /* Copy the name and flags from the old type to that of the new and set
4905 the alignment to try for an integral type. For QUAL_UNION_TYPE,
4906 also copy the size. */
4915 {
4918 }
4924 /* Now copy the fields, keeping the position and size. */
4927 {
4929 tree new_field;
4945 SET_DECL_ORIGINAL_FIELD
4954 }
4959 }
4960 \f
4961 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
4962 if needed. We have already verified that SIZE and TYPE are large enough.
4964 GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
4965 to issue a warning.
4967 IS_USER_TYPE is true if we must be sure we complete the original type.
4969 DEFINITION is true if this type is being defined.
4971 SAME_RM_SIZE is true if the RM_Size of the resulting type is to be
4972 set to its TYPE_SIZE; otherwise, it's set to the RM_Size of the original
4973 type. */
4975 tree
4979 {
4981 tree record;
4982 tree field;
4984 /* If TYPE is a padded type, see if it agrees with any size and alignment
4985 we were given. If so, return the original type. Otherwise, strip
4986 off the padding, since we will either be returning the inner type
4987 or repadding it. If no size or alignment is specified, use that of
4988 the original padded type. */
4991 {
5008 }
5010 /* If the size is either not being changed or is being made smaller (which
5011 is not done here (and is only valid for bitfields anyway), show the size
5012 isn't changing. Likewise, clear the alignment if it isn't being
5013 changed. Then return if we aren't doing anything. */
5027 /* We used to modify the record in place in some cases, but that could
5028 generate incorrect debugging information. So make a new record
5029 type and name. */
5035 /* If we were making a type, complete the original type and give it a
5036 name. */
5043 gnat_entity);
5045 /* If we are changing the alignment and the input type is a record with
5046 BLKmode and a small constant size, try to make a form that has an
5047 integral mode. That might allow this record to have an integral mode,
5048 which will be much more efficient. There is no point in doing this if a
5049 size is specified unless it is also smaller than the biggest alignment
5050 and it is incorrect to do this if the size of the original type is not a
5051 multiple of the alignment. */
5057 && (!size
5079 /* Keep the RM_Size of the padded record as that of the old record
5080 if requested. */
5083 /* Unless debugging information isn't being written for the input type,
5084 write a record that shows what we are a subtype of and also make a
5085 variable that indicates our size, if variable. */
5089 {
5110 }
5117 /* If the size was widened explicitly, maybe give a warning. */
5123 {
5136 /* Generate message only for entities that come from source, since
5137 if we have an entity created by expansion, the message will be
5138 generated for some other corresponding source entity. */
5141 gnat_entity,
5148 }
5151 }
5152 \f
5153 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
5154 the value passed against the list of choices. */
5156 tree
5158 {
5159 Node_Id choice;
5160 Node_Id gnat_temp;
5165 {
5167 {
5172 /* There's no good type to use here, so we might as well use
5173 integer_type_node. */
5174 this_test
5188 this_test
5198 /* This represents either a subtype range, an enumeration
5199 literal, or a constant Ekind says which. If an enumeration
5200 literal or constant, fall through to the next case. */
5203 {
5209 this_test
5216 }
5217 /* ... fall through ... */
5222 single);
5231 }
5235 }
5238 }
5239 \f
5240 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
5241 placed in GNU_RECORD_TYPE.
5243 PACKED is 1 if the enclosing record is packed and -1 if the enclosing
5244 record has a Component_Alignment of Storage_Unit.
5246 DEFINITION is true if this field is for a record being defined. */
5248 static tree
5251 {
5256 tree gnu_field;
5257 bool needs_strict_alignment
5261 /* If this field requires strict alignment or contains an item of
5262 variable sized, pretend it isn't packed. */
5266 /* For packed records, this is one of the few occasions on which we use
5267 the official RM size for discrete or fixed-point components, instead
5268 of the normal GNAT size stored in Esize. See description in Einfo:
5269 "Handling of Type'Size Values" for further details. */
5279 /* If we have a specified size that's smaller than that of the field type,
5280 or a position is specified, and the field type is also a record that's
5281 BLKmode and with a small constant size, see if we can get an integral
5282 mode form of the type when appropriate. If we can, show a size was
5283 specified for the field if there wasn't one already, so we know to make
5284 this a bitfield and avoid making things wider.
5286 Doing this is first useful if the record is packed because we can then
5287 place the field at a non-byte-aligned position and so achieve tighter
5288 packing.
5290 This is in addition *required* if the field shares a byte with another
5291 field and the front-end lets the back-end handle the references, because
5292 GCC does not handle BLKmode bitfields properly.
5294 We avoid the transformation if it is not required or potentially useful,
5295 as it might entail an increase of the field's alignment and have ripple
5296 effects on the outer record type. A typical case is a field known to be
5297 byte aligned and not to share a byte with another field.
5299 Besides, we don't even look the possibility of a transformation in cases
5300 known to be in error already, for instance when an invalid size results
5301 from a component clause. */
5308 || (gnu_size
5311 {
5312 /* See what the alternate type and size would be. */
5315 bool has_byte_aligned_clause
5320 /* Compute whether we should avoid the substitution. */
5322 /* There is no point substituting if there is no change. */
5324 ||
5325 /* ... nor when the field is known to be byte aligned and not to
5326 share a byte with another field. */
5327 (has_byte_aligned_clause
5329 ||
5330 /* The size of an aliased field must be an exact multiple of the
5331 type's alignment, which the substitution might increase. Reject
5332 substitutions that would so invalidate a component clause when the
5333 specified position is byte aligned, as the change would have no
5334 real benefit from the packing standpoint anyway. */
5336 && has_byte_aligned_clause
5338 );
5340 /* Substitute unless told otherwise. */
5342 {
5347 }
5348 }
5350 /* If we are packing the record and the field is BLKmode, round the
5351 size up to a byte boundary. */
5356 {
5361 /* Ensure the position does not overlap with the parent subtype,
5362 if there is one. */
5364 {
5365 tree gnu_parent
5371 {
5372 post_error_ne_tree
5376 }
5377 }
5379 /* If this field needs strict alignment, ensure the record is
5380 sufficiently aligned and that that position and size are
5381 consistent with the alignment. */
5383 {
5390 /* If Atomic, the size must match exactly that of the field. */
5393 {
5394 post_error_ne_tree
5400 }
5402 /* If Aliased, the size must match exactly the rounded size. We
5403 used to be more accommodating here and accept greater sizes, but
5404 fully supporting this case on big-endian platforms would require
5405 switching to a more involved layout for the field. */
5407 && gnu_size
5409 {
5410 post_error_ne_tree
5413 gnu_rounded_size);
5415 }
5420 {
5422 post_error_ne_num
5428 post_error_ne_num
5434 post_error_ne_num
5438 else
5442 }
5443 }
5447 }
5449 /* If the record has rep clauses and this is the tag field, make a rep
5450 clause for it as well. */
5453 {
5456 }
5458 /* We need to make the size the maximum for the type if it is
5459 self-referential and an unconstrained type. In that case, we can't
5460 pack the field since we can't make a copy to align it. */
5462 && !gnu_size
5465 {
5468 }
5470 /* If no size is specified (or if there was an error), don't specify a
5471 position. */
5474 else
5475 {
5476 /* If the field's type is justified modular, we would need to remove
5477 the wrapper to (better) meet the layout requirements. However we
5478 can do so only if the field is not aliased to preserve the unique
5479 layout and if the prescribed size is not greater than that of the
5480 packed array to preserve the justification. */
5488 gnu_field_type
5493 }
5498 /* Now create the decl for the field. */
5510 }
5511 \f
5512 /* Return true if TYPE is a type with variable size, a padding type with a
5513 field of variable size or is a record that has a field such a field. */
5515 static bool
5517 {
5518 tree field;
5520 /* We need not be concerned about this at all if we don't have
5521 strict alignment. */
5539 }
5540 \f
5541 /* Return a GCC tree for a record type given a GNAT Component_List and a chain
5542 of GCC trees for fields that are in the record and have already been
5543 processed. When called from gnat_to_gnu_entity during the processing of a
5544 record type definition, the GCC nodes for the discriminants will be on
5545 the chain. The other calls to this function are recursive calls from
5546 itself for the Component_List of a variant and the chain is empty.
5548 PACKED is 1 if this is for a record with "pragma pack" and -1 is this is
5549 for a record type with "pragma component_alignment (storage_unit)".
5551 DEFINITION is true if we are defining this record.
5553 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
5554 with a rep clause is to be added. If it is nonzero, that is all that
5555 should be done with such fields.
5557 CANCEL_ALIGNMENT, if true, means the alignment should be zeroed before
5558 laying out the record. This means the alignment only serves to force fields
5559 to be bitfields, but not require the record to be that aligned. This is
5560 used for variants.
5562 ALL_REP, if true, means a rep clause was found for all the fields. This
5563 simplifies the logic since we know we're not in the mixed case.
5565 DEFER_DEBUG, if true, means that the debugging routines should not be
5566 called when finishing constructing the record type.
5568 UNCHECKED_UNION, if tree, means that we are building a type for a record
5569 with a Pragma Unchecked_Union.
5571 The processing of the component list fills in the chain with all of the
5572 fields of the record and then the record type is finished. */
5574 static void
5579 {
5580 Node_Id component_decl;
5581 Entity_Id gnat_field;
5582 Node_Id variant_part;
5588 /* For each variable within each component declaration create a GCC field
5589 and add it to the list, skipping any pragmas in the list. */
5595 {
5600 else
5601 {
5605 /* If this is the _Tag field, put it before any discriminants,
5606 instead of after them as is the case for all other fields.
5607 Ignore field of void type if only annotating. */
5610 else
5611 {
5614 }
5615 }
5618 }
5620 /* At the end of the component list there may be a variant part. */
5623 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
5624 mutually exclusive and should go in the same memory. To do this we need
5625 to treat each variant as a record whose elements are created from the
5626 component list for the variant. So here we create the records from the
5627 lists for the variants and put them all into the QUAL_UNION_TYPE.
5628 If this is an Unchecked_Union, we make a UNION_TYPE instead or
5629 use GNU_RECORD_TYPE if there are no fields so far. */
5631 {
5633 Node_Id variant;
5635 tree gnu_var_name
5639 tree gnu_union_type;
5640 tree gnu_union_name;
5641 tree gnu_union_field;
5652 else
5653 {
5655 gnu_union_type
5660 }
5665 {
5667 tree gnu_inner_name;
5668 tree gnu_qual;
5676 /* Set the alignment of the inner type in case we need to make
5677 inner objects into bitfields, but then clear it out
5678 so the record actually gets only the alignment required. */
5682 /* Similarly, if the outer record has a size specified and all fields
5683 have record rep clauses, we can propagate the size into the
5684 variant part. */
5686 {
5690 }
5692 /* Create the record for the variant. Note that we defer emitting
5693 debug info for it until after we are sure to actually use it. */
5704 /* If this is an Unchecked_Union and we have exactly one field,
5705 use that field here. */
5709 else
5710 {
5711 /* Emit debug info for the record. We used to throw away
5712 empty records but we no longer do that because we need
5713 them to generate complete debug info for the variant;
5714 otherwise, the union type definition will be lacking
5715 the fields associated with these empty variants. */
5720 (all_rep_and_size
5723 (all_rep_and_size
5731 }
5735 }
5737 /* Only make the QUAL_UNION_TYPE if there are any non-empty variants. */
5739 {
5741 {
5745 }
5750 /* If GNU_UNION_TYPE is our record type, it means we must have an
5751 Unchecked_Union with no fields. Verify that and, if so, just
5752 return. */
5754 {
5757 }
5759 gnu_union_field
5761 packed,
5768 }
5769 }
5771 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses. If they
5772 do, pull them out and put them into GNU_OUR_REP_LIST. We have to do this
5773 in a separate pass since we want to handle the discriminants but can't
5774 play with them until we've used them in debugging data above.
5776 ??? Note: if we then reorder them, debugging information will be wrong,
5777 but there's nothing that can be done about this at the moment. */
5780 {
5782 {
5787 else
5793 }
5794 else
5795 {
5798 }
5799 }
5801 /* If we have any items in our rep'ed field list, it is not the case that all
5802 the fields in the record have rep clauses, and P_REP_LIST is nonzero,
5803 set it and ignore the items. */
5807 {
5808 /* Otherwise, sort the fields by bit position and put them into their
5809 own record if we have any fields without rep clauses. */
5810 tree gnu_rep_type
5822 /* Put the fields in the list in order of increasing position, which
5823 means we start from the end. */
5826 {
5830 }
5833 {
5839 }
5840 else
5841 {
5844 }
5845 }
5852 }
5853 \f
5854 /* Called via qsort from the above. Returns -1, 1, depending on the
5855 bit positions and ordinals of the two fields. Use DECL_UID to ensure
5856 a stable sort. */
5858 static int
5860 {
5868 else
5870 }
5871 \f
5872 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
5873 placed into an Esize, Component_Bit_Offset, or Component_Size value
5874 in the GNAT tree. */
5876 static Uint
5878 {
5880 TCode tcode;
5886 /* See if we've already saved the value for this node. */
5888 {
5899 }
5901 /* If we do not return inside this switch, TCODE will be set to the
5902 code to use for a Create_Node operand and LEN (set above) will be
5903 the number of recursive calls for us to make. */
5906 {
5911 /* This may have come from a conversion from some smaller type,
5912 so ensure this is in bitsizetype. */
5915 /* For negative values, use NEGATE_EXPR of the supplied value. */
5917 {
5918 /* The ridiculous code below is to handle the case of the largest
5919 negative integer. */
5922 tree temp;
5925 {
5926 negative_size
5929 bitsize_one_node));
5931 }
5938 }
5945 /* This peculiar test is to make sure that the size fits in an int
5946 on machines where HOST_WIDE_INT is not "int". */
5949 else
5953 /* The only case we handle here is a simple discriminant reference. */
5961 else
5967 /* Now just list the operations we handle. */
5999 }
6001 /* Now get each of the operands that's relevant for this code. If any
6002 cannot be expressed as a repinfo node, say we can't. */
6007 {
6011 }
6015 /* Save the result in the cache. */
6017 {
6021 }
6024 }
6026 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding
6027 GCC type, set Component_Bit_Offset and Esize to the position and size
6028 used by Gigi. */
6030 static void
6032 {
6033 tree gnu_list;
6034 tree gnu_entry;
6035 Entity_Id gnat_field;
6037 /* We operate by first making a list of all fields and their positions
6038 (we can get the sizes easily at any time) by a recursive call
6039 and then update all the sizes into the tree. */
6042 BIGGEST_ALIGNMENT);
6049 {
6053 gnu_list);
6056 {
6058 {
6059 /* In this mode the tag and parent components have not been
6060 generated, so we add the appropriate offset to each
6061 component. For a component appearing in the current
6062 extension, the offset is the size of the parent. */
6065 parent_offset
6067 bitsizetype);
6068 else
6070 }
6072 Set_Component_Bit_Offset
6074 annotate_value
6079 parent_offset)));
6083 }
6086 {
6087 /* If there is no gnu_entry, this is an inherited component whose
6088 position is the same as in the parent type. */
6089 Set_Component_Bit_Offset
6094 }
6095 }
6096 }
6098 /* Scan all fields in GNU_TYPE and build entries where TREE_PURPOSE is the
6099 FIELD_DECL and TREE_VALUE a TREE_LIST with TREE_PURPOSE being the byte
6100 position and TREE_VALUE being a TREE_LIST with TREE_PURPOSE the value to be
6101 placed into DECL_OFFSET_ALIGN and TREE_VALUE the bit position. GNU_POS is
6102 to be added to the position, GNU_BITPOS to the bit position, OFFSET_ALIGN is
6103 the present value of DECL_OFFSET_ALIGN and GNU_LIST is a list of the entries
6104 so far. */
6106 static tree
6109 {
6110 tree gnu_field;
6115 {
6120 unsigned int our_offset_align
6123 gnu_result
6128 NULL_TREE),
6129 gnu_result);
6132 gnu_result
6135 our_offset_align);
6136 }
6139 }
6140 \f
6141 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
6142 corresponding to GNAT_OBJECT. If size is valid, return a tree corresponding
6143 to its value. Otherwise return 0. KIND is VAR_DECL is we are specifying
6144 the size for an object, TYPE_DECL for the size of a type, and FIELD_DECL
6145 for the size of a field. COMPONENT_P is true if we are being called
6146 to process the Component_Size of GNAT_OBJECT. This is used for error
6147 message handling and to indicate to use the object size of GNU_TYPE.
6148 ZERO_OK is true if a size of zero is permitted; if ZERO_OK is false,
6149 it means that a size of zero should be treated as an unspecified size. */
6151 static tree
6154 {
6155 Node_Id gnat_error_node;
6156 tree type_size
6158 tree size;
6160 /* Find the node to use for errors. */
6167 else
6170 /* Return 0 if no size was specified, either because Esize was not Present or
6171 the specified size was zero. */
6175 /* Get the size as a tree. Give an error if a size was specified, but cannot
6176 be represented as in sizetype. */
6179 {
6184 }
6186 /* Ignore a negative size since that corresponds to our back-annotation.
6187 Also ignore a zero size unless a size clause exists. */
6191 /* The size of objects is always a multiple of a byte. */
6194 {
6198 else
6202 }
6204 /* If this is an integral type or a packed array type, the front-end has
6205 verified the size, so we need not do it here (which would entail
6206 checking against the bounds). However, if this is an aliased object, it
6207 may not be smaller than the type of the object. */
6212 /* If the object is a record that contains a template, add the size of
6213 the template to the specified size. */
6218 /* Modify the size of the type to be that of the maximum size if it has a
6219 discriminant or the size of a thin pointer if this is a fat pointer. */
6225 /* If this is an access type, the minimum size is that given by the smallest
6226 integral mode that's valid for pointers. */
6228 {
6234 ;
6237 }
6239 /* If the size of the object is a constant, the new size must not be
6240 smaller. */
6244 {
6246 post_error_ne_tree
6249 else
6256 post_error_ne_tree_2
6266 }
6269 }
6270 \f
6271 /* Similarly, but both validate and process a value of RM_Size. This
6272 routine is only called for types. */
6274 static void
6276 {
6277 /* Only give an error if a Value_Size clause was explicitly given.
6278 Otherwise, we'd be duplicating an error on the Size clause. */
6279 Node_Id gnat_attr_node
6282 tree size;
6284 /* Get the size as a tree. Do nothing if none was specified, either
6285 because RM_Size was not Present or if the specified size was zero.
6286 Give an error if a size was specified, but cannot be represented as
6287 in sizetype. */
6293 {
6296 gnat_entity);
6299 }
6301 /* Ignore a negative size since that corresponds to our back-annotation.
6302 Also ignore a zero size unless a size clause exists, a Value_Size
6303 clause exists, or this is an integer type, in which case the
6304 front end will have always set it. */
6311 /* If the old size is self-referential, get the maximum size. */
6315 /* If the size of the object is a constant, the new size must not be
6316 smaller (the front end checks this for scalar types). */
6321 {
6323 post_error_ne_tree
6328 }
6330 /* Otherwise, set the RM_Size. */
6341 }
6342 \f
6343 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
6344 If TYPE is the best type, return it. Otherwise, make a new type. We
6345 only support new integral and pointer types. BIASED_P is nonzero if
6346 we are making a biased type. */
6348 static tree
6350 {
6351 tree new_type;
6355 /* If size indicates an error, just return TYPE to avoid propagating the
6356 error. Likewise if it's too large to represent. */
6362 {
6365 /* Only do something if the type is not already the proper size and is
6366 not a packed array type. */
6378 new_type
6390 /* Do something if this is a fat pointer, in which case we
6391 may need to return the thin pointer. */
6393 return
6394 build_pointer_type
6399 /* Only do something if this is a thin pointer, in which case we
6400 may need to return the fat pointer. */
6402 return
6409 }
6412 }
6413 \f
6414 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
6415 a type or object whose present alignment is ALIGN. If this alignment is
6416 valid, return it. Otherwise, give an error and return ALIGN. */
6418 static unsigned int
6420 {
6424 #ifndef MAX_OFILE_ALIGNMENT
6425 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
6426 #endif
6431 /* Don't worry about checking alignment if alignment was not specified
6432 by the source program and we already posted an error for this entity. */
6437 /* Within GCC, an alignment is an integer, so we must make sure a
6438 value is specified that fits in that range. Also, alignments of
6439 more than MAX_OFILE_ALIGNMENT can't be supported. */
6453 else
6457 }
6458 \f
6459 /* Verify that OBJECT, a type or decl, is something we can implement
6460 atomically. If not, give an error for GNAT_ENTITY. COMP_P is true
6461 if we require atomic components. */
6463 static void
6465 {
6467 Node_Id gnat_node;
6470 tree size;
6472 /* There are three case of what OBJECT can be. It can be a type, in which
6473 case we take the size, alignment and mode from the type. It can be a
6474 declaration that was indirect, in which case the relevant values are
6475 that of the type being pointed to, or it can be a normal declaration,
6476 in which case the values are of the decl. The code below assumes that
6477 OBJECT is either a type or a decl. */
6479 {
6483 }
6485 {
6489 }
6490 else
6491 {
6495 }
6497 /* Consider all floating-point types atomic and any types that that are
6498 represented by integers no wider than a machine word. */
6505 /* For the moment, also allow anything that has an alignment equal
6506 to its size and which is smaller than a word. */
6514 {
6522 }
6527 else
6530 }
6531 \f
6532 /* Check if FTYPE1 and FTYPE2, two potentially different function type nodes,
6533 have compatible signatures so that a call using one type may be safely
6534 issued if the actual target function type is the other. Return 1 if it is
6535 the case, 0 otherwise, and post errors on the incompatibilities.
6537 This is used when an Ada subprogram is mapped onto a GCC builtin, to ensure
6538 that calls to the subprogram will have arguments suitable for the later
6539 underlying builtin expansion. */
6541 static int
6543 {
6544 /* As of now, we only perform very trivial tests and consider it's the
6545 programmer's responsibility to ensure the type correctness in the Ada
6546 declaration, as in the regular Import cases.
6548 Mismatches typically result in either error messages from the builtin
6549 expander, internal compiler errors, or in a real call sequence. This
6550 should be refined to issue diagnostics helping error detection and
6551 correction. */
6553 /* Almost fake test, ensuring a use of each argument. */
6558 }
6559 \f
6560 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new type
6561 with all size expressions that contain F updated by replacing F with R.
6562 This is identical to GCC's substitute_in_type except that it knows about
6563 TYPE_INDEX_TYPE. If F is NULL_TREE, always make a new RECORD_TYPE, even if
6564 nothing has changed. */
6566 tree
6568 {
6570 tree tem;
6573 {
6579 {
6588 SET_TYPE_INDEX_TYPE
6591 }
6598 {
6612 }
6626 /* Don't know how to do these yet. */
6630 {
6644 /* If we had bounded the sizes of T by a constant, bound the sizes of
6645 NEW by the same constant. */
6655 }
6660 {
6661 tree field;
6662 bool changed_field
6669 /* Start out with no fields, make new fields, and chain them
6670 in. If we haven't actually changed the type of any field,
6671 discard everything we've done and return the old type. */
6677 {
6688 /* If this is an internal field and the type of this field is
6689 a UNION_TYPE or RECORD_TYPE with no elements, ignore it. If
6690 the type just has one element, treat that as the field.
6691 But don't do this if we are processing a QUAL_UNION_TYPE. */
6696 {
6701 {
6702 tree next_new_field
6705 /* Make sure omitting the union doesn't change
6706 the layout. */
6709 }
6710 }
6717 /* If the size of the old field was set at a constant,
6718 propagate the size in case the type's size was variable.
6719 (This occurs in the case of a variant or discriminated
6720 record with a default size used as a field of another
6721 record.) */
6730 {
6736 /* Do the substitution inside the qualifier and if we find
6737 that this field will not be present, omit it. */
6742 }
6746 else
6751 /* If this is a qualified type and this field will always be
6752 present, we are done. */
6756 }
6758 /* If this used to be a qualified union type, but we now know what
6759 field will be present, make this a normal union. */
6770 /* If the size was originally a constant use it. */
6773 {
6777 }
6780 }
6784 }
6785 }
6786 \f
6787 /* Return the "RM size" of GNU_TYPE. This is the actual number of bits
6788 needed to represent the object. */
6790 tree
6792 {
6793 /* For integer types, this is the precision. For record types, we store
6794 the size explicitly. For other types, this is just the size. */
6800 /* Return the rm_size of the actual data plus the size of the template. */
6801 return
6811 else
6813 }
6814 \f
6815 /* Return an identifier representing the external name to be used for
6816 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
6817 and the specified suffix. */
6819 tree
6821 {
6830 /* A variable using the Stdcall convention (meaning we are running
6831 on a Windows box) live in a DLL. Here we adjust its name to use
6832 the jump-table, the _imp__NAME contains the address for the NAME
6833 variable. */
6836 {
6843 }
6846 }
6848 /* Return the name to be used for GNAT_ENTITY. If a type, create a
6849 fully-qualified name, possibly with type information encoding.
6850 Otherwise, return the name. */
6852 tree
6854 {
6857 }
6859 /* Given GNU_ID, an IDENTIFIER_NODE containing a name and SUFFIX, a
6860 string, return a new IDENTIFIER_NODE that is the concatenation of
6861 the name in GNU_ID and SUFFIX. */
6863 tree
6865 {
6874 }