| blob | fac6f2f06e3c73defedf6044a4a0b0f3cb478ed7 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2006, 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 ****************************************************************************/
56 /* Convention_Stdcall should be processed in a specific way on Windows targets
57 only. The macro below is a helper to avoid having to check for a Windows
58 specific attribute throughout this unit. */
60 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
61 #define Has_Stdcall_Convention(E) (Convention (E) == Convention_Stdcall)
62 #else
63 #define Has_Stdcall_Convention(E) (0)
64 #endif
66 /* These two variables are used to defer recursively expanding incomplete
67 types while we are processing a record or subprogram type. */
70 static struct incomplete
71 {
73 tree old_type;
74 Entity_Id full_type;
77 /* These two variables are used to defer emission of debug information for
78 nested incomplete record types */
107 /* Given GNAT_ENTITY, an entity in the incoming GNAT tree, return a
108 GCC type corresponding to that entity. GNAT_ENTITY is assumed to
109 refer to an Ada type. */
111 tree
113 {
114 tree gnu_decl;
116 /* The back end never attempts to annotate generic types */
120 /* Convert the ada entity type into a GCC TYPE_DECL node. */
124 }
125 \f
126 /* Given GNAT_ENTITY, a GNAT defining identifier node, which denotes some Ada
127 entity, this routine returns the equivalent GCC tree for that entity
128 (an ..._DECL node) and associates the ..._DECL node with the input GNAT
129 defining identifier.
131 If GNAT_ENTITY is a variable or a constant declaration, GNU_EXPR gives its
132 initial value (in GCC tree form). This is optional for variables.
133 For renamed entities, GNU_EXPR gives the object being renamed.
135 DEFINITION is nonzero if this call is intended for a definition. This is
136 used for separate compilation where it necessary to know whether an
137 external declaration or a definition should be created if the GCC equivalent
138 was not created previously. The value of 1 is normally used for a nonzero
139 DEFINITION, but a value of 2 is used in special circumstances, defined in
140 the code. */
142 tree
144 {
145 tree gnu_entity_id;
147 /* Contains the gnu XXXX_DECL tree node which is equivalent to the input
148 GNAT tree. This node will be associated with the GNAT node by calling
149 the save_gnu_tree routine at the end of the `switch' statement. */
151 /* true if we have already saved gnu_decl as a gnat association. */
153 /* Nonzero if we incremented defer_incomplete_level. */
155 /* Nonzero if we incremented defer_debug_level. */
157 /* Nonzero if we incremented force_global. */
159 /* Nonzero if we should check to see if elaborated during processing. */
161 /* Nonzero if we made GNU_DECL and its type here. */
167 Entity_Id gnat_temp;
168 unsigned int esize
178 bool imported_p
183 /* Since a use of an Itype is a definition, process it as such if it
184 is not in a with'ed unit. */
189 {
190 /* Ensure that we are in a subprogram mentioned in the Scope
191 chain of this entity, our current scope is global,
192 or that we encountered a task or entry (where we can't currently
193 accurately check scoping). */
196 {
199 }
203 {
208 gnat_temp
220 && (current_function_decl
222 {
225 }
226 }
228 /* This abort means the entity "gnat_entity" has an incorrect scope,
229 i.e. that its scope does not correspond to the subprogram in which
230 it is declared */
232 }
234 /* If this is entity 0, something went badly wrong. */
237 /* If we've already processed this entity, return what we got last time.
238 If we are defining the node, we should not have already processed it.
239 In that case, we will abort below when we try to save a new GCC tree for
240 this object. We also need to handle the case of getting a dummy type
241 when a Full_View exists. */
244 && (! definition
246 {
253 {
259 }
262 }
264 /* If this is a numeric or enumeral type, or an access type, a nonzero
265 Esize must be specified unless it was specified by the programmer. */
273 /* Likewise, RM_Size must be specified for all discrete and fixed-point
274 types. */
278 /* Get the name of the entity and set up the line number and filename of
279 the original definition for use in any decl we make. */
283 /* If we get here, it means we have not yet done anything with this
284 entity. If we are not defining it here, it must be external,
285 otherwise we should have defined it already. */
292 /* For cases when we are not defining (i.e., we are referencing from
293 another compilation unit) Public entities, show we are at global level
294 for the purpose of computing scopes. Don't do this for components or
295 discriminants since the relevant test is whether or not the record is
296 being defined. But do this for Imported functions or procedures in
297 all cases. */
305 /* Handle any attributes directly attached to the entity. */
309 /* Machine_Attributes on types are expected to be propagated to subtypes.
310 The corresponding Gigi_Rep_Items are only attached to the first subtype
311 though, so we handle the propagation here. */
318 {
320 /* If this is a use of a deferred constant, get its full
321 declaration. */
323 {
328 }
330 /* If we have an external constant that we are not defining,
331 get the expression that is was defined to represent. We
332 may throw that expression away later if it is not a
333 constant.
334 Do not retrieve the expression if it is an aggregate, because
335 in complex instantiation contexts it may not be expanded */
344 /* Ignore deferred constant definitions; they are processed fully in the
345 front-end. For deferred constant references, get the full
346 definition. On the other hand, constants that are renamings are
347 handled like variable renamings. If No_Initialization is set, this is
348 not a deferred constant but a constant whose value is built
349 manually. */
354 {
358 }
361 {
366 }
371 /* We used to special case VMS exceptions here to directly map them to
372 their associated condition code. Since this code had to be masked
373 dynamically to strip off the severity bits, this caused trouble in
374 the GCC/ZCX case because the "type" pointers we store in the tables
375 have to be static. We now don't special case here anymore, and let
376 the regular processing take place, which leaves us with a regular
377 exception data object for VMS exceptions too. The condition code
378 mapping is taken care of by the front end and the bitmasking by the
379 runtime library. */
384 {
385 /* The GNAT record where the component was defined. */
388 /* If the variable is an inherited record component (in the case of
389 extended record types), just return the inherited entity, which
390 must be a FIELD_DECL. Likewise for discriminants.
391 For discriminants of untagged records which have explicit
392 stored discriminants, return the entity for the corresponding
393 stored discriminant. Also use Original_Record_Component
394 if the record has a private extension. */
398 {
399 gnu_decl
404 }
406 /* If the enclosing record has explicit stored discriminants,
407 then it is an untagged record. If the Corresponding_Discriminant
408 is not empty then this must be a renamed discriminant and its
409 Original_Record_Component must point to the corresponding explicit
410 stored discriminant (i.e., we should have taken the previous
411 branch). */
415 {
416 /* A tagged record has no explicit stored discriminants. */
420 gnu_decl
425 }
427 /* If the enclosing record has explicit stored discriminants,
428 then it is an untagged record. If the Corresponding_Discriminant
429 is not empty then this must be a renamed discriminant and its
430 Original_Record_Component must point to the corresponding explicit
431 stored discriminant (i.e., we should have taken the first
432 branch). */
439 /* Otherwise, if we are not defining this and we have no GCC type
440 for the containing record, make one for it. Then we should
441 have made our own equivalent. */
443 {
444 /* ??? If this is in a record whose scope is a protected
445 type and we have an Original_Record_Component, use it.
446 This is a workaround for major problems in protected type
447 handling. */
455 {
456 gnu_decl
462 }
468 }
470 else
471 /* Here we have no GCC type and this is a reference rather than a
472 definition. This should never happen. Most likely the cause is a
473 reference before declaration in the gnat tree for gnat_entity. */
475 }
481 /* Simple variables, loop variables, OUT parameters, and exceptions. */
482 object:
483 {
485 bool const_flag
500 {
504 else
506 }
508 /* Get the type after elaborating the renamed object. */
511 /* If this is a loop variable, its type should be the base type.
512 This is because the code for processing a loop determines whether
513 a normal loop end test can be done by comparing the bounds of the
514 loop against those of the base type, which is presumed to be the
515 size used for computation. But this is not correct when the size
516 of the subtype is smaller than the type. */
520 /* Reject non-renamed objects whose types are unconstrained arrays or
521 any object whose type is a dummy type or VOID_TYPE. */
527 {
530 force_global--;
532 }
534 /* If an alignment is specified, use it if valid. Note that
535 exceptions are objects but don't have alignments. We must do this
536 before we validate the size, since the alignment can affect the
537 size. */
539 {
545 }
547 /* If we are defining the object, see if it has a Size value and
548 validate it if so. If we are not defining the object and a Size
549 clause applies, simply retrieve the value. We don't want to ignore
550 the clause and it is expected to have been validated already. Then
551 get the new type, if any. */
560 {
561 gnu_type
567 }
569 /* If this object has self-referential size, it must be a record with
570 a default value. We are supposed to allocate an object of the
571 maximum size in this case unless it is a constant with an
572 initializing expression, in which case we can get the size from
573 that. Note that the resulting size may still be a variable, so
574 this may end up with an indirect allocation. */
578 {
580 gnu_size
581 = SUBSTITUTE_PLACEHOLDER_IN_EXPR
584 /* We may have no GNU_EXPR because No_Initialization is
585 set even though there's an Expression. */
590 gnu_size
592 (Etype
594 else
595 {
598 }
599 }
601 /* If the size is zero bytes, make it one byte since some linkers have
602 trouble with zero-sized objects. If the object will have a
603 template, that will make it nonzero so don't bother. Also avoid
604 doing that for an object renaming or an object with an address
605 clause, as we would lose useful information on the view size
606 (e.g. for null array slices) and we are not allocating the object
607 here anyway. */
616 /* If this is an atomic object with no specified size and alignment,
617 but where the size of the type is a constant, set the alignment to
618 the lowest power of two greater than the size, or to the
619 biggest meaningful alignment, whichever is smaller. */
623 {
626 BIGGEST_ALIGNMENT))
628 else
633 }
635 /* If the object is set to have atomic components, find the component
636 type and validate it.
638 ??? Note that we ignore Has_Volatile_Components on objects; it's
639 not at all clear what to do in that case. */
642 {
651 }
653 /* Now check if the type of the object allows atomic access. Note
654 that we must test the type, even if this object has size and
655 alignment to allow such access, because we will be going
656 inside the padded record to assign to the object. We could fix
657 this by always copying via an intermediate value, but it's not
658 clear it's worth the effort. */
662 /* If this is an aliased object with an unconstrained nominal subtype,
663 make a type that includes the template. */
667 {
668 tree gnu_fat
671 gnu_type
675 }
677 #ifdef MINIMUM_ATOMIC_ALIGNMENT
678 /* If the size is a constant and no alignment is specified, force
679 the alignment to be the minimum valid atomic alignment. The
680 restriction on constant size avoids problems with variable-size
681 temporaries; if the size is variable, there's no issue with
682 atomic access. Also don't do this for a constant, since it isn't
683 necessary and can interfere with constant replacement. Finally,
684 do not do it for Out parameters since that creates an
685 size inconsistency with In parameters. */
694 #endif
696 /* Make a new type with the desired size and alignment, if needed. */
700 /* Make a volatile version of this object's type if we are to
701 make the object volatile. Note that 13.3(19) says that we
702 should treat other types of objects as volatile as well. */
712 /* Convert the expression to the type of the object except in the
713 case where the object's type is unconstrained or the object's type
714 is a padded record whose field is of self-referential size. In
715 the former case, converting will generate unnecessary evaluations
716 of the CONSTRUCTOR to compute the size and in the latter case, we
717 want to only copy the actual data. */
723 && (CONTAINS_PLACEHOLDER_P
727 /* See if this is a renaming, and handle appropriately depending on
728 what is renamed and in which context. There are three major
729 cases:
731 1/ This is a constant renaming and we can just make an object
732 with what is renamed as its initial value,
734 2/ We can reuse a stabilized version of what is renamed in place
735 of the renaming,
737 3/ If neither 1 or 2 applies, we make the renaming entity a constant
738 pointer to what is being renamed. */
741 {
742 /* If the renamed object had padding, strip off the reference
743 to the inner object and reset our type. */
747 && (TYPE_IS_PADDING_P
749 {
752 }
754 /* Case 1: If this is a constant renaming, treat it as a normal
755 object whose initial value is what is being renamed. We cannot
756 do this if the type is unconstrained or class-wide. */
763 ;
765 /* Otherwise, see if we can proceed with a stabilized version of
766 the renamed entity or if we need to make a pointer. */
767 else
768 {
772 /* Case 2: If the renaming entity need not be materialized and
773 the renamed expression is something we can stabilize, use
774 that for the renaming. At the global level, we can only do
775 this if we know no SAVE_EXPRs need be made, because the
776 expression we return might be used in arbitrary conditional
777 branches so we must force the SAVE_EXPRs evaluation
778 immediately and this requires a function context. */
783 {
784 maybe_stable_expr
789 {
794 }
796 /* The stabilization failed. Keep maybe_stable_expr
797 untouched here to let the pointer case below know
798 about that failure. */
799 }
801 /* Case 3: Make this into a constant pointer to the object we
802 are to rename and attach the object to the pointer if it is
803 an lvalue that can be stabilized.
805 From the proper scope, attached objects will be referenced
806 directly instead of indirectly via the pointer to avoid
807 subtle aliasing problems with non addressable entities.
808 They have to be stable because we must not evaluate the
809 variables in the expression every time the renaming is used.
810 They also have to be lvalues because the context in which
811 they are reused sometimes requires so. We call pointers
812 with an attached object "renaming" pointers.
814 In the rare cases where we cannot stabilize the renamed
815 object, we just make a "bare" pointer, and the renamed
816 entity is always accessed indirectly through it. */
817 {
824 /* If a previous attempt at unrestricted stabilization
825 failed, there is no point trying again and we can reuse
826 the result without attaching it to the pointer. */
828 ;
830 /* Otherwise, try to stabilize now, restricting to
831 lvalues only, and attach the expression to the pointer
832 if the stabilization succeeds.
834 Note that this might introduce SAVE_EXPRs and we don't
835 check whether we're at the global level or not. This is
836 fine since we are building a pointer initializer and
837 neither the pointer nor the initializing expression can
838 be accessed before the pointer elaboration has taken
839 place in a correct program.
841 SAVE_EXPRs will be evaluated at the right spots by either
842 create_var_decl->expand_decl_init for the non-global case
843 or build_unit_elab for the global case, and will be
844 attached to the elaboration procedure by the RTL expander
845 in the latter case. We have no need to force an early
846 evaluation here. */
847 else
848 {
849 maybe_stable_expr
855 /* Attaching is actually performed downstream, as soon
856 as we have a DECL for the pointer we make. */
857 }
859 gnu_expr
862 /* If the initial expression has side effects, we might
863 still have an unstabilized version at this point (for
864 instance if it involves a function call). Wrap the
865 result into a SAVE_EXPR now, in case it happens to be
866 referenced several times. */
872 }
873 }
874 }
876 /* If this is an aliased object whose nominal subtype is unconstrained,
877 the object is a record that contains both the template and
878 the object. If there is an initializer, it will have already
879 been converted to the right type, but we need to create the
880 template if there is no initializer. */
883 /* Beware that padding might have been introduced
884 via maybe_pad_type above. */
887 == RECORD_TYPE
888 && TYPE_CONTAINS_TEMPLATE_P
891 {
892 tree template_field
897 gnu_expr
898 = gnat_build_constructor
900 tree_cons
904 NULL_TREE),
905 NULL_TREE));
906 }
908 /* If this is a pointer and it does not have an initializing
909 expression, initialize it to NULL, unless the object is
910 imported. */
916 /* If we are defining the object and it has an Address clause we must
917 get the address expression from the saved GCC tree for the
918 object if the object has a Freeze_Node. Otherwise, we elaborate
919 the address expression here since the front-end has guaranteed
920 in that case that the elaboration has no effects. Note that
921 only the latter mechanism is currently in use. */
923 {
924 tree gnu_address
930 /* Ignore the size. It's either meaningless or was handled
931 above. */
938 /* If we don't have an initializing expression for the underlying
939 variable, the initializing expression for the pointer is the
940 specified address. Otherwise, we have to make a COMPOUND_EXPR
941 to assign both the address and the initial value. */
944 else
945 gnu_expr
947 build_binary_op
950 gnu_address),
951 gnu_expr),
952 gnu_address);
953 }
955 /* If it has an address clause and we are not defining it, mark it
956 as an indirect object. Likewise for Stdcall objects that are
957 imported. */
961 {
966 /* No point in taking the address of an initializing expression
967 that isn't going to be used. */
970 }
972 /* If we are at top level and this object is of variable size,
973 make the actual type a hidden pointer to the real type and
974 make the initializer be a memory allocation and initialization.
975 Likewise for objects we aren't defining (presumed to be
976 external references from other packages), but there we do
977 not set up an initialization.
979 If the object's size overflows, make an allocator too, so that
980 Storage_Error gets raised. Note that we will never free
981 such memory, so we presume it never will get allocated. */
986 || (gnu_size
990 {
996 /* In case this was a aliased object whose nominal subtype is
997 unconstrained, the pointer above will be a thin pointer and
998 build_allocator will automatically make the template.
1000 If we have a template initializer only (that we made above),
1001 pretend there is none and rely on what build_allocator creates
1002 again anyway. Otherwise (if we have a full initializer), get
1003 the data part and feed that to build_allocator.
1005 If we are elaborating a mutable object, tell build_allocator to
1006 ignore a possibly simpler size from the initializer, if any, as
1007 we must allocate the maximum possible size in this case. */
1010 {
1015 {
1016 gnu_alloc_type
1023 else
1024 gnu_expr
1025 = build_component_ref
1029 }
1035 gnat_entity);
1039 }
1040 else
1041 {
1044 }
1045 }
1047 /* If this object would go into the stack and has an alignment
1048 larger than the default largest alignment, make a variable
1049 to hold the "aligning type" with a modified initial value,
1050 if any, then point to it and make that the value of this
1051 variable, which is now indirect. */
1054 {
1055 tree gnu_new_type
1058 tree gnu_new_var;
1060 gnu_new_var
1066 add_stmt_with_node
1068 build_component_ref
1071 gnu_expr),
1072 gnat_entity);
1075 gnu_expr
1076 = build_unary_op
1084 }
1090 /* Convert the expression to the type of the object except in the
1091 case where the object's type is unconstrained or the object's type
1092 is a padded record whose field is of self-referential size. In
1093 the former case, converting will generate unnecessary evaluations
1094 of the CONSTRUCTOR to compute the size and in the latter case, we
1095 want to only copy the actual data. */
1101 && (CONTAINS_PLACEHOLDER_P
1105 /* If this name is external or there was a name specified, use it,
1106 unless this is a VMS exception object since this would conflict
1107 with the symbol we need to export in addition. Don't use the
1108 Interface_Name if there is an address clause (see CD30005). */
1117 /* If this is constant initialized to a static constant and the
1118 object has an aggregate type, force it to be statically
1119 allocated. */
1135 {
1138 }
1140 /* If we have an address clause and we've made this indirect, it's
1141 not enough to merely mark the type as volatile since volatile
1142 references only conflict with other volatile references while this
1143 reference must conflict with all other references. So ensure that
1144 the dereferenced value has alias set 0. */
1153 STACK_CHECK_MAX_VAR_SIZE))))
1158 gnat_entity);
1160 /* If this is a public constant or we're not optimizing and we're not
1161 making a VAR_DECL for it, make one just for export or debugger
1162 use. Likewise if the address is taken or if the object or type is
1163 aliased. */
1170 {
1171 tree gnu_corr_var
1177 }
1179 /* If this is declared in a block that contains a block with an
1180 exception handler, we must force this variable in memory to
1181 suppress an invalid optimization. */
1186 /* Back-annotate the Alignment of the object if not already in the
1187 tree. Likewise for Esize if the object is of a constant size.
1188 But if the "object" is actually a pointer to an object, the
1189 alignment and size are the same as the type, so don't back-annotate
1190 the values for the pointer. */
1197 {
1202 gnu_back_size
1207 }
1208 }
1212 /* Return a TYPE_DECL for "void" that we previously made. */
1217 /* A special case, for the types Character and Wide_Character in
1218 Standard, we do not list all the literals. So if the literals
1219 are not specified, make this an unsigned type. */
1221 {
1224 }
1226 /* Normal case of non-character type, or non-Standard character type */
1227 {
1228 /* Here we have a list of enumeral constants in First_Literal.
1229 We make a CONST_DECL for each and build into GNU_LITERAL_LIST
1230 the list to be places into TYPE_FIELDS. Each node in the list
1231 is a TREE_LIST node whose TREE_VALUE is the literal name
1232 and whose TREE_PURPOSE is the value of the literal.
1234 Esize contains the number of bits needed to represent the enumeral
1235 type, Type_Low_Bound also points to the first literal and
1236 Type_High_Bound points to the last literal. */
1238 Entity_Id gnat_literal;
1243 else
1251 {
1253 gnu_type);
1254 tree gnu_literal
1262 }
1266 /* Note that the bounds are updated at the end of this function
1267 because to avoid an infinite recursion when we get the bounds of
1268 this type, since those bounds are objects of this type. */
1269 }
1275 /* For integer types, just make a signed type the appropriate number
1276 of bits. */
1281 /* For modular types, make the unsigned type of the proper number of
1282 bits and then set up the modulus, if required. */
1283 {
1285 tree gnu_modulus;
1291 /* Find the smallest mode at least ESIZE bits wide and make a class
1292 using that mode. */
1297 ;
1303 /* Get the modulus in this type. If it overflows, assume it is because
1304 it is equal to 2**Esize. Note that there is no overflow checking
1305 done on unsigned type, so we detect the overflow by looking for
1306 a modulus of zero, which is otherwise invalid. */
1310 {
1315 }
1317 /* If we have to set TYPE_PRECISION different from its natural value,
1318 make a subtype to do do. Likewise if there is a modulus and
1319 it is not one greater than TYPE_MAX_VALUE. */
1323 {
1340 }
1341 }
1350 /* For integral subtypes, we make a new INTEGER_TYPE. Note
1351 that we do not want to call build_range_type since we would
1352 like each subtype node to be distinct. This will be important
1353 when memory aliasing is implemented.
1355 The TREE_TYPE field of the INTEGER_TYPE we make points to the
1356 parent type; this fact is used by the arithmetic conversion
1357 functions.
1359 We elaborate the Ancestor_Subtype if it is not in the current
1360 unit and one of our bounds is non-static. We do this to ensure
1361 consistent naming in the case where several subtypes share the same
1362 bounds by always elaborating the first such subtype first, thus
1363 using its name. */
1375 {
1378 }
1386 gnat_entity,
1393 gnat_entity,
1397 /* One of the above calls might have caused us to be elaborated,
1398 so don't blow up if so. */
1400 {
1403 }
1408 /* This should be an unsigned type if the lower bound is constant
1409 and non-negative or if the base type is unsigned; a signed type
1410 otherwise. */
1420 /* Inherit our alias set from what we're a subtype of. Subtypes
1421 are not different types and a pointer can designate any instance
1422 within a subtype hierarchy. */
1425 /* If the type we are dealing with is to represent a packed array,
1426 we need to have the bits left justified on big-endian targets
1427 and right justified on little-endian targets. We also need to
1428 ensure that when the value is read (e.g. for comparison of two
1429 such values), we only get the good bits, since the unused bits
1430 are uninitialized. Both goals are accomplished by wrapping the
1431 modular value in an enclosing struct. */
1433 {
1435 tree gnu_field;
1444 /* Create a stripped-down declaration of the original type, mainly
1445 for debugging. */
1449 /* Don't notify the field as "addressable", since we won't be taking
1450 it's address and it would prevent create_field_decl from making a
1451 bitfield. */
1460 }
1465 /* If this is a VAX floating-point type, use an integer of the proper
1466 size. All the operations will be handled with ASM statements. */
1468 {
1473 sizetype));
1475 }
1477 /* The type of the Low and High bounds can be our type if this is
1478 a type from Standard, so set them at the end of the function. */
1486 {
1489 }
1491 {
1518 /* One of the above calls might have caused us to be elaborated,
1519 so don't blow up if so. */
1521 {
1524 }
1528 /* Inherit our alias set from what we're a subtype of, as for
1529 integer subtypes. */
1531 }
1534 /* Array and String Types and Subtypes
1536 Unconstrained array types are represented by E_Array_Type and
1537 constrained array types are represented by E_Array_Subtype. There
1538 are no actual objects of an unconstrained array type; all we have
1539 are pointers to that type.
1541 The following fields are defined on array types and subtypes:
1543 Component_Type Component type of the array.
1544 Number_Dimensions Number of dimensions (an int).
1545 First_Index Type of first index. */
1549 {
1555 int firstdim
1557 int nextdim
1563 tree gnu_max_size_unit;
1565 Entity_Id gnat_ind_subtype;
1566 Entity_Id gnat_ind_base_subtype;
1567 tree gnu_template_reference;
1568 tree tem;
1576 /* Make a node for the array. If we are not defining the array
1577 suppress expanding incomplete types. */
1583 /* Build the fat pointer type. Use a "void *" object instead of
1584 a pointer to the array type since we don't have the array type
1585 yet (it will reference the fat pointer via the bounds). */
1588 ptr_void_type_node,
1591 gnu_ptr_template,
1594 /* Make sure we can put this into a register. */
1598 /* Build a reference to the template from a PLACEHOLDER_EXPR that
1599 is the fat pointer. This will be used to access the individual
1600 fields once we build them. */
1604 gnu_template_reference
1608 /* Now create the GCC type for each index and add the fields for
1609 that index to the template. */
1611 gnat_ind_base_subtype
1617 {
1619 tree gnu_ind_subtype
1621 tree gnu_base_subtype
1623 tree gnu_base_min
1625 tree gnu_base_max
1629 /* Make the FIELD_DECLs for the minimum and maximum of this
1630 type and then make extractions of that field from the
1631 template. */
1634 gnu_ind_subtype,
1638 gnu_ind_subtype,
1647 /* We can't use build_component_ref here since the template
1648 type isn't complete yet. */
1651 NULL_TREE);
1654 NULL_TREE);
1657 /* Make a range type with the new ranges, but using
1658 the Ada subtype. Then we convert to sizetype. */
1664 /* Update the maximum size of the array, in elements. */
1665 gnu_max_size
1669 gnu_base_min)));
1673 }
1676 gnu_template_fields
1679 /* Install all the fields into the template. */
1684 /* Now make the array of arrays and update the pointer to the array
1685 in the fat pointer. Note that it is the first field. */
1689 /* Get and validate any specified Component_Size, but if Packed,
1690 ignore it since the front end will have taken care of it. */
1691 gnu_comp_size
1693 gnat_entity,
1701 /* If the component type is a RECORD_TYPE that has a self-referential
1702 size, use the maxium size. */
1708 {
1712 }
1718 /* If Component_Size is not already specified, annotate it with the
1719 size of the component. */
1729 gnu_max_size),
1733 {
1737 /* If the type below this an multi-array type, then this
1738 does not not have aliased components.
1740 ??? Otherwise, for now, we say that any component of aggregate
1741 type is addressable because the front end may take 'Reference
1742 of it. But we have to make it addressable if it must be passed
1743 by reference or it that is the default. */
1749 }
1751 /* If an alignment is specified, use it if valid. But ignore it for
1752 types that represent the unpacked base type for packed arrays. */
1755 {
1760 }
1766 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
1767 corresponding fat pointer. */
1774 /* If the maximum size doesn't overflow, use it. */
1789 /* Create a record type for the object and its template and
1790 set the template at a negative offset. */
1802 /* Give the thin pointer type a name. */
1806 gnat_entity);
1807 }
1813 /* This is the actual data type for array variables. Multidimensional
1814 arrays are implemented in the gnu tree as arrays of arrays. Note
1815 that for the moment arrays which have sparse enumeration subtypes as
1816 index components create sparse arrays, which is obviously space
1817 inefficient but so much easier to code for now.
1819 Also note that the subtype never refers to the unconstrained
1820 array type, which is somewhat at variance with Ada semantics.
1822 First check to see if this is simply a renaming of the array
1823 type. If so, the result is the array type. */
1828 else
1829 {
1832 int first_dim
1835 int next_dim
1837 Entity_Id gnat_ind_subtype;
1838 Entity_Id gnat_ind_base_subtype;
1843 tree gnu_max_size_unit;
1847 /* First create the gnu types for each index. Create types for
1848 debugging information to point to the index types if the
1849 are not integer types, have variable bounds, or are
1850 wider than sizetype. */
1853 gnat_ind_base_subtype
1859 {
1860 tree gnu_index_subtype
1862 tree gnu_min
1864 tree gnu_max
1866 tree gnu_base_subtype
1868 tree gnu_base_min
1870 tree gnu_base_max
1873 tree gnu_base_base_min
1875 tree gnu_base_base_max
1877 tree gnu_high;
1878 tree gnu_this_max;
1880 /* If the minimum and maximum values both overflow in
1881 SIZETYPE, but the difference in the original type
1882 does not overflow in SIZETYPE, ignore the overflow
1883 indications. */
1891 && (!TREE_OVERFLOW
1899 /* Similarly, if the range is null, use bounds of 1..0 for
1900 the sizetype bounds. */
1912 /* Now compute the size of this bound. We need to provide
1913 GCC with an upper bound to use but have to deal with the
1914 "superflat" case. There are three ways to do this. If we
1915 can prove that the array can never be superflat, we can
1916 just use the high bound of the index subtype. If we can
1917 prove that the low bound minus one can't overflow, we
1918 can do this as MAX (hb, lb - 1). Otherwise, we have to use
1919 the expression hb >= lb ? hb : lb - 1. */
1922 /* See if the base array type is already flat. If it is, we
1923 are probably compiling an ACVC test, but it will cause the
1924 code below to malfunction if we don't handle it specially. */
1932 /* If gnu_high is now an integer which overflowed, the array
1933 cannot be superflat. */
1940 else
1941 gnu_high
1942 = build_cond_expr
1950 /* Also compute the maximum size of the array. Here we
1951 see if any constraint on the index type of the base type
1952 can be used in the case of self-referential bound on
1953 the index type of the subtype. We look for a non-"infinite"
1954 and non-self-referential bound from any type involved and
1955 handle each bound separately. */
1980 gnu_this_max
1984 gnu_base_min)),
1985 size_zero_node);
1991 gnu_max_size
2005 }
2007 /* Then flatten: create the array of arrays. */
2011 /* One of the above calls might have caused us to be elaborated,
2012 so don't blow up if so. */
2014 {
2017 }
2019 /* Get and validate any specified Component_Size, but if Packed,
2020 ignore it since the front end will have taken care of it. */
2021 gnu_comp_size
2023 gnat_entity,
2028 /* If the component type is a RECORD_TYPE that has a self-referential
2029 size, use the maxium size. */
2035 {
2040 }
2054 {
2057 /* If the type below this an multi-array type, then this
2058 does not not have aliased components.
2060 ??? Otherwise, for now, we say that any component of aggregate
2061 type is addressable because the front end may take 'Reference
2062 of it. But we have to make it addressable if it must be passed
2063 by reference or it that is the default. */
2069 }
2071 /* If we are at file level and this is a multi-dimensional array, we
2072 need to make a variable corresponding to the stride of the
2073 inner dimensions. */
2075 {
2077 tree gnu_arr_type;
2083 {
2091 /* ??? For now, store the size as a multiple of the
2092 alignment of the element type in bytes so that we
2093 can see the alignment from the tree. */
2095 = build_binary_op
2097 elaborate_expression_1
2106 }
2107 }
2109 /* If we need to write out a record type giving the names of
2110 the bounds, do it now. */
2112 {
2115 tree gnu_field;
2121 {
2122 tree gnu_type_name
2129 integer_type_node,
2130 gnu_bound_rec_type,
2134 }
2138 }
2145 /* If our size depends on a placeholder and the maximum size doesn't
2146 overflow, use it. */
2153 {
2159 }
2161 /* Set our alias set to that of our base type. This gives all
2162 array subtypes the same alias set. */
2164 }
2166 /* If this is a packed type, make this type the same as the packed
2167 array type, but do some adjusting in the type first. */
2170 {
2171 Entity_Id gnat_index;
2172 tree gnu_inner_type;
2174 /* First finish the type we had been making so that we output
2175 debugging information for it */
2176 gnu_type
2179 | (TYPE_QUAL_VOLATILE
2187 /* Save it as our equivalent in case the call below elaborates
2188 this type again. */
2202 /* We need to point the type we just made to our index type so
2203 the actual bounds can be put into a template. */
2209 {
2211 {
2212 /* The TYPE_ACTUAL_BOUNDS field is also used for the modulus.
2213 If it is, we need to make another type. */
2215 {
2216 tree gnu_subtype;
2233 }
2236 }
2242 SET_TYPE_ACTUAL_BOUNDS
2249 SET_TYPE_ACTUAL_BOUNDS
2256 }
2257 }
2259 /* Abort if packed array with no packed array type field set. */
2260 else
2266 /* Create the type for a string literal. */
2267 {
2268 Entity_Id gnat_full_type
2273 tree gnu_string_array_type
2275 tree gnu_string_index_type
2278 tree gnu_lower_bound
2283 tree gnu_upper_bound
2285 gnu_lower_bound,
2287 tree gnu_range_type
2290 tree gnu_index_type
2295 gnu_range_type);
2297 gnu_type
2299 gnu_index_type);
2301 }
2304 /* Record Types and Subtypes
2306 The following fields are defined on record types:
2308 Has_Discriminants True if the record has discriminants
2309 First_Discriminant Points to head of list of discriminants
2310 First_Entity Points to head of list of fields
2311 Is_Tagged_Type True if the record is tagged
2313 Implementation of Ada records and discriminated records:
2315 A record type definition is transformed into the equivalent of a C
2316 struct definition. The fields that are the discriminants which are
2317 found in the Full_Type_Declaration node and the elements of the
2318 Component_List found in the Record_Type_Definition node. The
2319 Component_List can be a recursive structure since each Variant of
2320 the Variant_Part of the Component_List has a Component_List.
2322 Processing of a record type definition comprises starting the list of
2323 field declarations here from the discriminants and the calling the
2324 function components_to_record to add the rest of the fields from the
2325 component list and return the gnu type node. The function
2326 components_to_record will call itself recursively as it traverses
2327 the tree. */
2331 {
2332 gnu_type
2333 = build_complex_type
2334 (get_unpadded_type
2337 (Component_List
2338 (Type_Definition
2342 }
2344 {
2347 Entity_Id gnat_field;
2348 tree gnu_field;
2350 tree gnu_get_parent;
2357 bool is_extension
2361 /* See if all fields have a rep clause. Stop when we find one
2362 that doesn't. */
2371 /* If this is a record extension, go a level further to find the
2372 record definition. Also, verify we have a Parent_Subtype. */
2374 {
2381 }
2383 /* Make a node for the record. If we are not defining the record,
2384 suppress expanding incomplete types. We use the same RECORD_TYPE
2385 as for a dummy type and reset TYPE_DUMMY_P to show it's no longer
2386 a dummy.
2388 It is very tempting to delay resetting this bit until we are done
2389 with completing the type, e.g. to let possible intermediate
2390 elaboration of access types designating the record know it is not
2391 complete and arrange for update_pointer_to to fix things up later.
2393 It would be wrong, however, because dummy types are expected only
2394 to be created for Ada incomplete or private types, which is not
2395 what we have here. Doing so would make other parts of gigi think
2396 we are dealing with a really incomplete or private type, and have
2397 nasty side effects, typically on the generation of the associated
2398 debugging information. */
2411 /* If both a size and rep clause was specified, put the size in
2412 the record type now so that it can get the proper mode. */
2416 /* Always set the alignment here so that it can be used to
2417 set the mode, if it is making the alignment stricter. If
2418 it is invalid, it will be checked again below. If this is to
2419 be Atomic, choose a default alignment of a word unless we know
2420 the size and it's smaller. */
2429 /* If we have a Parent_Subtype, make a field for the parent. If
2430 this record has rep clauses, force the position to zero. */
2432 {
2434 tree gnu_parent;
2436 /* A major complexity here is that the parent subtype will
2437 reference our discriminants in its Discriminant_Constraint
2438 list. But those must reference the parent component of this
2439 record which is of the parent subtype we have not built yet!
2440 To break the circle we first build a dummy COMPONENT_REF which
2441 represents the "get to the parent" operation and initialize
2442 each of those discriminants to a COMPONENT_REF of the above
2443 dummy parent referencing the corresponding discrimant of the
2444 base type of the parent subtype. */
2448 NULL_TREE),
2449 NULL_TREE);
2456 save_gnu_tree
2460 gnu_get_parent,
2463 NULL_TREE),
2466 /* Then we build the parent subtype. */
2469 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
2470 initially built. The discriminants must reference the fields
2471 of the parent subtype and not those of its base type for the
2472 placeholder machinery to properly work. */
2478 {
2488 }
2490 /* The "get to the parent" COMPONENT_REF must be given its
2491 proper type... */
2494 /* ...and reference the _parent field of this record. */
2495 gnu_field_list
2503 }
2505 /* Make the fields for the discriminants and put them into the record
2506 unless it's an Unchecked_Union. */
2511 {
2512 /* If this is a record extension and this discriminant
2513 is the renaming of another discriminant, we've already
2514 handled the discriminant above. */
2519 gnu_field
2522 /* Make an expression using a PLACEHOLDER_EXPR from the
2523 FIELD_DECL node just created and link that with the
2524 corresponding GNAT defining identifier. Then add to the
2525 list of fields. */
2534 {
2537 }
2538 }
2540 /* Put the discriminants into the record (backwards), so we can
2541 know the appropriate discriminant to use for the names of the
2542 variants. */
2545 /* Add the listed fields into the record and finish up. */
2552 {
2554 defer_debug_level++;
2556 defer_debug_incomplete_list
2558 defer_debug_incomplete_list);
2559 }
2561 /* We used to remove the associations of the discriminants and
2562 _Parent for validity checking, but we may need them if there's
2563 Freeze_Node for a subtype used in this record. */
2568 /* If it is a tagged record force the type to BLKmode to insure
2569 that these objects will always be placed in memory. Do the
2570 same thing for limited record types. */
2574 /* If this is a derived type, we must make the alias set of this type
2575 the same as that of the type we are derived from. We assume here
2576 that the other type is already frozen. */
2582 /* Fill in locations of fields. */
2585 /* If there are any entities in the chain corresponding to
2586 components that we did not elaborate, ensure we elaborate their
2587 types if they are Itypes. */
2595 }
2599 /* If an equivalent type is present, that is what we should use.
2600 Otherwise, fall through to handle this like a record subtype
2601 since it may have constraints. */
2604 {
2609 }
2611 /* ... fall through ... */
2615 /* If Cloned_Subtype is Present it means this record subtype has
2616 identical layout to that type or subtype and we should use
2617 that GCC type for this one. The front end guarantees that
2618 the component list is shared. */
2620 {
2624 }
2626 /* Otherwise, first ensure the base type is elaborated. Then, if we are
2627 changing the type, make a new type with each field having the
2628 type of the field in the new subtype but having the position
2629 computed by transforming every discriminant reference according
2630 to the constraints. We don't see any difference between
2631 private and nonprivate type here since derivations from types should
2632 have been deferred until the completion of the private type. */
2633 else
2634 {
2636 tree gnu_base_type;
2637 tree gnu_orig_type;
2642 /* Get the base type initially for its alignment and sizes. But
2643 if it is a padded type, we do all the other work with the
2644 unpadded type. */
2653 {
2656 }
2658 /* When the type has discriminants, and these discriminants
2659 affect the shape of what it built, factor them in.
2661 If we are making a subtype of an Unchecked_Union (must be an
2662 Itype), just return the type.
2664 We can't just use Is_Constrained because private subtypes without
2665 discriminants of full types with discriminants with default
2666 expressions are Is_Constrained but aren't constrained! */
2674 {
2675 Entity_Id gnat_field;
2677 tree gnu_pos_list
2680 BIGGEST_ALIGNMENT);
2681 tree gnu_subst_list
2683 definition);
2684 tree gnu_temp;
2690 gnat_entity);
2702 {
2703 tree gnu_old_field
2706 tree gnu_offset
2708 gnu_pos_list));
2711 tree gnu_field_type
2715 unsigned int offset_align
2718 tree gnu_field;
2720 /* If there was a component clause, the field types must be
2721 the same for the type and subtype, so copy the data from
2722 the old field to avoid recomputation here. Also if the
2723 field is justified modular and the optimization in
2724 gnat_to_gnu_field was applied. */
2731 {
2734 }
2736 /* If this was a bitfield, get the size from the old field.
2737 Also ensure the type can be placed into a bitfield. */
2739 {
2745 }
2754 /* If the size is now a constant, we can set it as the
2755 size of the field when we make it. Otherwise, we need
2756 to deal with it specially. */
2760 gnu_field
2761 = create_field_decl
2767 {
2776 bitsize_unit_node));
2778 }
2782 SET_DECL_ORIGINAL_FIELD
2793 }
2795 /* Now go through the entities again looking for Itypes that
2796 we have not elaborated but should (e.g., Etypes of fields
2797 that have Original_Components). */
2808 /* Now set the size, alignment and alias set of the new type to
2809 match that of the old one, doing any substitutions, as
2810 above. */
2836 SET_TYPE_ADA_SIZE
2841 /* Recompute the mode of this record type now that we know its
2842 actual size. */
2845 /* Fill in locations of fields. */
2847 }
2849 /* If we've made a new type, record it and make an XVS type to show
2850 what this is a subtype of. Some debuggers require the XVS
2851 type to be output first, so do it in that order. */
2853 {
2855 {
2866 integer_type_node,
2867 gnu_subtype_marker,
2871 }
2878 }
2880 /* Otherwise, go down all the components in the new type and
2881 make them equivalent to those in the base type. */
2882 else
2889 gnat_to_gnu_field_decl
2891 }
2896 /* If we are not defining this entity, and we have incomplete
2897 entities being processed above us, make a dummy type and
2898 fill it in later. */
2900 {
2904 gnu_type
2905 = build_pointer_type
2918 }
2920 /* ... fall through ... */
2927 {
2929 Entity_Id gnat_desig_full
2931 Incomplete_Or_Private_Kind))
2933 /* We want to know if we'll be seeing the freeze node for any
2934 incomplete type we may be pointing to. */
2935 bool in_main_unit
2951 {
2953 {
2957 }
2959 Incomplete_Or_Private_Kind))
2961 }
2966 /* If either the designated type or its full view is an
2967 unconstrained array subtype, replace it with the type it's a
2968 subtype of. This avoids problems with multiple copies of
2969 unconstrained array types. */
2978 /* If the designated type is a subtype of an incomplete record type,
2979 use the parent type to avoid order of elaboration issues. This
2980 can lose some code efficiency, but there is no alternative. */
2986 /* If we are pointing to an incomplete type whose completion is an
2987 unconstrained array, make a fat pointer type instead of a pointer
2988 to VOID. The two types in our fields will be pointers to VOID and
2989 will be replaced in update_pointer_to. Similarly, if the type
2990 itself is a dummy type or an unconstrained array. Also make
2991 a dummy TYPE_OBJECT_RECORD_TYPE in case we have any thin
2992 pointers to it. */
3008 && defer_incomplete_level
3012 {
3013 tree gnu_old
3017 tree fields;
3019 /* Show the dummy we get will be a fat pointer. */
3022 /* If the call above got something that has a pointer, that
3023 pointer is our type. This could have happened either
3024 because the type was elaborated or because somebody
3025 else executed the code below. */
3028 {
3034 fields
3036 create_field_decl
3041 ptr_void_type_node,
3044 /* Make sure we can place this into a register. */
3055 }
3056 }
3058 /* If we already know what the full type is, use it. */
3063 /* Get the type of the thing we are to point to and build a pointer
3064 to it. If it is a reference to an incomplete or private type with a
3065 full view that is a record, make a dummy type node and get the
3066 actual type later when we have verified it is safe. */
3072 {
3075 }
3077 /* Likewise if we are pointing to a record or array and we are to defer
3078 elaborating incomplete types. We do this since this access type
3079 may be the full view of some private type. Note that the
3080 unconstrained array case is handled above. */
3088 {
3091 }
3093 {
3094 gnu_type
3096 p_mode,
3099 }
3100 else
3103 /* It is possible that the above call to gnat_to_gnu_type resolved our
3104 type. If so, just return it. */
3106 {
3109 }
3111 /* If we have a GCC type for the designated type, possibly modify it
3112 if we are pointing only to constant objects and then make a pointer
3113 to it. Don't do this for unconstrained arrays. */
3115 {
3118 {
3119 gnu_desig_type
3120 = build_qualified_type
3124 /* Some extra processing is required if we are building a
3125 pointer to an incomplete type (in the GCC sense). We might
3126 have such a type if we just made a dummy, or directly out
3127 of the call to gnat_to_gnu_type above if we are processing
3128 an access type for a record component designating the
3129 record type itself. */
3131 {
3132 /* We must ensure that the pointer to variant we make will
3133 be processed by update_pointer_to when the initial type
3134 is completed. Pretend we made a dummy and let further
3135 processing act as usual. */
3138 /* We must ensure that update_pointer_to will not retrieve
3139 the dummy variant when building a properly qualified
3140 version of the complete type. We take advantage of the
3141 fact that get_qualified_type is requiring TYPE_NAMEs to
3142 match to influence build_qualified_type and then also
3143 update_pointer_to here. */
3146 }
3147 }
3149 gnu_type
3152 }
3154 /* If we are not defining this object and we made a dummy pointer,
3155 save our current definition, evaluate the actual type, and replace
3156 the tentative type we made with the actual one. If we are to defer
3157 actually looking up the actual type, make an entry in the
3158 deferred list. */
3161 {
3162 tree gnu_old_type
3168 gnu_type
3169 = build_pointer_type
3170 (TYPE_OBJECT_RECORD_TYPE
3180 /* Note that the call to gnat_to_gnu_type here might have
3181 updated gnu_old_type directly, in which case it is not a
3182 dummy type any more when we get into update_pointer_to.
3184 This may happen for instance when the designated type is a
3185 record type, because their elaboration starts with an
3186 initial node from make_dummy_type, which may yield the same
3187 node as the one we got.
3189 Besides, variants of this non-dummy type might have been
3190 created along the way. update_pointer_to is expected to
3191 properly take care of those situations. */
3194 else
3195 {
3203 }
3204 }
3205 }
3212 else
3213 /* The runtime representation is the equivalent type. */
3227 /* We treat this as identical to its base type; any constraint is
3228 meaningful only to the front end.
3230 The designated type must be elaborated as well, if it does
3231 not have its own freeze node. Designated (sub)types created
3232 for constrained components of records with discriminants are
3233 not frozen by the front end and thus not elaborated by gigi,
3234 because their use may appear before the base type is frozen,
3235 and because it is not clear that they are needed anywhere in
3236 Gigi. With the current model, there is no correct place where
3237 they could be elaborated. */
3244 {
3245 /* If we are not defining this entity, and we have incomplete
3246 entities being processed above us, make a dummy type and
3247 elaborate it later. */
3249 {
3252 tree gnu_ptr_type
3253 = build_pointer_type
3260 }
3263 Incomplete_Or_Private_Kind))
3264 ;
3265 else
3268 }
3273 /* Subprogram Entities
3275 The following access functions are defined for subprograms (functions
3276 or procedures):
3278 First_Formal The first formal parameter.
3279 Is_Imported Indicates that the subprogram has appeared in
3280 an INTERFACE or IMPORT pragma. For now we
3281 assume that the external language is C.
3282 Is_Inlined True if the subprogram is to be inlined.
3284 In addition for function subprograms we have:
3286 Etype Return type of the function.
3288 Each parameter is first checked by calling must_pass_by_ref on its
3289 type to determine if it is passed by reference. For parameters which
3290 are copied in, if they are Ada IN OUT or OUT parameters, their return
3291 value becomes part of a record which becomes the return type of the
3292 function (C function - note that this applies only to Ada procedures
3293 so there is no Ada return type). Additional code to store back the
3294 parameters will be generated on the caller side. This transformation
3295 is done here, not in the front-end.
3297 The intended result of the transformation can be seen from the
3298 equivalent source rewritings that follow:
3300 struct temp {int a,b};
3301 procedure P (A,B: IN OUT ...) is temp P (int A,B) {
3302 .. ..
3303 end P; return {A,B};
3304 }
3305 procedure call
3307 {
3308 temp t;
3309 P(X,Y); t = P(X,Y);
3310 X = t.a , Y = t.b;
3311 }
3313 For subprogram types we need to perform mainly the same conversions to
3314 GCC form that are needed for procedures and function declarations. The
3315 only difference is that at the end, we make a type declaration instead
3316 of a function declaration. */
3321 {
3322 /* The first GCC parameter declaration (a PARM_DECL node). The
3323 PARM_DECL nodes are chained through the TREE_CHAIN field, so this
3324 actually is the head of this parameter list. */
3326 /* The type returned by a function. If the subprogram is a procedure
3327 this type should be void_type_node. */
3329 /* List of fields in return type of procedure with copy in copy out
3330 parameters. */
3332 /* Non-null for subprograms containing parameters passed by copy in
3333 copy out (Ada IN OUT or OUT parameters not passed by reference),
3334 in which case it is the list of nodes used to specify the values of
3335 the in out/out parameters that are returned as a record upon
3336 procedure return. The TREE_PURPOSE of an element of this list is
3337 a field of the record and the TREE_VALUE is the PARM_DECL
3338 corresponding to that field. This list will be saved in the
3339 TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
3341 /* If an import pragma asks to map this subprogram to a GCC builtin,
3342 this is the builtin DECL node. */
3344 Entity_Id gnat_param;
3347 bool extern_flag
3359 /* A parameter may refer to this type, so defer completion
3360 of any incomplete types. */
3363 /* If the subprogram has an alias, it is probably inherited, so
3364 we can use the original one. If the original "subprogram"
3365 is actually an enumeration literal, it may be the first use
3366 of its type, so we must elaborate that type now. */
3368 {
3375 /* Elaborate any Itypes in the parameters of this entity. */
3383 }
3385 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
3386 corresponding DECL node.
3388 We still want the parameter associations to take place because the
3389 proper generation of calls depends on it (a GNAT parameter without
3390 a corresponding GCC tree has a very specific meaning), so we don't
3391 just break here. */
3395 /* ??? What if we don't find the builtin node above ? warn ? err ?
3396 In the current state we neither warn nor err, and calls will just
3397 be handled as for regular subprograms. */
3402 /* If this function returns by reference, make the actual
3403 return type of this function the pointer and mark the decl. */
3405 {
3408 }
3410 /* If the Mechanism is By_Reference, ensure the return type uses
3411 the machine's by-reference mechanism, which may not the same
3412 as above (e.g., it might be by passing a fake parameter). */
3415 {
3418 }
3420 /* If we are supposed to return an unconstrained array,
3421 actually return a fat pointer and make a note of that. Return
3422 a pointer to an unconstrained record of variable size. */
3424 {
3427 }
3429 /* If the type requires a transient scope, the result is allocated
3430 on the secondary stack, so the result type of the function is
3431 just a pointer. */
3433 {
3436 }
3438 /* If the type is a padded type and the underlying type would not
3439 be passed by reference or this function has a foreign convention,
3440 return the underlying type. */
3448 /* If the return type is unconstrained, that means it must have a
3449 maximum size. We convert the function into a procedure and its
3450 caller will pass a pointer to an object of that maximum size as the
3451 first parameter when we call the function. */
3453 {
3455 gnu_param_list
3460 }
3462 /* If the return type has a size that overflows, we cannot have
3463 a function that returns that type. This usage doesn't make
3464 sense anyway, so give an error here. */
3468 {
3470 gnat_entity);
3476 }
3478 /* Look at all our parameters and get the type of
3479 each. While doing this, build a copy-out structure if
3480 we need one. */
3485 {
3495 /* Builtins are expanded inline and there is no real call sequence
3496 involved. so the type expected by the underlying expander is
3497 always the type of each argument "as is". */
3501 /* Otherwise, see if a Mechanism was supplied that forced this
3502 parameter to be passed one way or another. */
3506 ;
3514 {
3520 else
3522 }
3523 else
3526 /* If this is either a foreign function or if the
3527 underlying type won't be passed by reference, strip off
3528 possible padding type. */
3534 && (req_by_copy
3536 (TYPE_FIELDS
3540 /* If this is an IN parameter it is read-only, so make a variant
3541 of the type that is read-only.
3543 ??? However, if this is an unconstrained array, that type can
3544 be very complex. So skip it for now. Likewise for any other
3545 self-referential type. */
3549 gnu_param_type
3554 /* For foreign conventions, pass arrays as a pointer to the
3555 underlying type. First check for unconstrained array and get
3556 the underlying array. Then get the component type and build
3557 a pointer to it. */
3560 gnu_param_type
3565 gnu_param_type
3566 = build_pointer_type
3571 && !req_by_copy
3573 {
3574 /* Strip off any multi-dimensional entries, then strip
3575 off the last array to get the component type. */
3584 gnu_param_type
3590 }
3592 /* Fat pointers are passed as thin pointers for foreign
3593 conventions. */
3596 gnu_param_type
3600 /* If we must pass or were requested to pass by reference, do so.
3601 If we were requested to pass by copy, do so.
3602 Otherwise, for foreign conventions, pass all in out parameters
3603 or aggregates by reference. For COBOL and Fortran, pass
3604 all integer and FP types that way too. For Convention Ada,
3605 use the standard Ada default. */
3607 || (!req_by_copy
3617 /* For convention Ada, see if we pass by reference
3618 by default. */
3621 {
3624 }
3632 /* If this is an OUT parameter that isn't passed by reference
3633 and isn't a pointer or aggregate, we don't make a PARM_DECL
3634 for it. Instead, it will be a VAR_DECL created when we process
3635 the procedure. For the special parameter of Valued_Procedure,
3636 never pass it in.
3638 An exception is made to cover the RM-6.4.1 rule requiring "by
3639 copy" out parameters with discriminants or implicit initial
3640 values to be handled like in out parameters. These type are
3641 normally built as aggregates, and hence passed by reference,
3642 except for some packed arrays which end up encoded in special
3643 integer types.
3645 The exception we need to make is then for packed arrays of
3646 records with discriminants or implicit initial values. We have
3647 no light/easy way to check for the latter case, so we merely
3648 check for packed arrays of records. This may lead to useless
3649 copy-in operations, but in very rare cases only, as these would
3650 be exceptions in a set of already exceptional situations. */
3653 || (!by_descr_p
3661 else
3662 {
3663 gnu_param
3664 = create_param_decl
3666 by_ref_p || by_component_ptr_p
3680 /* If a parameter is a pointer, this function may modify
3681 memory through it and thus shouldn't be considered
3682 a pure function. Also, the memory may be modified
3683 between two calls, so they can't be CSE'ed. The latter
3684 case also handles by-ref parameters. */
3688 }
3691 {
3693 {
3698 }
3707 gnu_return_list);
3708 }
3709 }
3711 /* Do not compute record for out parameters if subprogram is
3712 stubbed since structures are incomplete for the back-end. */
3715 {
3716 /* If all types are not complete, defer emission of debug
3717 information for this record types. Otherwise, we risk emitting
3718 debug information for a dummy type contained in the fields
3719 for that record. */
3724 {
3726 defer_debug_level++;
3728 defer_debug_incomplete_list
3730 defer_debug_incomplete_list);
3731 }
3732 }
3734 /* If we have a CICO list but it has only one entry, we convert
3735 this function into a function that simply returns that one
3736 object. */
3741 {
3751 }
3753 /* Both lists ware built in reverse. */
3757 gnu_type
3760 returns_by_ref,
3762 returns_by_target_ptr);
3764 /* A subprogram (something that doesn't return anything) shouldn't
3765 be considered Pure since there would be no reason for such a
3766 subprogram. Note that procedures with Out (or In Out) parameters
3767 have already been converted into a function with a return type. */
3771 /* The semantics of "pure" in Ada essentially matches that of "const"
3772 in the back-end. In particular, both properties are orthogonal to
3773 the "nothrow" property. But this is true only if the EH circuitry
3774 is explicit in the internal representation of the back-end. If we
3775 are to completely hide the EH circuitry from it, we need to declare
3776 that calls to pure Ada subprograms that can throw have side effects
3777 since they can trigger an "abnormal" transfer of control flow; thus
3778 they can be neither "const" nor "pure" in the back-end sense. */
3779 gnu_type
3788 /* If we have a builtin decl for that function, check the signatures
3789 compatibilities. If the signatures are compatible, use the builtin
3790 decl. If they are not, we expect the checker predicate to have
3791 posted the appropriate errors, and just continue with what we have
3792 so far. */
3794 {
3798 {
3802 }
3803 }
3805 /* If there was no specified Interface_Name and the external and
3806 internal names of the subprogram are the same, only use the
3807 internal name to allow disambiguation of nested subprograms. */
3811 /* If we are defining the subprogram and it has an Address clause
3812 we must get the address expression from the saved GCC tree for the
3813 subprogram if it has a Freeze_Node. Otherwise, we elaborate
3814 the address expression here since the front-end has guaranteed
3815 in that case that the elaboration has no effects. If there is
3816 an Address clause and we are not defining the object, just
3817 make it a constant. */
3819 {
3823 gnu_address
3834 gnu_decl
3839 }
3845 gnat_entity);
3846 else
3847 {
3852 gnat_entity);
3856 }
3857 }
3868 /* If this type does not have a full view in the unit we are
3869 compiling, then just get the type from its Etype. */
3871 {
3872 /* If this is an incomplete type with no full view, it must be
3873 either a limited view brought in by a limited_with clause, in
3874 which case we use the non-limited view, or a Taft Amendement
3875 type, in which case we just return a dummy type. */
3877 {
3882 else
3884 }
3889 else
3890 {
3894 }
3897 }
3899 /* Otherwise, if we are not defining the type now, get the
3900 type from the full view. But always get the type from the full
3901 view for define on use types, since otherwise we won't see them! */
3908 {
3913 }
3915 /* For incomplete types, make a dummy type entry which will be
3916 replaced later. */
3919 /* Save this type as the full declaration's type so we can do any needed
3920 updates when we see it. */
3927 /* Simple class_wide types are always viewed as their root_type
3928 by Gigi unless an Equivalent_Type is specified. */
3932 else
3944 else
3956 /* Nothing at all to do here, so just return an ERROR_MARK and claim
3957 we've already saved it, so we don't try to. */
3964 }
3966 /* If we had a case where we evaluated another type and it might have
3967 defined this one, handle it here. */
3969 {
3972 }
3974 /* If we are processing a type and there is either no decl for it or
3975 we just made one, do some common processing for the type, such as
3976 handling alignment and possible padding. */
3979 {
3987 /* ??? Don't set the size for a String_Literal since it is either
3988 confirming or we don't handle it properly (if the low bound is
3989 non-constant). */
3995 /* If a size was specified, see if we can make a new type of that size
3996 by rearranging the type, for example from a fat to a thin pointer. */
3998 {
3999 gnu_type
4006 }
4008 /* If the alignment hasn't already been processed and this is
4009 not an unconstrained array, see if an alignment is specified.
4010 If not, we pick a default alignment for atomic objects. */
4012 ;
4026 /* See if we need to pad the type. If we did, and made a record,
4027 the name of the new type may be changed. So get it back for
4028 us when we make the new TYPE_DECL below. */
4033 {
4037 }
4041 /* If we are at global level, GCC will have applied variable_size to
4042 the type, but that won't have done anything. So, if it's not
4043 a constant or self-referential, call elaborate_expression_1 to
4044 make a variable for the size rather than calculating it each time.
4045 Handle both the RM size and the actual size. */
4050 {
4054 {
4061 }
4062 else
4063 {
4070 /* ??? For now, store the size as a multiple of the alignment
4071 in bytes so that we can see the alignment from the tree. */
4073 = build_binary_op
4075 elaborate_expression_1
4086 SET_TYPE_ADA_SIZE
4089 gnat_entity,
4093 }
4094 }
4096 /* If this is a record type or subtype, call elaborate_expression_1 on
4097 any field position. Do this for both global and local types.
4098 Skip any fields that we haven't made trees for to avoid problems with
4099 class wide types. */
4104 {
4107 /* ??? Unfortunately, GCC needs to be able to prove the
4108 alignment of this offset and if it's a variable, it can't.
4109 In GCC 3.4, we'll use DECL_OFFSET_ALIGN in some way, but
4110 right now, we have to put in an explicit multiply and
4111 divide by that value. */
4114 = build_binary_op
4116 elaborate_expression_1
4125 }
4129 | (TYPE_QUAL_VOLATILE
4142 else
4144 }
4147 {
4150 /* Back-annotate the Alignment of the type if not already in the
4151 tree. Likewise for sizes. */
4157 {
4158 /* If the size is self-referential, we annotate the maximum
4159 value of that size. */
4168 {
4169 /* In this mode the tag and the parent components are not
4170 generated by the front-end, so the sizes must be adjusted
4171 explicitly now. */
4177 {
4178 size_offset
4182 }
4183 else
4191 }
4192 }
4196 }
4206 /* If we haven't already, associate the ..._DECL node that we just made with
4207 the input GNAT entity node. */
4211 /* If this is an enumeral or floating-point type, we were not able to set
4212 the bounds since they refer to the type. These bounds are always static.
4214 For enumeration types, also write debugging information and declare the
4215 enumeration literal table, if needed. */
4219 {
4222 /* If this is a padded type, we need to use the underlying type. */
4227 /* If this is a floating point type and we haven't set a floating
4228 point type yet, use this in the evaluation of the bounds. */
4238 {
4241 /* Since this has both a typedef and a tag, avoid outputting
4242 the name twice. */
4245 }
4246 }
4248 /* If we deferred processing of incomplete types, re-enable it. If there
4249 were no other disables and we have some to process, do so. */
4251 {
4257 {
4264 }
4265 }
4267 /* If we are not defining this type, see if it's in the incomplete list.
4268 If so, handle that list entry now. */
4270 {
4275 {
4279 }
4280 }
4282 /* If there are no incomplete types and we have deferred emission
4283 of debug information, check whether we have finished defining
4284 all nested records.
4285 If so, handle the list now. */
4288 defer_debug_level--;
4291 && !defer_incomplete_level
4293 {
4299 {
4302 }
4305 }
4308 force_global--;
4317 }
4319 /* Similar, but if the returned value is a COMPONENT_REF, return the
4320 FIELD_DECL. */
4322 tree
4324 {
4331 }
4333 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
4335 static
4337 {
4344 return
4346 }
4347 \f
4348 /* Given GNAT_ENTITY, elaborate all expressions that are required to
4349 be elaborated at the point of its definition, but do nothing else. */
4351 void
4353 {
4355 {
4362 {
4366 /* ??? Tests for avoiding static constraint error expression
4367 is needed until the front stops generating bogus conversions
4368 on bounds of real types. */
4377 }
4380 {
4384 /* If this is a record extension, go a level further to find the
4385 record definition. */
4388 }
4398 {
4399 Node_Id gnat_discriminant_expr;
4400 Entity_Id gnat_field;
4403 gnat_discriminant_expr
4408 /* ??? For now, ignore access discriminants. */
4411 gnat_entity,
4413 }
4416 }
4417 }
4418 \f
4419 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
4420 any entities on its entity chain similarly. */
4422 void
4424 {
4425 Entity_Id gnat_sub_entity;
4428 /* If this has an entity list, process all in the list. */
4445 /* Now clear this if it has been defined, but only do so if it isn't
4446 a subprogram or parameter. We could refine this, but it isn't
4447 worth it. If this is statically allocated, it is supposed to
4448 hang around out of cope. */
4451 {
4454 }
4455 }
4456 \f
4457 /* Set the alias set of GNU_NEW_TYPE to be that of GNU_OLD_TYPE. If this
4458 is a multi-dimensional array type, do this recursively. */
4460 static void
4462 {
4463 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
4464 of a one-dimensional array, since the padding has the same alias set
4465 as the field type, but if it's a multi-dimensional array, we need to
4466 see the inner types. */
4472 /* We need to be careful here in case GNU_OLD_TYPE is an unconstrained
4473 array. In that case, it doesn't have the same shape as GNU_NEW_TYPE,
4474 so we need to go down to what does. */
4476 gnu_old_type
4486 }
4487 \f
4488 /* Return a TREE_LIST describing the substitutions needed to reflect
4489 discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
4490 them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
4491 of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
4492 gives the tree for the discriminant and TREE_VALUES is the replacement
4493 value. They are in the form of operands to substitute_in_expr.
4494 DEFINITION is as in gnat_to_gnu_entity. */
4496 static tree
4499 {
4500 Entity_Id gnat_discrim;
4501 Node_Id gnat_value;
4512 /* Ignore access discriminants. */
4515 elaborate_expression
4519 gnu_list);
4522 }
4523 \f
4524 /* For the following two functions: for each GNAT entity, the GCC
4525 tree node used as a dummy for that entity, if any. */
4529 /* Initialize the above table. */
4531 void
4533 {
4534 Node_Id gnat_node;
4542 }
4544 /* Make a dummy type corresponding to GNAT_TYPE. */
4546 tree
4548 {
4549 Entity_Id gnat_underlying;
4550 tree gnu_type;
4553 /* Find a full type for GNAT_TYPE, taking into account any class wide
4554 types. */
4564 ;
4566 /* If it there already a dummy type, use that one. Else make one. */
4570 /* If this is a record, make this a RECORD_TYPE or UNION_TYPE; else make
4571 it an ENUMERAL_TYPE. */
4573 {
4574 Node_Id component_list
4576 (Declaration_Node
4578 Node_Id component;
4580 /* Make this a UNION_TYPE unless it's either not an Unchecked_Union or
4581 we have a non-discriminant field outside a variant. In either case,
4582 it's a RECORD_TYPE. */
4586 else
4591 }
4592 else
4604 }
4605 \f
4606 /* Return true if the size represented by GNU_SIZE can be handled by an
4607 allocation. If STATIC_P is true, consider only what can be done with a
4608 static allocation. */
4610 static bool
4612 {
4613 HOST_WIDE_INT our_size;
4615 /* If this is not a static allocation, the only case we want to forbid
4616 is an overflowing size. That will be converted into a raise a
4617 Storage_Error. */
4622 /* Otherwise, we need to deal with both variable sizes and constant
4623 sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
4624 since assemblers may not like very large sizes. */
4630 }
4631 \f
4632 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
4634 static void
4636 {
4637 Node_Id gnat_temp;
4642 {
4652 {
4654 (gnat_to_gnu
4661 (gnat_to_gnu
4662 (Expression
4665 }
4668 {
4695 }
4702 /* If we have an argument specified together with an attribute name,
4703 make it a single TREE_VALUE entry in a list of arguments, as GCC
4704 expects it. */
4707 else
4710 attr->error_point
4714 }
4715 }
4716 \f
4717 /* Get the unpadded version of a GNAT type. */
4719 tree
4721 {
4728 }
4729 \f
4730 /* Called when we need to protect a variable object using a save_expr. */
4732 tree
4734 {
4741 {
4749 }
4750 else
4752 }
4753 \f
4754 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
4755 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
4756 return the GCC tree to use for that expression. GNU_NAME is the
4757 qualification to use if an external name is appropriate and DEFINITION is
4758 nonzero if this is a definition of GNAT_ENTITY. If NEED_VALUE is nonzero,
4759 we need a result. Otherwise, we are just elaborating this for
4760 side-effects. If NEED_DEBUG is nonzero we need the symbol for debugging
4761 purposes even if it isn't needed for code generation. */
4763 static tree
4767 {
4768 tree gnu_expr;
4770 /* If we already elaborated this expression (e.g., it was involved
4771 in the definition of a private type), use the old value. */
4775 /* If we don't need a value and this is static or a discriminant, we
4776 don't need to do anything. */
4783 /* Otherwise, convert this tree to its GCC equivalent. */
4784 gnu_expr
4788 /* Save the expression in case we try to elaborate this entity again. Since
4789 this is not a DECL, don't check it. Don't save if it's a discriminant. */
4794 }
4796 /* Similar, but take a GNU expression. */
4798 static tree
4802 {
4804 /* Strip any conversions to see if the expression is a readonly variable.
4805 ??? This really should remain readonly, but we have to think about
4806 the typing of the tree here. */
4811 /* In most cases, we won't see a naked FIELD_DECL here because a
4812 discriminant reference will have been replaced with a COMPONENT_REF
4813 when the type is being elaborated. However, there are some cases
4814 involving child types where we will. So convert it to a COMPONENT_REF
4815 here. We have to hope it will be at the highest level of the
4816 expression in these cases. */
4822 /* If GNU_EXPR is neither a placeholder nor a constant, nor a variable
4823 that is a constant, make a variable that is initialized to contain the
4824 bound when the package containing the definition is elaborated. If
4825 this entity is defined at top level and a bound or discriminant value
4826 isn't a constant or a reference to a discriminant, replace the bound
4827 by the variable; otherwise use a SAVE_EXPR if needed. Note that we
4828 rely here on the fact that an expression cannot contain both the
4829 discriminant and some other variable. */
4836 /* If this is a static expression or contains a discriminant, we don't
4837 need the variable for debugging (and can't elaborate anyway if a
4838 discriminant). */
4844 /* Now create the variable if we need it. */
4846 gnu_decl
4853 /* We only need to use this variable if we are in global context since GCC
4854 can do the right thing in the local case. */
4859 else
4861 }
4862 \f
4863 /* Create a record type that contains a field of TYPE with a starting bit
4864 position so that it is aligned to ALIGN bits and is SIZE bytes long. */
4866 tree
4868 {
4873 place));
4882 /* The bit position is obtained by "and"ing the alignment minus 1
4883 with the two's complement of the address and multiplying
4884 by the number of bits per unit. Do all this in sizetype. */
4889 size_addr_place),
4892 bitsize_unit_node);
4894 /* Create the field, with -1 as the 'addressable' indication to avoid the
4895 creation of a bitfield. We don't need one, it would have damaging
4896 consequences on the alignment computation, and create_field_decl would
4897 make one without this special argument, for instance because of the
4898 complex position expression. */
4907 bitsize_unit_node),
4913 }
4914 \f
4915 /* TYPE is a RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE, with BLKmode that's
4916 being used as the field type of a packed record. See if we can rewrite it
4917 as a record that has a non-BLKmode type, which we can pack tighter. If so,
4918 return the new type. If not, return the original type. */
4920 static tree
4922 {
4925 tree old_field;
4927 /* Copy the name and flags from the old type to that of the new and set
4928 the alignment to try for an integral type. For QUAL_UNION_TYPE,
4929 also copy the size. */
4938 {
4941 }
4947 /* Now copy the fields, keeping the position and size. */
4950 {
4952 tree new_field;
4968 SET_DECL_ORIGINAL_FIELD
4977 }
4982 }
4983 \f
4984 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
4985 if needed. We have already verified that SIZE and TYPE are large enough.
4987 GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
4988 to issue a warning.
4990 IS_USER_TYPE is true if we must be sure we complete the original type.
4992 DEFINITION is true if this type is being defined.
4994 SAME_RM_SIZE is true if the RM_Size of the resulting type is to be
4995 set to its TYPE_SIZE; otherwise, it's set to the RM_Size of the original
4996 type. */
4998 tree
5002 {
5004 tree record;
5005 tree field;
5007 /* If TYPE is a padded type, see if it agrees with any size and alignment
5008 we were given. If so, return the original type. Otherwise, strip
5009 off the padding, since we will either be returning the inner type
5010 or repadding it. If no size or alignment is specified, use that of
5011 the original padded type. */
5014 {
5031 }
5033 /* If the size is either not being changed or is being made smaller (which
5034 is not done here (and is only valid for bitfields anyway), show the size
5035 isn't changing. Likewise, clear the alignment if it isn't being
5036 changed. Then return if we aren't doing anything. */
5050 /* We used to modify the record in place in some cases, but that could
5051 generate incorrect debugging information. So make a new record
5052 type and name. */
5058 /* If we were making a type, complete the original type and give it a
5059 name. */
5066 gnat_entity);
5068 /* If we are changing the alignment and the input type is a record with
5069 BLKmode and a small constant size, try to make a form that has an
5070 integral mode. That might allow this record to have an integral mode,
5071 which will be much more efficient. There is no point in doing this if a
5072 size is specified unless it is also smaller than the biggest alignment
5073 and it is incorrect to do this if the size of the original type is not a
5074 multiple of the alignment. */
5080 && (!size
5102 /* Keep the RM_Size of the padded record as that of the old record
5103 if requested. */
5106 /* Unless debugging information isn't being written for the input type,
5107 write a record that shows what we are a subtype of and also make a
5108 variable that indicates our size, if variable. */
5112 {
5133 }
5140 /* If the size was widened explicitly, maybe give a warning. */
5146 {
5159 /* Generate message only for entities that come from source, since
5160 if we have an entity created by expansion, the message will be
5161 generated for some other corresponding source entity. */
5164 gnat_entity,
5171 }
5174 }
5175 \f
5176 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
5177 the value passed against the list of choices. */
5179 tree
5181 {
5182 Node_Id choice;
5183 Node_Id gnat_temp;
5188 {
5190 {
5195 /* There's no good type to use here, so we might as well use
5196 integer_type_node. */
5197 this_test
5211 this_test
5221 /* This represents either a subtype range, an enumeration
5222 literal, or a constant Ekind says which. If an enumeration
5223 literal or constant, fall through to the next case. */
5226 {
5232 this_test
5239 }
5240 /* ... fall through ... */
5245 single);
5254 }
5258 }
5261 }
5262 \f
5263 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
5264 placed in GNU_RECORD_TYPE.
5266 PACKED is 1 if the enclosing record is packed and -1 if the enclosing
5267 record has a Component_Alignment of Storage_Unit.
5269 DEFINITION is true if this field is for a record being defined. */
5271 static tree
5274 {
5279 tree gnu_field;
5280 bool needs_strict_alignment
5284 /* If this field requires strict alignment or contains an item of
5285 variable sized, pretend it isn't packed. */
5289 /* For packed records, this is one of the few occasions on which we use
5290 the official RM size for discrete or fixed-point components, instead
5291 of the normal GNAT size stored in Esize. See description in Einfo:
5292 "Handling of Type'Size Values" for further details. */
5302 /* If we have a specified size that's smaller than that of the field type,
5303 or a position is specified, and the field type is also a record that's
5304 BLKmode and with a small constant size, see if we can get an integral
5305 mode form of the type when appropriate. If we can, show a size was
5306 specified for the field if there wasn't one already, so we know to make
5307 this a bitfield and avoid making things wider.
5309 Doing this is first useful if the record is packed because we can then
5310 place the field at a non-byte-aligned position and so achieve tighter
5311 packing.
5313 This is in addition *required* if the field shares a byte with another
5314 field and the front-end lets the back-end handle the references, because
5315 GCC does not handle BLKmode bitfields properly.
5317 We avoid the transformation if it is not required or potentially useful,
5318 as it might entail an increase of the field's alignment and have ripple
5319 effects on the outer record type. A typical case is a field known to be
5320 byte aligned and not to share a byte with another field.
5322 Besides, we don't even look the possibility of a transformation in cases
5323 known to be in error already, for instance when an invalid size results
5324 from a component clause. */
5331 || (gnu_size
5334 {
5335 /* See what the alternate type and size would be. */
5338 bool has_byte_aligned_clause
5343 /* Compute whether we should avoid the substitution. */
5345 /* There is no point substituting if there is no change. */
5347 ||
5348 /* ... nor when the field is known to be byte aligned and not to
5349 share a byte with another field. */
5350 (has_byte_aligned_clause
5352 ||
5353 /* The size of an aliased field must be an exact multiple of the
5354 type's alignment, which the substitution might increase. Reject
5355 substitutions that would so invalidate a component clause when the
5356 specified position is byte aligned, as the change would have no
5357 real benefit from the packing standpoint anyway. */
5359 && has_byte_aligned_clause
5361 );
5363 /* Substitute unless told otherwise. */
5365 {
5370 }
5371 }
5373 /* If we are packing the record and the field is BLKmode, round the
5374 size up to a byte boundary. */
5379 {
5384 /* Ensure the position does not overlap with the parent subtype,
5385 if there is one. */
5387 {
5388 tree gnu_parent
5394 {
5395 post_error_ne_tree
5399 }
5400 }
5402 /* If this field needs strict alignment, ensure the record is
5403 sufficiently aligned and that that position and size are
5404 consistent with the alignment. */
5406 {
5413 /* If Atomic, the size must match exactly that of the field. */
5416 {
5417 post_error_ne_tree
5423 }
5425 /* If Aliased, the size must match exactly the rounded size. We
5426 used to be more accommodating here and accept greater sizes, but
5427 fully supporting this case on big-endian platforms would require
5428 switching to a more involved layout for the field. */
5430 && gnu_size
5432 {
5433 post_error_ne_tree
5436 gnu_rounded_size);
5438 }
5443 {
5445 post_error_ne_num
5451 post_error_ne_num
5457 post_error_ne_num
5461 else
5465 }
5466 }
5470 }
5472 /* If the record has rep clauses and this is the tag field, make a rep
5473 clause for it as well. */
5476 {
5479 }
5481 /* We need to make the size the maximum for the type if it is
5482 self-referential and an unconstrained type. In that case, we can't
5483 pack the field since we can't make a copy to align it. */
5485 && !gnu_size
5488 {
5491 }
5493 /* If no size is specified (or if there was an error), don't specify a
5494 position. */
5497 else
5498 {
5499 /* If the field's type is justified modular, we would need to remove
5500 the wrapper to (better) meet the layout requirements. However we
5501 can do so only if the field is not aliased to preserve the unique
5502 layout and if the prescribed size is not greater than that of the
5503 packed array to preserve the justification. */
5511 gnu_field_type
5516 }
5521 /* Now create the decl for the field. */
5533 }
5534 \f
5535 /* Return true if TYPE is a type with variable size, a padding type with a
5536 field of variable size or is a record that has a field such a field. */
5538 static bool
5540 {
5541 tree field;
5543 /* We need not be concerned about this at all if we don't have
5544 strict alignment. */
5562 }
5563 \f
5564 /* Return a GCC tree for a record type given a GNAT Component_List and a chain
5565 of GCC trees for fields that are in the record and have already been
5566 processed. When called from gnat_to_gnu_entity during the processing of a
5567 record type definition, the GCC nodes for the discriminants will be on
5568 the chain. The other calls to this function are recursive calls from
5569 itself for the Component_List of a variant and the chain is empty.
5571 PACKED is 1 if this is for a record with "pragma pack" and -1 is this is
5572 for a record type with "pragma component_alignment (storage_unit)".
5574 DEFINITION is true if we are defining this record.
5576 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
5577 with a rep clause is to be added. If it is nonzero, that is all that
5578 should be done with such fields.
5580 CANCEL_ALIGNMENT, if true, means the alignment should be zeroed before
5581 laying out the record. This means the alignment only serves to force fields
5582 to be bitfields, but not require the record to be that aligned. This is
5583 used for variants.
5585 ALL_REP, if true, means a rep clause was found for all the fields. This
5586 simplifies the logic since we know we're not in the mixed case.
5588 DEFER_DEBUG, if true, means that the debugging routines should not be
5589 called when finishing constructing the record type.
5591 UNCHECKED_UNION, if tree, means that we are building a type for a record
5592 with a Pragma Unchecked_Union.
5594 The processing of the component list fills in the chain with all of the
5595 fields of the record and then the record type is finished. */
5597 static void
5602 {
5603 Node_Id component_decl;
5604 Entity_Id gnat_field;
5605 Node_Id variant_part;
5611 /* For each variable within each component declaration create a GCC field
5612 and add it to the list, skipping any pragmas in the list. */
5618 {
5623 else
5624 {
5628 /* If this is the _Tag field, put it before any discriminants,
5629 instead of after them as is the case for all other fields.
5630 Ignore field of void type if only annotating. */
5633 else
5634 {
5637 }
5638 }
5641 }
5643 /* At the end of the component list there may be a variant part. */
5646 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
5647 mutually exclusive and should go in the same memory. To do this we need
5648 to treat each variant as a record whose elements are created from the
5649 component list for the variant. So here we create the records from the
5650 lists for the variants and put them all into the QUAL_UNION_TYPE.
5651 If this is an Unchecked_Union, we make a UNION_TYPE instead or
5652 use GNU_RECORD_TYPE if there are no fields so far. */
5654 {
5656 Node_Id variant;
5658 tree gnu_var_name
5662 tree gnu_union_type;
5663 tree gnu_union_name;
5664 tree gnu_union_field;
5675 else
5676 {
5678 gnu_union_type
5683 }
5688 {
5690 tree gnu_inner_name;
5691 tree gnu_qual;
5699 /* Set the alignment of the inner type in case we need to make
5700 inner objects into bitfields, but then clear it out
5701 so the record actually gets only the alignment required. */
5705 /* Similarly, if the outer record has a size specified and all fields
5706 have record rep clauses, we can propagate the size into the
5707 variant part. */
5709 {
5713 }
5715 /* Create the record for the variant. Note that we defer emitting
5716 debug info for it until after we are sure to actually use it. */
5727 /* If this is an Unchecked_Union and we have exactly one field,
5728 use that field here. */
5732 else
5733 {
5734 /* Emit debug info for the record. We used to throw away
5735 empty records but we no longer do that because we need
5736 them to generate complete debug info for the variant;
5737 otherwise, the union type definition will be lacking
5738 the fields associated with these empty variants. */
5743 (all_rep_and_size
5746 (all_rep_and_size
5754 }
5758 }
5760 /* Only make the QUAL_UNION_TYPE if there are any non-empty variants. */
5762 {
5764 {
5768 }
5773 /* If GNU_UNION_TYPE is our record type, it means we must have an
5774 Unchecked_Union with no fields. Verify that and, if so, just
5775 return. */
5777 {
5780 }
5782 gnu_union_field
5784 packed,
5791 }
5792 }
5794 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses. If they
5795 do, pull them out and put them into GNU_OUR_REP_LIST. We have to do this
5796 in a separate pass since we want to handle the discriminants but can't
5797 play with them until we've used them in debugging data above.
5799 ??? Note: if we then reorder them, debugging information will be wrong,
5800 but there's nothing that can be done about this at the moment. */
5803 {
5805 {
5810 else
5816 }
5817 else
5818 {
5821 }
5822 }
5824 /* If we have any items in our rep'ed field list, it is not the case that all
5825 the fields in the record have rep clauses, and P_REP_LIST is nonzero,
5826 set it and ignore the items. */
5830 {
5831 /* Otherwise, sort the fields by bit position and put them into their
5832 own record if we have any fields without rep clauses. */
5833 tree gnu_rep_type
5845 /* Put the fields in the list in order of increasing position, which
5846 means we start from the end. */
5849 {
5853 }
5856 {
5862 }
5863 else
5864 {
5867 }
5868 }
5875 }
5876 \f
5877 /* Called via qsort from the above. Returns -1, 1, depending on the
5878 bit positions and ordinals of the two fields. Use DECL_UID to ensure
5879 a stable sort. */
5881 static int
5883 {
5891 else
5893 }
5894 \f
5895 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
5896 placed into an Esize, Component_Bit_Offset, or Component_Size value
5897 in the GNAT tree. */
5899 static Uint
5901 {
5903 TCode tcode;
5908 /* See if we've already saved the value for this node. */
5912 /* If we do not return inside this switch, TCODE will be set to the
5913 code to use for a Create_Node operand and LEN (set above) will be
5914 the number of recursive calls for us to make. */
5917 {
5922 /* This may have come from a conversion from some smaller type,
5923 so ensure this is in bitsizetype. */
5926 /* For negative values, use NEGATE_EXPR of the supplied value. */
5928 {
5929 /* The ridiculous code below is to handle the case of the largest
5930 negative integer. */
5933 tree temp;
5936 {
5937 negative_size
5940 bitsize_one_node));
5942 }
5949 }
5956 /* This peculiar test is to make sure that the size fits in an int
5957 on machines where HOST_WIDE_INT is not "int". */
5960 else
5964 /* The only case we handle here is a simple discriminant reference. */
5972 else
5978 /* Now just list the operations we handle. */
6010 }
6012 /* Now get each of the operands that's relevant for this code. If any
6013 cannot be expressed as a repinfo node, say we can't. */
6018 {
6022 }
6027 }
6029 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding
6030 GCC type, set Component_Bit_Offset and Esize to the position and size
6031 used by Gigi. */
6033 static void
6035 {
6036 tree gnu_list;
6037 tree gnu_entry;
6038 Entity_Id gnat_field;
6040 /* We operate by first making a list of all fields and their positions
6041 (we can get the sizes easily at any time) by a recursive call
6042 and then update all the sizes into the tree. */
6045 BIGGEST_ALIGNMENT);
6052 {
6056 gnu_list);
6059 {
6061 {
6062 /* In this mode the tag and parent components have not been
6063 generated, so we add the appropriate offset to each
6064 component. For a component appearing in the current
6065 extension, the offset is the size of the parent. */
6068 parent_offset
6070 bitsizetype);
6071 else
6073 }
6075 Set_Component_Bit_Offset
6077 annotate_value
6082 parent_offset)));
6086 }
6089 {
6090 /* If there is no gnu_entry, this is an inherited component whose
6091 position is the same as in the parent type. */
6092 Set_Component_Bit_Offset
6097 }
6098 }
6099 }
6101 /* Scan all fields in GNU_TYPE and build entries where TREE_PURPOSE is the
6102 FIELD_DECL and TREE_VALUE a TREE_LIST with TREE_PURPOSE being the byte
6103 position and TREE_VALUE being a TREE_LIST with TREE_PURPOSE the value to be
6104 placed into DECL_OFFSET_ALIGN and TREE_VALUE the bit position. GNU_POS is
6105 to be added to the position, GNU_BITPOS to the bit position, OFFSET_ALIGN is
6106 the present value of DECL_OFFSET_ALIGN and GNU_LIST is a list of the entries
6107 so far. */
6109 static tree
6112 {
6113 tree gnu_field;
6118 {
6123 unsigned int our_offset_align
6126 gnu_result
6131 NULL_TREE),
6132 gnu_result);
6135 gnu_result
6138 our_offset_align);
6139 }
6142 }
6143 \f
6144 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
6145 corresponding to GNAT_OBJECT. If size is valid, return a tree corresponding
6146 to its value. Otherwise return 0. KIND is VAR_DECL is we are specifying
6147 the size for an object, TYPE_DECL for the size of a type, and FIELD_DECL
6148 for the size of a field. COMPONENT_P is true if we are being called
6149 to process the Component_Size of GNAT_OBJECT. This is used for error
6150 message handling and to indicate to use the object size of GNU_TYPE.
6151 ZERO_OK is true if a size of zero is permitted; if ZERO_OK is false,
6152 it means that a size of zero should be treated as an unspecified size. */
6154 static tree
6157 {
6158 Node_Id gnat_error_node;
6159 tree type_size
6161 tree size;
6163 /* Find the node to use for errors. */
6170 else
6173 /* Return 0 if no size was specified, either because Esize was not Present or
6174 the specified size was zero. */
6178 /* Get the size as a tree. Give an error if a size was specified, but cannot
6179 be represented as in sizetype. */
6182 {
6187 }
6189 /* Ignore a negative size since that corresponds to our back-annotation.
6190 Also ignore a zero size unless a size clause exists. */
6194 /* The size of objects is always a multiple of a byte. */
6197 {
6201 else
6205 }
6207 /* If this is an integral type or a packed array type, the front-end has
6208 verified the size, so we need not do it here (which would entail
6209 checking against the bounds). However, if this is an aliased object, it
6210 may not be smaller than the type of the object. */
6215 /* If the object is a record that contains a template, add the size of
6216 the template to the specified size. */
6221 /* Modify the size of the type to be that of the maximum size if it has a
6222 discriminant or the size of a thin pointer if this is a fat pointer. */
6228 /* If this is an access type, the minimum size is that given by the smallest
6229 integral mode that's valid for pointers. */
6231 {
6237 ;
6240 }
6242 /* If the size of the object is a constant, the new size must not be
6243 smaller. */
6247 {
6249 post_error_ne_tree
6252 else
6259 post_error_ne_tree_2
6269 }
6272 }
6273 \f
6274 /* Similarly, but both validate and process a value of RM_Size. This
6275 routine is only called for types. */
6277 static void
6279 {
6280 /* Only give an error if a Value_Size clause was explicitly given.
6281 Otherwise, we'd be duplicating an error on the Size clause. */
6282 Node_Id gnat_attr_node
6285 tree size;
6287 /* Get the size as a tree. Do nothing if none was specified, either
6288 because RM_Size was not Present or if the specified size was zero.
6289 Give an error if a size was specified, but cannot be represented as
6290 in sizetype. */
6296 {
6299 gnat_entity);
6302 }
6304 /* Ignore a negative size since that corresponds to our back-annotation.
6305 Also ignore a zero size unless a size clause exists, a Value_Size
6306 clause exists, or this is an integer type, in which case the
6307 front end will have always set it. */
6314 /* If the old size is self-referential, get the maximum size. */
6318 /* If the size of the object is a constant, the new size must not be
6319 smaller (the front end checks this for scalar types). */
6324 {
6326 post_error_ne_tree
6331 }
6333 /* Otherwise, set the RM_Size. */
6344 }
6345 \f
6346 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
6347 If TYPE is the best type, return it. Otherwise, make a new type. We
6348 only support new integral and pointer types. BIASED_P is nonzero if
6349 we are making a biased type. */
6351 static tree
6353 {
6354 tree new_type;
6358 /* If size indicates an error, just return TYPE to avoid propagating the
6359 error. Likewise if it's too large to represent. */
6365 {
6368 /* Only do something if the type is not already the proper size and is
6369 not a packed array type. */
6381 new_type
6393 /* Do something if this is a fat pointer, in which case we
6394 may need to return the thin pointer. */
6396 return
6397 build_pointer_type
6402 /* Only do something if this is a thin pointer, in which case we
6403 may need to return the fat pointer. */
6405 return
6412 }
6415 }
6416 \f
6417 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
6418 a type or object whose present alignment is ALIGN. If this alignment is
6419 valid, return it. Otherwise, give an error and return ALIGN. */
6421 static unsigned int
6423 {
6427 #ifndef MAX_OFILE_ALIGNMENT
6428 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
6429 #endif
6434 /* Don't worry about checking alignment if alignment was not specified
6435 by the source program and we already posted an error for this entity. */
6440 /* Within GCC, an alignment is an integer, so we must make sure a
6441 value is specified that fits in that range. Also, alignments of
6442 more than MAX_OFILE_ALIGNMENT can't be supported. */
6456 else
6460 }
6461 \f
6462 /* Verify that OBJECT, a type or decl, is something we can implement
6463 atomically. If not, give an error for GNAT_ENTITY. COMP_P is true
6464 if we require atomic components. */
6466 static void
6468 {
6470 Node_Id gnat_node;
6473 tree size;
6475 /* There are three case of what OBJECT can be. It can be a type, in which
6476 case we take the size, alignment and mode from the type. It can be a
6477 declaration that was indirect, in which case the relevant values are
6478 that of the type being pointed to, or it can be a normal declaration,
6479 in which case the values are of the decl. The code below assumes that
6480 OBJECT is either a type or a decl. */
6482 {
6486 }
6488 {
6492 }
6493 else
6494 {
6498 }
6500 /* Consider all floating-point types atomic and any types that that are
6501 represented by integers no wider than a machine word. */
6508 /* For the moment, also allow anything that has an alignment equal
6509 to its size and which is smaller than a word. */
6517 {
6525 }
6530 else
6533 }
6534 \f
6535 /* Check if FTYPE1 and FTYPE2, two potentially different function type nodes,
6536 have compatible signatures so that a call using one type may be safely
6537 issued if the actual target function type is the other. Return 1 if it is
6538 the case, 0 otherwise, and post errors on the incompatibilities.
6540 This is used when an Ada subprogram is mapped onto a GCC builtin, to ensure
6541 that calls to the subprogram will have arguments suitable for the later
6542 underlying builtin expansion. */
6544 static int
6546 {
6547 /* As of now, we only perform very trivial tests and consider it's the
6548 programmer's responsibility to ensure the type correctness in the Ada
6549 declaration, as in the regular Import cases.
6551 Mismatches typically result in either error messages from the builtin
6552 expander, internal compiler errors, or in a real call sequence. This
6553 should be refined to issue diagnostics helping error detection and
6554 correction. */
6556 /* Almost fake test, ensuring a use of each argument. */
6561 }
6562 \f
6563 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new type
6564 with all size expressions that contain F updated by replacing F with R.
6565 This is identical to GCC's substitute_in_type except that it knows about
6566 TYPE_INDEX_TYPE. If F is NULL_TREE, always make a new RECORD_TYPE, even if
6567 nothing has changed. */
6569 tree
6571 {
6573 tree tem;
6576 {
6582 {
6591 SET_TYPE_INDEX_TYPE
6594 }
6601 {
6615 }
6629 /* Don't know how to do these yet. */
6633 {
6647 /* If we had bounded the sizes of T by a constant, bound the sizes of
6648 NEW by the same constant. */
6658 }
6663 {
6664 tree field;
6665 bool changed_field
6672 /* Start out with no fields, make new fields, and chain them
6673 in. If we haven't actually changed the type of any field,
6674 discard everything we've done and return the old type. */
6680 {
6691 /* If this is an internal field and the type of this field is
6692 a UNION_TYPE or RECORD_TYPE with no elements, ignore it. If
6693 the type just has one element, treat that as the field.
6694 But don't do this if we are processing a QUAL_UNION_TYPE. */
6699 {
6704 {
6705 tree next_new_field
6708 /* Make sure omitting the union doesn't change
6709 the layout. */
6712 }
6713 }
6720 /* If the size of the old field was set at a constant,
6721 propagate the size in case the type's size was variable.
6722 (This occurs in the case of a variant or discriminated
6723 record with a default size used as a field of another
6724 record.) */
6733 {
6739 /* Do the substitution inside the qualifier and if we find
6740 that this field will not be present, omit it. */
6745 }
6749 else
6754 /* If this is a qualified type and this field will always be
6755 present, we are done. */
6759 }
6761 /* If this used to be a qualified union type, but we now know what
6762 field will be present, make this a normal union. */
6773 /* If the size was originally a constant use it. */
6776 {
6780 }
6783 }
6787 }
6788 }
6789 \f
6790 /* Return the "RM size" of GNU_TYPE. This is the actual number of bits
6791 needed to represent the object. */
6793 tree
6795 {
6796 /* For integer types, this is the precision. For record types, we store
6797 the size explicitly. For other types, this is just the size. */
6803 /* Return the rm_size of the actual data plus the size of the template. */
6804 return
6814 else
6816 }
6817 \f
6818 /* Return an identifier representing the external name to be used for
6819 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
6820 and the specified suffix. */
6822 tree
6824 {
6833 /* A variable using the Stdcall convention (meaning we are running
6834 on a Windows box) live in a DLL. Here we adjust its name to use
6835 the jump-table, the _imp__NAME contains the address for the NAME
6836 variable. */
6839 {
6846 }
6849 }
6851 /* Return the name to be used for GNAT_ENTITY. If a type, create a
6852 fully-qualified name, possibly with type information encoding.
6853 Otherwise, return the name. */
6855 tree
6857 {
6860 }
6862 /* Given GNU_ID, an IDENTIFIER_NODE containing a name and SUFFIX, a
6863 string, return a new IDENTIFIER_NODE that is the concatenation of
6864 the name in GNU_ID and SUFFIX. */
6866 tree
6868 {
6877 }