| blob | a7ee5ce2be8fc0dd610db69cf51c45ffed4acc5e |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * D E C L *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2007, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 2, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License distributed with GNAT; see file COPYING. If not, write *
19 * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, *
20 * Boston, MA 02110-1301, USA. *
21 * *
22 * GNAT was originally developed by the GNAT team at New York University. *
23 * Extensive contributions were provided by Ada Core Technologies Inc. *
24 * *
25 ****************************************************************************/
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
182 /* Since a use of an Itype is a definition, process it as such if it
183 is not in a with'ed unit. */
188 {
189 /* Ensure that we are in a subprogram mentioned in the Scope
190 chain of this entity, our current scope is global,
191 or that we encountered a task or entry (where we can't currently
192 accurately check scoping). */
195 {
198 }
202 {
207 gnat_temp
219 && (current_function_decl
221 {
224 }
225 }
227 /* This abort means the entity "gnat_entity" has an incorrect scope,
228 i.e. that its scope does not correspond to the subprogram in which
229 it is declared */
231 }
233 /* If this is entity 0, something went badly wrong. */
236 /* If we've already processed this entity, return what we got last time.
237 If we are defining the node, we should not have already processed it.
238 In that case, we will abort below when we try to save a new GCC tree for
239 this object. We also need to handle the case of getting a dummy type
240 when a Full_View exists. */
243 && (! definition
245 {
252 {
258 }
261 }
263 /* If this is a numeric or enumeral type, or an access type, a nonzero
264 Esize must be specified unless it was specified by the programmer. */
272 /* Likewise, RM_Size must be specified for all discrete and fixed-point
273 types. */
277 /* Get the name of the entity and set up the line number and filename of
278 the original definition for use in any decl we make. */
282 /* If we get here, it means we have not yet done anything with this
283 entity. If we are not defining it here, it must be external,
284 otherwise we should have defined it already. */
291 /* For cases when we are not defining (i.e., we are referencing from
292 another compilation unit) Public entities, show we are at global level
293 for the purpose of computing scopes. Don't do this for components or
294 discriminants since the relevant test is whether or not the record is
295 being defined. But do this for Imported functions or procedures in
296 all cases. */
304 /* Handle any attributes directly attached to the entity. */
308 /* Machine_Attributes on types are expected to be propagated to subtypes.
309 The corresponding Gigi_Rep_Items are only attached to the first subtype
310 though, so we handle the propagation here. */
317 {
319 /* If this is a use of a deferred constant, get its full
320 declaration. */
322 {
327 }
329 /* If we have an external constant that we are not defining,
330 get the expression that is was defined to represent. We
331 may throw that expression away later if it is not a
332 constant.
333 Do not retrieve the expression if it is an aggregate, because
334 in complex instantiation contexts it may not be expanded */
343 /* Ignore deferred constant definitions; they are processed fully in the
344 front-end. For deferred constant references, get the full
345 definition. On the other hand, constants that are renamings are
346 handled like variable renamings. If No_Initialization is set, this is
347 not a deferred constant but a constant whose value is built
348 manually. */
353 {
357 }
360 {
365 }
370 /* We used to special case VMS exceptions here to directly map them to
371 their associated condition code. Since this code had to be masked
372 dynamically to strip off the severity bits, this caused trouble in
373 the GCC/ZCX case because the "type" pointers we store in the tables
374 have to be static. We now don't special case here anymore, and let
375 the regular processing take place, which leaves us with a regular
376 exception data object for VMS exceptions too. The condition code
377 mapping is taken care of by the front end and the bitmasking by the
378 runtime library. */
383 {
384 /* The GNAT record where the component was defined. */
387 /* If the variable is an inherited record component (in the case of
388 extended record types), just return the inherited entity, which
389 must be a FIELD_DECL. Likewise for discriminants.
390 For discriminants of untagged records which have explicit
391 stored discriminants, return the entity for the corresponding
392 stored discriminant. Also use Original_Record_Component
393 if the record has a private extension. */
397 {
398 gnu_decl
403 }
405 /* If the enclosing record has explicit stored discriminants,
406 then it is an untagged record. If the Corresponding_Discriminant
407 is not empty then this must be a renamed discriminant and its
408 Original_Record_Component must point to the corresponding explicit
409 stored discriminant (i.e., we should have taken the previous
410 branch). */
414 {
415 /* A tagged record has no explicit stored discriminants. */
419 gnu_decl
424 }
428 {
433 }
435 /* If the enclosing record has explicit stored discriminants,
436 then it is an untagged record. If the Corresponding_Discriminant
437 is not empty then this must be a renamed discriminant and its
438 Original_Record_Component must point to the corresponding explicit
439 stored discriminant (i.e., we should have taken the first
440 branch). */
447 /* Otherwise, if we are not defining this and we have no GCC type
448 for the containing record, make one for it. Then we should
449 have made our own equivalent. */
451 {
452 /* ??? If this is in a record whose scope is a protected
453 type and we have an Original_Record_Component, use it.
454 This is a workaround for major problems in protected type
455 handling. */
463 {
464 gnu_decl
470 }
476 }
478 else
479 /* Here we have no GCC type and this is a reference rather than a
480 definition. This should never happen. Most likely the cause is a
481 reference before declaration in the gnat tree for gnat_entity. */
483 }
489 /* Simple variables, loop variables, OUT parameters, and exceptions. */
490 object:
491 {
493 bool const_flag
508 {
512 else
514 }
516 /* Get the type after elaborating the renamed object. */
519 /* If this is a loop variable, its type should be the base type.
520 This is because the code for processing a loop determines whether
521 a normal loop end test can be done by comparing the bounds of the
522 loop against those of the base type, which is presumed to be the
523 size used for computation. But this is not correct when the size
524 of the subtype is smaller than the type. */
528 /* Reject non-renamed objects whose types are unconstrained arrays or
529 any object whose type is a dummy type or VOID_TYPE. */
535 {
538 force_global--;
540 }
542 /* If an alignment is specified, use it if valid. Note that
543 exceptions are objects but don't have alignments. We must do this
544 before we validate the size, since the alignment can affect the
545 size. */
547 {
553 }
555 /* If we are defining the object, see if it has a Size value and
556 validate it if so. If we are not defining the object and a Size
557 clause applies, simply retrieve the value. We don't want to ignore
558 the clause and it is expected to have been validated already. Then
559 get the new type, if any. */
568 {
569 gnu_type
575 }
577 /* If this object has self-referential size, it must be a record with
578 a default value. We are supposed to allocate an object of the
579 maximum size in this case unless it is a constant with an
580 initializing expression, in which case we can get the size from
581 that. Note that the resulting size may still be a variable, so
582 this may end up with an indirect allocation. */
586 {
588 gnu_size
589 = SUBSTITUTE_PLACEHOLDER_IN_EXPR
592 /* We may have no GNU_EXPR because No_Initialization is
593 set even though there's an Expression. */
598 gnu_size
600 (Etype
602 else
603 {
606 }
607 }
609 /* If the size is zero bytes, make it one byte since some linkers have
610 trouble with zero-sized objects. If the object will have a
611 template, that will make it nonzero so don't bother. Also avoid
612 doing that for an object renaming or an object with an address
613 clause, as we would lose useful information on the view size
614 (e.g. for null array slices) and we are not allocating the object
615 here anyway. */
624 /* If this is an atomic object with no specified size and alignment,
625 but where the size of the type is a constant, set the alignment to
626 the lowest power of two greater than the size, or to the
627 biggest meaningful alignment, whichever is smaller. */
631 {
634 BIGGEST_ALIGNMENT))
636 else
641 }
643 /* If the object is set to have atomic components, find the component
644 type and validate it.
646 ??? Note that we ignore Has_Volatile_Components on objects; it's
647 not at all clear what to do in that case. */
650 {
659 }
661 /* Now check if the type of the object allows atomic access. Note
662 that we must test the type, even if this object has size and
663 alignment to allow such access, because we will be going
664 inside the padded record to assign to the object. We could fix
665 this by always copying via an intermediate value, but it's not
666 clear it's worth the effort. */
670 /* If this is an aliased object with an unconstrained nominal subtype,
671 make a type that includes the template. */
675 {
676 tree gnu_fat
679 gnu_type
683 }
685 #ifdef MINIMUM_ATOMIC_ALIGNMENT
686 /* If the size is a constant and no alignment is specified, force
687 the alignment to be the minimum valid atomic alignment. The
688 restriction on constant size avoids problems with variable-size
689 temporaries; if the size is variable, there's no issue with
690 atomic access. Also don't do this for a constant, since it isn't
691 necessary and can interfere with constant replacement. Finally,
692 do not do it for Out parameters since that creates an
693 size inconsistency with In parameters. */
702 #endif
704 /* Make a new type with the desired size and alignment, if needed. */
708 /* Make a volatile version of this object's type if we are to
709 make the object volatile. Note that 13.3(19) says that we
710 should treat other types of objects as volatile as well. */
720 /* Convert the expression to the type of the object except in the
721 case where the object's type is unconstrained or the object's type
722 is a padded record whose field is of self-referential size. In
723 the former case, converting will generate unnecessary evaluations
724 of the CONSTRUCTOR to compute the size and in the latter case, we
725 want to only copy the actual data. */
731 && (CONTAINS_PLACEHOLDER_P
735 /* See if this is a renaming, and handle appropriately depending on
736 what is renamed and in which context. There are three major
737 cases:
739 1/ This is a constant renaming and we can just make an object
740 with what is renamed as its initial value,
742 2/ We can reuse a stabilized version of what is renamed in place
743 of the renaming,
745 3/ If neither 1 or 2 applies, we make the renaming entity a constant
746 pointer to what is being renamed. */
749 {
750 /* If the renamed object had padding, strip off the reference
751 to the inner object and reset our type. */
755 && (TYPE_IS_PADDING_P
757 {
760 }
762 /* Case 1: If this is a constant renaming, treat it as a normal
763 object whose initial value is what is being renamed. We cannot
764 do this if the type is unconstrained or class-wide. */
771 ;
773 /* Otherwise, see if we can proceed with a stabilized version of
774 the renamed entity or if we need to make a pointer. */
775 else
776 {
780 /* Case 2: If the renaming entity need not be materialized and
781 the renamed expression is something we can stabilize, use
782 that for the renaming. At the global level, we can only do
783 this if we know no SAVE_EXPRs need be made, because the
784 expression we return might be used in arbitrary conditional
785 branches so we must force the SAVE_EXPRs evaluation
786 immediately and this requires a function context. */
791 {
792 maybe_stable_expr
797 {
802 }
804 /* The stabilization failed. Keep maybe_stable_expr
805 untouched here to let the pointer case below know
806 about that failure. */
807 }
809 /* Case 3: Make this into a constant pointer to the object we
810 are to rename and attach the object to the pointer if it is
811 an lvalue that can be stabilized.
813 From the proper scope, attached objects will be referenced
814 directly instead of indirectly via the pointer to avoid
815 subtle aliasing problems with non addressable entities.
816 They have to be stable because we must not evaluate the
817 variables in the expression every time the renaming is used.
818 They also have to be lvalues because the context in which
819 they are reused sometimes requires so. We call pointers
820 with an attached object "renaming" pointers.
822 In the rare cases where we cannot stabilize the renamed
823 object, we just make a "bare" pointer, and the renamed
824 entity is always accessed indirectly through it. */
825 {
830 /* If a previous attempt at unrestricted stabilization
831 failed, there is no point trying again and we can reuse
832 the result without attaching it to the pointer. In this
833 case it will only be used as the initializing expression
834 of the pointer and thus needs no special treatment with
835 regard to multiple evaluations. */
837 ;
839 /* Otherwise, try to stabilize now, restricting to lvalues
840 only, and attach the expression to the pointer if the
841 stabilization succeeds.
843 Note that this might introduce SAVE_EXPRs and we don't
844 check whether we're at the global level or not. This is
845 fine since we are building a pointer initializer and
846 neither the pointer nor the initializing expression can
847 be accessed before the pointer elaboration has taken
848 place in a correct program.
850 SAVE_EXPRs will be evaluated at the right spots by either
851 create_var_decl->expand_decl_init for the non-global case
852 or build_unit_elab for the global case, and will be
853 attached to the elaboration procedure by the RTL expander
854 in the latter case. We have no need to force an early
855 evaluation here. */
856 else
857 {
858 maybe_stable_expr
865 /* Attaching is actually performed downstream, as soon
866 as we have a VAR_DECL for the pointer we make. */
867 }
869 gnu_expr
874 }
875 }
876 }
878 /* If this is an aliased object whose nominal subtype is unconstrained,
879 the object is a record that contains both the template and
880 the object. If there is an initializer, it will have already
881 been converted to the right type, but we need to create the
882 template if there is no initializer. */
885 /* Beware that padding might have been introduced
886 via maybe_pad_type above. */
889 == RECORD_TYPE
890 && TYPE_CONTAINS_TEMPLATE_P
893 {
894 tree template_field
899 gnu_expr
900 = gnat_build_constructor
902 tree_cons
906 NULL_TREE),
907 NULL_TREE));
908 }
910 /* If this is a pointer and it does not have an initializing
911 expression, initialize it to NULL, unless the object is
912 imported. */
918 /* If we are defining the object and it has an Address clause we must
919 get the address expression from the saved GCC tree for the
920 object if the object has a Freeze_Node. Otherwise, we elaborate
921 the address expression here since the front-end has guaranteed
922 in that case that the elaboration has no effects. Note that
923 only the latter mechanism is currently in use. */
925 {
926 tree gnu_address
932 /* Ignore the size. It's either meaningless or was handled
933 above. */
935 /* The address expression contains a conversion from pointer type
936 to the system__address integer type, which means the address
937 of the underlying object escapes. We therefore have no other
938 choice than forcing the type of the object being defined to
939 alias everything in order to make type-based alias analysis
940 aware that it will dereference the escaped address.
941 ??? This uncovers problems in ACATS at -O2 with the volatility
942 of the original type: it may not be correctly propagated, thus
943 causing PRE to enter an infinite loop creating value numbers
944 out of volatile expressions. Disable it for now. */
945 gnu_type
951 /* If we don't have an initializing expression for the underlying
952 variable, the initializing expression for the pointer is the
953 specified address. Otherwise, we have to make a COMPOUND_EXPR
954 to assign both the address and the initial value. */
957 else
958 gnu_expr
960 build_binary_op
963 gnu_address),
964 gnu_expr),
965 gnu_address);
966 }
968 /* If it has an address clause and we are not defining it, mark it
969 as an indirect object. Likewise for Stdcall objects that are
970 imported. */
974 {
975 /* See the definition case above for the rationale. */
976 gnu_type
981 /* No point in taking the address of an initializing expression
982 that isn't going to be used. */
985 }
987 /* If we are at top level and this object is of variable size,
988 make the actual type a hidden pointer to the real type and
989 make the initializer be a memory allocation and initialization.
990 Likewise for objects we aren't defining (presumed to be
991 external references from other packages), but there we do
992 not set up an initialization.
994 If the object's size overflows, make an allocator too, so that
995 Storage_Error gets raised. Note that we will never free
996 such memory, so we presume it never will get allocated. */
1001 || (gnu_size
1005 {
1011 /* In case this was a aliased object whose nominal subtype is
1012 unconstrained, the pointer above will be a thin pointer and
1013 build_allocator will automatically make the template.
1015 If we have a template initializer only (that we made above),
1016 pretend there is none and rely on what build_allocator creates
1017 again anyway. Otherwise (if we have a full initializer), get
1018 the data part and feed that to build_allocator.
1020 If we are elaborating a mutable object, tell build_allocator to
1021 ignore a possibly simpler size from the initializer, if any, as
1022 we must allocate the maximum possible size in this case. */
1025 {
1030 {
1031 gnu_alloc_type
1038 else
1039 gnu_expr
1040 = build_component_ref
1044 }
1050 gnat_entity);
1054 }
1055 else
1056 {
1059 }
1060 }
1062 /* If this object would go into the stack and has an alignment
1063 larger than the default largest alignment, make a variable
1064 to hold the "aligning type" with a modified initial value,
1065 if any, then point to it and make that the value of this
1066 variable, which is now indirect. */
1069 {
1070 tree gnu_new_type
1073 tree gnu_new_var;
1075 gnu_new_var
1081 add_stmt_with_node
1083 build_component_ref
1086 gnu_expr),
1087 gnat_entity);
1090 gnu_expr
1091 = build_unary_op
1099 }
1105 /* Convert the expression to the type of the object except in the
1106 case where the object's type is unconstrained or the object's type
1107 is a padded record whose field is of self-referential size. In
1108 the former case, converting will generate unnecessary evaluations
1109 of the CONSTRUCTOR to compute the size and in the latter case, we
1110 want to only copy the actual data. */
1116 && (CONTAINS_PLACEHOLDER_P
1120 /* If this name is external or there was a name specified, use it,
1121 unless this is a VMS exception object since this would conflict
1122 with the symbol we need to export in addition. Don't use the
1123 Interface_Name if there is an address clause (see CD30005). */
1132 /* If this is constant initialized to a static constant and the
1133 object has an aggregate type, force it to be statically
1134 allocated. */
1150 {
1153 {
1156 }
1157 }
1164 STACK_CHECK_MAX_VAR_SIZE))))
1169 gnat_entity);
1171 /* If this is a public constant or we're not optimizing and we're not
1172 making a VAR_DECL for it, make one just for export or debugger
1173 use. Likewise if the address is taken or if the object or type is
1174 aliased. */
1181 {
1182 tree gnu_corr_var
1188 }
1190 /* If this is declared in a block that contains a block with an
1191 exception handler, we must force this variable in memory to
1192 suppress an invalid optimization. */
1197 /* Back-annotate the Alignment of the object if not already in the
1198 tree. Likewise for Esize if the object is of a constant size.
1199 But if the "object" is actually a pointer to an object, the
1200 alignment and size are the same as the type, so don't back-annotate
1201 the values for the pointer. */
1208 {
1213 gnu_back_size
1218 }
1219 }
1223 /* Return a TYPE_DECL for "void" that we previously made. */
1228 /* A special case, for the types Character and Wide_Character in
1229 Standard, we do not list all the literals. So if the literals
1230 are not specified, make this an unsigned type. */
1232 {
1236 /* Set the TYPE_STRING_FLAG for Ada Character and
1237 Wide_Character types. This is needed by the dwarf-2 debug writer to
1238 distinguish between unsigned integer types and character types. */
1241 }
1243 /* Normal case of non-character type, or non-Standard character type */
1244 {
1245 /* Here we have a list of enumeral constants in First_Literal.
1246 We make a CONST_DECL for each and build into GNU_LITERAL_LIST
1247 the list to be places into TYPE_FIELDS. Each node in the list
1248 is a TREE_LIST node whose TREE_VALUE is the literal name
1249 and whose TREE_PURPOSE is the value of the literal.
1251 Esize contains the number of bits needed to represent the enumeral
1252 type, Type_Low_Bound also points to the first literal and
1253 Type_High_Bound points to the last literal. */
1255 Entity_Id gnat_literal;
1260 else
1268 {
1270 gnu_type);
1271 tree gnu_literal
1279 }
1283 /* Note that the bounds are updated at the end of this function
1284 because to avoid an infinite recursion when we get the bounds of
1285 this type, since those bounds are objects of this type. */
1286 }
1292 /* For integer types, just make a signed type the appropriate number
1293 of bits. */
1298 /* For modular types, make the unsigned type of the proper number of
1299 bits and then set up the modulus, if required. */
1300 {
1302 tree gnu_modulus;
1308 /* Find the smallest mode at least ESIZE bits wide and make a class
1309 using that mode. */
1314 ;
1320 /* Get the modulus in this type. If it overflows, assume it is because
1321 it is equal to 2**Esize. Note that there is no overflow checking
1322 done on unsigned type, so we detect the overflow by looking for
1323 a modulus of zero, which is otherwise invalid. */
1327 {
1332 }
1334 /* If we have to set TYPE_PRECISION different from its natural value,
1335 make a subtype to do do. Likewise if there is a modulus and
1336 it is not one greater than TYPE_MAX_VALUE. */
1340 {
1357 }
1358 }
1367 /* For integral subtypes, we make a new INTEGER_TYPE. Note
1368 that we do not want to call build_range_type since we would
1369 like each subtype node to be distinct. This will be important
1370 when memory aliasing is implemented.
1372 The TREE_TYPE field of the INTEGER_TYPE we make points to the
1373 parent type; this fact is used by the arithmetic conversion
1374 functions.
1376 We elaborate the Ancestor_Subtype if it is not in the current
1377 unit and one of our bounds is non-static. We do this to ensure
1378 consistent naming in the case where several subtypes share the same
1379 bounds by always elaborating the first such subtype first, thus
1380 using its name. */
1392 {
1395 }
1403 gnat_entity,
1410 gnat_entity,
1414 /* One of the above calls might have caused us to be elaborated,
1415 so don't blow up if so. */
1417 {
1420 }
1425 /* This should be an unsigned type if the lower bound is constant
1426 and non-negative or if the base type is unsigned; a signed type
1427 otherwise. */
1437 /* Inherit our alias set from what we're a subtype of. Subtypes
1438 are not different types and a pointer can designate any instance
1439 within a subtype hierarchy. */
1442 /* If the type we are dealing with is to represent a packed array,
1443 we need to have the bits left justified on big-endian targets
1444 and right justified on little-endian targets. We also need to
1445 ensure that when the value is read (e.g. for comparison of two
1446 such values), we only get the good bits, since the unused bits
1447 are uninitialized. Both goals are accomplished by wrapping the
1448 modular value in an enclosing struct. */
1450 {
1452 tree gnu_field;
1461 /* Create a stripped-down declaration of the original type, mainly
1462 for debugging. */
1466 /* Don't notify the field as "addressable", since we won't be taking
1467 it's address and it would prevent create_field_decl from making a
1468 bitfield. */
1477 }
1482 /* If this is a VAX floating-point type, use an integer of the proper
1483 size. All the operations will be handled with ASM statements. */
1485 {
1490 sizetype));
1492 }
1494 /* The type of the Low and High bounds can be our type if this is
1495 a type from Standard, so set them at the end of the function. */
1503 {
1506 }
1508 {
1535 /* One of the above calls might have caused us to be elaborated,
1536 so don't blow up if so. */
1538 {
1541 }
1545 /* Inherit our alias set from what we're a subtype of, as for
1546 integer subtypes. */
1548 }
1551 /* Array and String Types and Subtypes
1553 Unconstrained array types are represented by E_Array_Type and
1554 constrained array types are represented by E_Array_Subtype. There
1555 are no actual objects of an unconstrained array type; all we have
1556 are pointers to that type.
1558 The following fields are defined on array types and subtypes:
1560 Component_Type Component type of the array.
1561 Number_Dimensions Number of dimensions (an int).
1562 First_Index Type of first index. */
1566 {
1572 int firstdim
1574 int nextdim
1580 tree gnu_max_size_unit;
1582 Entity_Id gnat_ind_subtype;
1583 Entity_Id gnat_ind_base_subtype;
1584 tree gnu_template_reference;
1585 tree tem;
1593 /* Make a node for the array. If we are not defining the array
1594 suppress expanding incomplete types. */
1600 /* Build the fat pointer type. Use a "void *" object instead of
1601 a pointer to the array type since we don't have the array type
1602 yet (it will reference the fat pointer via the bounds). */
1605 ptr_void_type_node,
1608 gnu_ptr_template,
1611 /* Make sure we can put this into a register. */
1615 /* Build a reference to the template from a PLACEHOLDER_EXPR that
1616 is the fat pointer. This will be used to access the individual
1617 fields once we build them. */
1621 gnu_template_reference
1625 /* Now create the GCC type for each index and add the fields for
1626 that index to the template. */
1628 gnat_ind_base_subtype
1634 {
1636 tree gnu_ind_subtype
1638 tree gnu_base_subtype
1640 tree gnu_base_min
1642 tree gnu_base_max
1646 /* Make the FIELD_DECLs for the minimum and maximum of this
1647 type and then make extractions of that field from the
1648 template. */
1651 gnu_ind_subtype,
1655 gnu_ind_subtype,
1664 /* We can't use build_component_ref here since the template
1665 type isn't complete yet. */
1668 NULL_TREE);
1671 NULL_TREE);
1674 /* Make a range type with the new ranges, but using
1675 the Ada subtype. Then we convert to sizetype. */
1681 /* Update the maximum size of the array, in elements. */
1682 gnu_max_size
1686 gnu_base_min)));
1690 }
1693 gnu_template_fields
1696 /* Install all the fields into the template. */
1701 /* Now make the array of arrays and update the pointer to the array
1702 in the fat pointer. Note that it is the first field. */
1706 /* Get and validate any specified Component_Size, but if Packed,
1707 ignore it since the front end will have taken care of it. */
1708 gnu_comp_size
1710 gnat_entity,
1718 /* If the component type is a RECORD_TYPE that has a self-referential
1719 size, use the maxium size. */
1725 {
1729 }
1735 /* If Component_Size is not already specified, annotate it with the
1736 size of the component. */
1746 gnu_max_size),
1750 {
1754 /* If the type below this is a multi-array type, then this
1755 does not have aliased components. But we have to make
1756 them addressable if it must be passed by reference or
1757 if that is the default. */
1764 }
1766 /* If an alignment is specified, use it if valid. But ignore it for
1767 types that represent the unpacked base type for packed arrays. */
1770 {
1775 }
1781 /* The result type is an UNCONSTRAINED_ARRAY_TYPE that indicates the
1782 corresponding fat pointer. */
1789 /* If the maximum size doesn't overflow, use it. */
1804 /* Create a record type for the object and its template and
1805 set the template at a negative offset. */
1817 /* Give the thin pointer type a name. */
1821 gnat_entity);
1822 }
1828 /* This is the actual data type for array variables. Multidimensional
1829 arrays are implemented in the gnu tree as arrays of arrays. Note
1830 that for the moment arrays which have sparse enumeration subtypes as
1831 index components create sparse arrays, which is obviously space
1832 inefficient but so much easier to code for now.
1834 Also note that the subtype never refers to the unconstrained
1835 array type, which is somewhat at variance with Ada semantics.
1837 First check to see if this is simply a renaming of the array
1838 type. If so, the result is the array type. */
1843 else
1844 {
1847 int first_dim
1850 int next_dim
1852 Entity_Id gnat_ind_subtype;
1853 Entity_Id gnat_ind_base_subtype;
1858 tree gnu_max_size_unit;
1862 /* First create the gnu types for each index. Create types for
1863 debugging information to point to the index types if the
1864 are not integer types, have variable bounds, or are
1865 wider than sizetype. */
1868 gnat_ind_base_subtype
1874 {
1875 tree gnu_index_subtype
1877 tree gnu_min
1879 tree gnu_max
1881 tree gnu_base_subtype
1883 tree gnu_base_min
1885 tree gnu_base_max
1888 tree gnu_base_base_min
1890 tree gnu_base_base_max
1892 tree gnu_high;
1893 tree gnu_this_max;
1895 /* If the minimum and maximum values both overflow in
1896 SIZETYPE, but the difference in the original type
1897 does not overflow in SIZETYPE, ignore the overflow
1898 indications. */
1906 && (!TREE_OVERFLOW
1912 /* Similarly, if the range is null, use bounds of 1..0 for
1913 the sizetype bounds. */
1925 /* Now compute the size of this bound. We need to provide
1926 GCC with an upper bound to use but have to deal with the
1927 "superflat" case. There are three ways to do this. If we
1928 can prove that the array can never be superflat, we can
1929 just use the high bound of the index subtype. If we can
1930 prove that the low bound minus one can't overflow, we
1931 can do this as MAX (hb, lb - 1). Otherwise, we have to use
1932 the expression hb >= lb ? hb : lb - 1. */
1935 /* See if the base array type is already flat. If it is, we
1936 are probably compiling an ACVC test, but it will cause the
1937 code below to malfunction if we don't handle it specially. */
1945 /* If gnu_high is now an integer which overflowed, the array
1946 cannot be superflat. */
1953 else
1954 gnu_high
1955 = build_cond_expr
1963 /* Also compute the maximum size of the array. Here we
1964 see if any constraint on the index type of the base type
1965 can be used in the case of self-referential bound on
1966 the index type of the subtype. We look for a non-"infinite"
1967 and non-self-referential bound from any type involved and
1968 handle each bound separately. */
1997 gnu_this_max
2001 gnu_base_min)),
2002 size_zero_node);
2008 gnu_max_size
2022 }
2024 /* Then flatten: create the array of arrays. */
2028 /* One of the above calls might have caused us to be elaborated,
2029 so don't blow up if so. */
2031 {
2034 }
2036 /* Get and validate any specified Component_Size, but if Packed,
2037 ignore it since the front end will have taken care of it. */
2038 gnu_comp_size
2040 gnat_entity,
2045 /* If the component type is a RECORD_TYPE that has a self-referential
2046 size, use the maxium size. */
2052 {
2057 }
2071 {
2075 /* If the type below this is a multi-array type, then this
2076 does not have aliased components. But we have to make
2077 them addressable if it must be passed by reference or
2078 if that is the default. */
2085 }
2087 /* If we are at file level and this is a multi-dimensional array, we
2088 need to make a variable corresponding to the stride of the
2089 inner dimensions. */
2091 {
2093 tree gnu_arr_type;
2099 {
2107 /* ??? For now, store the size as a multiple of the
2108 alignment of the element type in bytes so that we
2109 can see the alignment from the tree. */
2111 = build_binary_op
2113 elaborate_expression_1
2122 }
2123 }
2125 /* If we need to write out a record type giving the names of
2126 the bounds, do it now. */
2128 {
2131 tree gnu_field;
2137 {
2138 tree gnu_type_name
2145 integer_type_node,
2146 gnu_bound_rec_type,
2150 }
2154 }
2161 /* If our size depends on a placeholder and the maximum size doesn't
2162 overflow, use it. */
2169 {
2175 }
2177 /* Set our alias set to that of our base type. This gives all
2178 array subtypes the same alias set. */
2180 }
2182 /* If this is a packed type, make this type the same as the packed
2183 array type, but do some adjusting in the type first. */
2186 {
2187 Entity_Id gnat_index;
2188 tree gnu_inner_type;
2190 /* First finish the type we had been making so that we output
2191 debugging information for it */
2192 gnu_type
2195 | (TYPE_QUAL_VOLATILE
2203 /* Save it as our equivalent in case the call below elaborates
2204 this type again. */
2218 /* We need to point the type we just made to our index type so
2219 the actual bounds can be put into a template. */
2225 {
2227 {
2228 /* The TYPE_ACTUAL_BOUNDS field is also used for the modulus.
2229 If it is, we need to make another type. */
2231 {
2232 tree gnu_subtype;
2249 }
2252 }
2258 SET_TYPE_ACTUAL_BOUNDS
2265 SET_TYPE_ACTUAL_BOUNDS
2272 }
2273 }
2275 /* Abort if packed array with no packed array type field set. */
2276 else
2282 /* Create the type for a string literal. */
2283 {
2284 Entity_Id gnat_full_type
2289 tree gnu_string_array_type
2291 tree gnu_string_index_type
2294 tree gnu_lower_bound
2299 tree gnu_upper_bound
2301 gnu_lower_bound,
2303 tree gnu_range_type
2306 tree gnu_index_type
2311 gnu_range_type);
2313 gnu_type
2315 gnu_index_type);
2317 }
2320 /* Record Types and Subtypes
2322 The following fields are defined on record types:
2324 Has_Discriminants True if the record has discriminants
2325 First_Discriminant Points to head of list of discriminants
2326 First_Entity Points to head of list of fields
2327 Is_Tagged_Type True if the record is tagged
2329 Implementation of Ada records and discriminated records:
2331 A record type definition is transformed into the equivalent of a C
2332 struct definition. The fields that are the discriminants which are
2333 found in the Full_Type_Declaration node and the elements of the
2334 Component_List found in the Record_Type_Definition node. The
2335 Component_List can be a recursive structure since each Variant of
2336 the Variant_Part of the Component_List has a Component_List.
2338 Processing of a record type definition comprises starting the list of
2339 field declarations here from the discriminants and the calling the
2340 function components_to_record to add the rest of the fields from the
2341 component list and return the gnu type node. The function
2342 components_to_record will call itself recursively as it traverses
2343 the tree. */
2347 {
2348 gnu_type
2349 = build_complex_type
2350 (get_unpadded_type
2353 (Component_List
2354 (Type_Definition
2358 }
2360 {
2363 Entity_Id gnat_field;
2364 tree gnu_field;
2366 tree gnu_get_parent;
2373 bool is_extension
2377 /* See if all fields have a rep clause. Stop when we find one
2378 that doesn't. */
2387 /* If this is a record extension, go a level further to find the
2388 record definition. Also, verify we have a Parent_Subtype. */
2390 {
2397 }
2399 /* Make a node for the record. If we are not defining the record,
2400 suppress expanding incomplete types. */
2403 /* ??? We should have create_type_decl like in the E_Record_Subtype
2404 case below. Unfortunately this would cause GNU_TYPE to be marked
2405 as visited, thus precluding the subtrees of the type that will be
2406 built below from being marked as visited when the real TYPE_DECL
2407 is eventually created. A solution could be to devise a special
2408 version of the function under the name create_type_stub_decl. */
2417 /* If both a size and rep clause was specified, put the size in
2418 the record type now so that it can get the proper mode. */
2422 /* Always set the alignment here so that it can be used to
2423 set the mode, if it is making the alignment stricter. If
2424 it is invalid, it will be checked again below. If this is to
2425 be Atomic, choose a default alignment of a word unless we know
2426 the size and it's smaller. */
2435 /* If we have a Parent_Subtype, make a field for the parent. If
2436 this record has rep clauses, force the position to zero. */
2438 {
2440 tree gnu_parent;
2442 /* A major complexity here is that the parent subtype will
2443 reference our discriminants in its Discriminant_Constraint
2444 list. But those must reference the parent component of this
2445 record which is of the parent subtype we have not built yet!
2446 To break the circle we first build a dummy COMPONENT_REF which
2447 represents the "get to the parent" operation and initialize
2448 each of those discriminants to a COMPONENT_REF of the above
2449 dummy parent referencing the corresponding discriminant of the
2450 base type of the parent subtype. */
2454 NULL_TREE),
2455 NULL_TREE);
2462 save_gnu_tree
2466 gnu_get_parent,
2469 NULL_TREE),
2472 /* Then we build the parent subtype. */
2475 /* Finally we fix up both kinds of twisted COMPONENT_REF we have
2476 initially built. The discriminants must reference the fields
2477 of the parent subtype and not those of its base type for the
2478 placeholder machinery to properly work. */
2484 {
2494 }
2496 /* The "get to the parent" COMPONENT_REF must be given its
2497 proper type... */
2500 /* ...and reference the _parent field of this record. */
2501 gnu_field_list
2509 }
2511 /* Make the fields for the discriminants and put them into the record
2512 unless it's an Unchecked_Union. */
2517 {
2518 /* If this is a record extension and this discriminant
2519 is the renaming of another discriminant, we've already
2520 handled the discriminant above. */
2525 gnu_field
2528 /* Make an expression using a PLACEHOLDER_EXPR from the
2529 FIELD_DECL node just created and link that with the
2530 corresponding GNAT defining identifier. Then add to the
2531 list of fields. */
2540 {
2543 }
2544 }
2546 /* Put the discriminants into the record (backwards), so we can
2547 know the appropriate discriminant to use for the names of the
2548 variants. */
2551 /* Add the listed fields into the record and finish up. */
2558 {
2560 defer_debug_level++;
2562 defer_debug_incomplete_list
2564 defer_debug_incomplete_list);
2565 }
2567 /* We used to remove the associations of the discriminants and
2568 _Parent for validity checking, but we may need them if there's
2569 Freeze_Node for a subtype used in this record. */
2574 /* If it is a tagged record force the type to BLKmode to insure
2575 that these objects will always be placed in memory. Do the
2576 same thing for limited record types. */
2580 /* If this is a derived type, we must make the alias set of this type
2581 the same as that of the type we are derived from. We assume here
2582 that the other type is already frozen. */
2588 /* Fill in locations of fields. */
2591 /* If there are any entities in the chain corresponding to
2592 components that we did not elaborate, ensure we elaborate their
2593 types if they are Itypes. */
2601 }
2605 /* If an equivalent type is present, that is what we should use.
2606 Otherwise, fall through to handle this like a record subtype
2607 since it may have constraints. */
2610 {
2615 }
2617 /* ... fall through ... */
2621 /* If Cloned_Subtype is Present it means this record subtype has
2622 identical layout to that type or subtype and we should use
2623 that GCC type for this one. The front end guarantees that
2624 the component list is shared. */
2626 {
2630 }
2632 /* Otherwise, first ensure the base type is elaborated. Then, if we are
2633 changing the type, make a new type with each field having the
2634 type of the field in the new subtype but having the position
2635 computed by transforming every discriminant reference according
2636 to the constraints. We don't see any difference between
2637 private and nonprivate type here since derivations from types should
2638 have been deferred until the completion of the private type. */
2639 else
2640 {
2642 tree gnu_base_type;
2643 tree gnu_orig_type;
2648 /* Get the base type initially for its alignment and sizes. But
2649 if it is a padded type, we do all the other work with the
2650 unpadded type. */
2659 {
2662 }
2664 /* When the type has discriminants, and these discriminants
2665 affect the shape of what it built, factor them in.
2667 If we are making a subtype of an Unchecked_Union (must be an
2668 Itype), just return the type.
2670 We can't just use Is_Constrained because private subtypes without
2671 discriminants of full types with discriminants with default
2672 expressions are Is_Constrained but aren't constrained! */
2680 {
2681 Entity_Id gnat_field;
2683 tree gnu_pos_list
2686 BIGGEST_ALIGNMENT);
2687 tree gnu_subst_list
2689 definition);
2690 tree gnu_temp;
2696 gnat_entity);
2708 {
2709 tree gnu_old_field
2712 tree gnu_offset
2714 gnu_pos_list));
2717 tree gnu_field_type
2721 unsigned int offset_align
2724 tree gnu_field;
2726 /* If there was a component clause, the field types must be
2727 the same for the type and subtype, so copy the data from
2728 the old field to avoid recomputation here. Also if the
2729 field is justified modular and the optimization in
2730 gnat_to_gnu_field was applied. */
2737 {
2740 }
2742 /* If this was a bitfield, get the size from the old field.
2743 Also ensure the type can be placed into a bitfield. */
2745 {
2751 }
2760 /* If the size is now a constant, we can set it as the
2761 size of the field when we make it. Otherwise, we need
2762 to deal with it specially. */
2766 gnu_field
2767 = create_field_decl
2773 {
2782 bitsize_unit_node));
2784 }
2788 SET_DECL_ORIGINAL_FIELD
2799 }
2801 /* Now go through the entities again looking for Itypes that
2802 we have not elaborated but should (e.g., Etypes of fields
2803 that have Original_Components). */
2814 /* Now set the size, alignment and alias set of the new type to
2815 match that of the old one, doing any substitutions, as
2816 above. */
2842 SET_TYPE_ADA_SIZE
2847 /* Recompute the mode of this record type now that we know its
2848 actual size. */
2851 /* Fill in locations of fields. */
2853 }
2855 /* If we've made a new type, record it and make an XVS type to show
2856 what this is a subtype of. Some debuggers require the XVS
2857 type to be output first, so do it in that order. */
2859 {
2861 {
2872 integer_type_node,
2873 gnu_subtype_marker,
2877 }
2884 }
2886 /* Otherwise, go down all the components in the new type and
2887 make them equivalent to those in the base type. */
2888 else
2895 gnat_to_gnu_field_decl
2897 }
2902 /* If we are not defining this entity, and we have incomplete
2903 entities being processed above us, make a dummy type and
2904 fill it in later. */
2906 {
2910 gnu_type
2911 = build_pointer_type
2924 }
2926 /* ... fall through ... */
2933 {
2935 /* Get the "full view" of this entity. If this is an incomplete
2936 entity from a limited with, treat its non-limited view as the
2937 full view. Otherwise, if this is an incomplete or private
2938 type, use the full view. */
2939 Entity_Id gnat_desig_full
2946 /* We want to know if we'll be seeing the freeze node for any
2947 incomplete type we may be pointing to. */
2948 bool in_main_unit
2964 {
2966 {
2970 }
2972 Incomplete_Or_Private_Kind))
2974 }
2979 /* If either the designated type or its full view is an
2980 unconstrained array subtype, replace it with the type it's a
2981 subtype of. This avoids problems with multiple copies of
2982 unconstrained array types. */
2991 /* If the designated type is a subtype of an incomplete record type,
2992 use the parent type to avoid order of elaboration issues. This
2993 can lose some code efficiency, but there is no alternative. */
2999 /* If we are pointing to an incomplete type whose completion is an
3000 unconstrained array, make a fat pointer type instead of a pointer
3001 to VOID. The two types in our fields will be pointers to VOID and
3002 will be replaced in update_pointer_to. Similarly, if the type
3003 itself is a dummy type or an unconstrained array. Also make
3004 a dummy TYPE_OBJECT_RECORD_TYPE in case we have any thin
3005 pointers to it. */
3021 && defer_incomplete_level
3031 {
3032 tree gnu_old
3036 tree fields;
3038 /* Show the dummy we get will be a fat pointer. */
3041 /* If the call above got something that has a pointer, that
3042 pointer is our type. This could have happened either
3043 because the type was elaborated or because somebody
3044 else executed the code below. */
3047 {
3053 fields
3055 create_field_decl
3060 ptr_void_type_node,
3063 /* Make sure we can place this into a register. */
3074 }
3075 }
3077 /* If we already know what the full type is, use it. */
3082 /* Get the type of the thing we are to point to and build a pointer
3083 to it. If it is a reference to an incomplete or private type with a
3084 full view that is a record, make a dummy type node and get the
3085 actual type later when we have verified it is safe. */
3091 {
3094 }
3096 /* Likewise if we are pointing to a record or array and we are to defer
3097 elaborating incomplete types. We do this since this access type
3098 may be the full view of some private type. Note that the
3099 unconstrained array case is handled above. */
3107 {
3110 }
3112 /* If this is a reference from a limited_with type back to our
3113 main unit and there's a Freeze_Node for it, either we have
3114 already processed the declaration and made the dummy type,
3115 in which case we just reuse the latter, or we have not yet,
3116 in which case we make the dummy type and it will be reused
3117 when the declaration is processed. In both cases, the pointer
3118 eventually created below will be automatically adjusted when
3119 the Freeze_Node is processed. Note that the unconstrained
3120 array case is handled above. */
3125 {
3128 }
3131 {
3132 gnu_type
3134 p_mode,
3137 }
3139 else
3142 /* It is possible that the above call to gnat_to_gnu_type resolved our
3143 type. If so, just return it. */
3145 {
3148 }
3150 /* If we have a GCC type for the designated type, possibly modify it
3151 if we are pointing only to constant objects and then make a pointer
3152 to it. Don't do this for unconstrained arrays. */
3154 {
3157 {
3158 gnu_desig_type
3159 = build_qualified_type
3163 /* Some extra processing is required if we are building a
3164 pointer to an incomplete type (in the GCC sense). We might
3165 have such a type if we just made a dummy, or directly out
3166 of the call to gnat_to_gnu_type above if we are processing
3167 an access type for a record component designating the
3168 record type itself. */
3170 {
3171 /* We must ensure that the pointer to variant we make will
3172 be processed by update_pointer_to when the initial type
3173 is completed. Pretend we made a dummy and let further
3174 processing act as usual. */
3177 /* We must ensure that update_pointer_to will not retrieve
3178 the dummy variant when building a properly qualified
3179 version of the complete type. We take advantage of the
3180 fact that get_qualified_type is requiring TYPE_NAMEs to
3181 match to influence build_qualified_type and then also
3182 update_pointer_to here. */
3185 }
3186 }
3188 gnu_type
3191 }
3193 /* If we are not defining this object and we made a dummy pointer,
3194 save our current definition, evaluate the actual type, and replace
3195 the tentative type we made with the actual one. If we are to defer
3196 actually looking up the actual type, make an entry in the
3197 deferred list. */
3200 {
3201 tree gnu_old_type
3207 gnu_type
3208 = build_pointer_type
3209 (TYPE_OBJECT_RECORD_TYPE
3219 /* Note that the call to gnat_to_gnu_type here might have
3220 updated gnu_old_type directly, in which case it is not a
3221 dummy type any more when we get into update_pointer_to.
3223 This may happen for instance when the designated type is a
3224 record type, because their elaboration starts with an
3225 initial node from make_dummy_type, which may yield the same
3226 node as the one we got.
3228 Besides, variants of this non-dummy type might have been
3229 created along the way. update_pointer_to is expected to
3230 properly take care of those situations. */
3233 else
3234 {
3242 }
3243 }
3244 }
3251 else
3252 {
3253 /* The runtime representation is the equivalent type. */
3256 }
3269 /* We treat this as identical to its base type; any constraint is
3270 meaningful only to the front end.
3272 The designated type must be elaborated as well, if it does
3273 not have its own freeze node. Designated (sub)types created
3274 for constrained components of records with discriminants are
3275 not frozen by the front end and thus not elaborated by gigi,
3276 because their use may appear before the base type is frozen,
3277 and because it is not clear that they are needed anywhere in
3278 Gigi. With the current model, there is no correct place where
3279 they could be elaborated. */
3286 {
3287 /* If we are not defining this entity, and we have incomplete
3288 entities being processed above us, make a dummy type and
3289 elaborate it later. */
3291 {
3294 tree gnu_ptr_type
3295 = build_pointer_type
3302 }
3305 Incomplete_Or_Private_Kind))
3306 ;
3307 else
3310 }
3315 /* Subprogram Entities
3317 The following access functions are defined for subprograms (functions
3318 or procedures):
3320 First_Formal The first formal parameter.
3321 Is_Imported Indicates that the subprogram has appeared in
3322 an INTERFACE or IMPORT pragma. For now we
3323 assume that the external language is C.
3324 Is_Inlined True if the subprogram is to be inlined.
3326 In addition for function subprograms we have:
3328 Etype Return type of the function.
3330 Each parameter is first checked by calling must_pass_by_ref on its
3331 type to determine if it is passed by reference. For parameters which
3332 are copied in, if they are Ada IN OUT or OUT parameters, their return
3333 value becomes part of a record which becomes the return type of the
3334 function (C function - note that this applies only to Ada procedures
3335 so there is no Ada return type). Additional code to store back the
3336 parameters will be generated on the caller side. This transformation
3337 is done here, not in the front-end.
3339 The intended result of the transformation can be seen from the
3340 equivalent source rewritings that follow:
3342 struct temp {int a,b};
3343 procedure P (A,B: IN OUT ...) is temp P (int A,B) {
3344 .. ..
3345 end P; return {A,B};
3346 }
3347 procedure call
3349 {
3350 temp t;
3351 P(X,Y); t = P(X,Y);
3352 X = t.a , Y = t.b;
3353 }
3355 For subprogram types we need to perform mainly the same conversions to
3356 GCC form that are needed for procedures and function declarations. The
3357 only difference is that at the end, we make a type declaration instead
3358 of a function declaration. */
3363 {
3364 /* The first GCC parameter declaration (a PARM_DECL node). The
3365 PARM_DECL nodes are chained through the TREE_CHAIN field, so this
3366 actually is the head of this parameter list. */
3368 /* The type returned by a function. If the subprogram is a procedure
3369 this type should be void_type_node. */
3371 /* List of fields in return type of procedure with copy in copy out
3372 parameters. */
3374 /* Non-null for subprograms containing parameters passed by copy in
3375 copy out (Ada IN OUT or OUT parameters not passed by reference),
3376 in which case it is the list of nodes used to specify the values of
3377 the in out/out parameters that are returned as a record upon
3378 procedure return. The TREE_PURPOSE of an element of this list is
3379 a field of the record and the TREE_VALUE is the PARM_DECL
3380 corresponding to that field. This list will be saved in the
3381 TYPE_CI_CO_LIST field of the FUNCTION_TYPE node we create. */
3383 /* If an import pragma asks to map this subprogram to a GCC builtin,
3384 this is the builtin DECL node. */
3386 Entity_Id gnat_param;
3389 bool extern_flag
3401 /* A parameter may refer to this type, so defer completion
3402 of any incomplete types. */
3405 /* If the subprogram has an alias, it is probably inherited, so
3406 we can use the original one. If the original "subprogram"
3407 is actually an enumeration literal, it may be the first use
3408 of its type, so we must elaborate that type now. */
3410 {
3417 /* Elaborate any Itypes in the parameters of this entity. */
3425 }
3427 /* If this subprogram is expectedly bound to a GCC builtin, fetch the
3428 corresponding DECL node.
3430 We still want the parameter associations to take place because the
3431 proper generation of calls depends on it (a GNAT parameter without
3432 a corresponding GCC tree has a very specific meaning), so we don't
3433 just break here. */
3437 /* ??? What if we don't find the builtin node above ? warn ? err ?
3438 In the current state we neither warn nor err, and calls will just
3439 be handled as for regular subprograms. */
3444 /* If this function returns by reference, make the actual
3445 return type of this function the pointer and mark the decl. */
3447 {
3450 }
3452 /* If the Mechanism is By_Reference, ensure the return type uses
3453 the machine's by-reference mechanism, which may not the same
3454 as above (e.g., it might be by passing a fake parameter). */
3457 {
3460 /* We expect this bit to be reset by gigi shortly, so can avoid a
3461 type node copy here. This actually also prevents troubles with
3462 the generation of debug information for the function, because
3463 we might have issued such info for this type already, and would
3464 be attaching a distinct type node to the function if we made a
3465 copy here. */
3466 }
3468 /* If we are supposed to return an unconstrained array,
3469 actually return a fat pointer and make a note of that. Return
3470 a pointer to an unconstrained record of variable size. */
3472 {
3475 }
3477 /* If the type requires a transient scope, the result is allocated
3478 on the secondary stack, so the result type of the function is
3479 just a pointer. */
3481 {
3484 }
3486 /* If the type is a padded type and the underlying type would not
3487 be passed by reference or this function has a foreign convention,
3488 return the underlying type. */
3496 /* If the return type is unconstrained, that means it must have a
3497 maximum size. We convert the function into a procedure and its
3498 caller will pass a pointer to an object of that maximum size as the
3499 first parameter when we call the function. */
3501 {
3503 gnu_param_list
3508 }
3510 /* If the return type has a size that overflows, we cannot have
3511 a function that returns that type. This usage doesn't make
3512 sense anyway, so give an error here. */
3516 {
3518 gnat_entity);
3524 }
3526 /* Look at all our parameters and get the type of
3527 each. While doing this, build a copy-out structure if
3528 we need one. */
3533 {
3543 /* Builtins are expanded inline and there is no real call sequence
3544 involved. so the type expected by the underlying expander is
3545 always the type of each argument "as is". */
3549 /* Otherwise, see if a Mechanism was supplied that forced this
3550 parameter to be passed one way or another. */
3554 ;
3562 {
3568 else
3570 }
3571 else
3574 /* If this is either a foreign function or if the
3575 underlying type won't be passed by reference, strip off
3576 possible padding type. */
3582 && (req_by_copy
3584 (TYPE_FIELDS
3588 /* If this is an IN parameter it is read-only, so make a variant
3589 of the type that is read-only.
3591 ??? However, if this is an unconstrained array, that type can
3592 be very complex. So skip it for now. Likewise for any other
3593 self-referential type. */
3597 gnu_param_type
3602 /* For foreign conventions, pass arrays as a pointer to the
3603 underlying type. First check for unconstrained array and get
3604 the underlying array. Then get the component type and build
3605 a pointer to it. */
3608 gnu_param_type
3613 gnu_param_type
3614 = build_pointer_type
3619 && !req_by_copy
3621 {
3622 /* Strip off any multi-dimensional entries, then strip
3623 off the last array to get the component type. */
3632 gnu_param_type
3638 }
3640 /* Fat pointers are passed as thin pointers for foreign
3641 conventions. */
3644 gnu_param_type
3648 /* If we must pass or were requested to pass by reference, do so.
3649 If we were requested to pass by copy, do so.
3650 Otherwise, for foreign conventions, pass all in out parameters
3651 or aggregates by reference. For COBOL and Fortran, pass
3652 all integer and FP types that way too. For Convention Ada,
3653 use the standard Ada default. */
3655 || (!req_by_copy
3665 /* For convention Ada, see if we pass by reference
3666 by default. */
3669 {
3672 }
3680 /* If this is an OUT parameter that isn't passed by reference
3681 and isn't a pointer or aggregate, we don't make a PARM_DECL
3682 for it. Instead, it will be a VAR_DECL created when we process
3683 the procedure. For the special parameter of Valued_Procedure,
3684 never pass it in.
3686 An exception is made to cover the RM-6.4.1 rule requiring "by
3687 copy" out parameters with discriminants or implicit initial
3688 values to be handled like in out parameters. These type are
3689 normally built as aggregates, and hence passed by reference,
3690 except for some packed arrays which end up encoded in special
3691 integer types.
3693 The exception we need to make is then for packed arrays of
3694 records with discriminants or implicit initial values. We have
3695 no light/easy way to check for the latter case, so we merely
3696 check for packed arrays of records. This may lead to useless
3697 copy-in operations, but in very rare cases only, as these would
3698 be exceptions in a set of already exceptional situations. */
3701 || (!by_descr_p
3709 else
3710 {
3711 gnu_param
3712 = create_param_decl
3714 by_ref_p || by_component_ptr_p
3728 /* If a parameter is a pointer, this function may modify
3729 memory through it and thus shouldn't be considered
3730 a pure function. Also, the memory may be modified
3731 between two calls, so they can't be CSE'ed. The latter
3732 case also handles by-ref parameters. */
3736 }
3739 {
3741 {
3746 }
3755 gnu_return_list);
3756 }
3757 }
3759 /* Do not compute record for out parameters if subprogram is
3760 stubbed since structures are incomplete for the back-end. */
3763 {
3764 /* If all types are not complete, defer emission of debug
3765 information for this record types. Otherwise, we risk emitting
3766 debug information for a dummy type contained in the fields
3767 for that record. */
3772 {
3774 defer_debug_level++;
3776 defer_debug_incomplete_list
3778 defer_debug_incomplete_list);
3779 }
3780 }
3782 /* If we have a CICO list but it has only one entry, we convert
3783 this function into a function that simply returns that one
3784 object. */
3789 {
3799 }
3801 /* Both lists ware built in reverse. */
3805 gnu_type
3808 returns_by_ref,
3810 returns_by_target_ptr);
3812 /* A subprogram (something that doesn't return anything) shouldn't
3813 be considered Pure since there would be no reason for such a
3814 subprogram. Note that procedures with Out (or In Out) parameters
3815 have already been converted into a function with a return type. */
3819 /* The semantics of "pure" in Ada essentially matches that of "const"
3820 in the back-end. In particular, both properties are orthogonal to
3821 the "nothrow" property. But this is true only if the EH circuitry
3822 is explicit in the internal representation of the back-end. If we
3823 are to completely hide the EH circuitry from it, we need to declare
3824 that calls to pure Ada subprograms that can throw have side effects
3825 since they can trigger an "abnormal" transfer of control flow; thus
3826 they can be neither "const" nor "pure" in the back-end sense. */
3827 gnu_type
3836 /* If we have a builtin decl for that function, check the signatures
3837 compatibilities. If the signatures are compatible, use the builtin
3838 decl. If they are not, we expect the checker predicate to have
3839 posted the appropriate errors, and just continue with what we have
3840 so far. */
3842 {
3846 {
3850 }
3851 }
3853 /* If there was no specified Interface_Name and the external and
3854 internal names of the subprogram are the same, only use the
3855 internal name to allow disambiguation of nested subprograms. */
3859 /* If we are defining the subprogram and it has an Address clause
3860 we must get the address expression from the saved GCC tree for the
3861 subprogram if it has a Freeze_Node. Otherwise, we elaborate
3862 the address expression here since the front-end has guaranteed
3863 in that case that the elaboration has no effects. If there is
3864 an Address clause and we are not defining the object, just
3865 make it a constant. */
3867 {
3871 gnu_address
3882 gnu_decl
3887 }
3893 gnat_entity);
3894 else
3895 {
3900 gnat_entity);
3904 }
3905 }
3916 {
3917 /* Get the "full view" of this entity. If this is an incomplete
3918 entity from a limited with, treat its non-limited view as the
3919 full view. Otherwise, use either the full view or the underlying
3920 full view, whichever is present. This is used in all the tests
3921 below. */
3922 Entity_Id full_view
3930 /* If this is an incomplete type with no full view, it must be a Taft
3931 Amendment type, in which case we return a dummy type. Otherwise,
3932 just get the type from its Etype. */
3934 {
3937 else
3938 {
3942 }
3944 }
3946 /* If we already made a type for the full view, reuse it. */
3948 {
3951 }
3953 /* Otherwise, if we are not defining the type now, get the type
3954 from the full view. But always get the type from the full view
3955 for define on use types, since otherwise we won't see them! */
3961 {
3965 }
3967 /* For incomplete types, make a dummy type entry which will be
3968 replaced later. */
3971 /* Save this type as the full declaration's type so we can do any
3972 needed updates when we see it. */
3978 }
3980 /* Simple class_wide types are always viewed as their root_type
3981 by Gigi unless an Equivalent_Type is specified. */
3985 else
3997 else
4009 /* Nothing at all to do here, so just return an ERROR_MARK and claim
4010 we've already saved it, so we don't try to. */
4017 }
4019 /* If we had a case where we evaluated another type and it might have
4020 defined this one, handle it here. */
4022 {
4025 }
4027 /* If we are processing a type and there is either no decl for it or
4028 we just made one, do some common processing for the type, such as
4029 handling alignment and possible padding. */
4032 {
4040 /* ??? Don't set the size for a String_Literal since it is either
4041 confirming or we don't handle it properly (if the low bound is
4042 non-constant). */
4048 /* If a size was specified, see if we can make a new type of that size
4049 by rearranging the type, for example from a fat to a thin pointer. */
4051 {
4052 gnu_type
4059 }
4061 /* If the alignment hasn't already been processed and this is
4062 not an unconstrained array, see if an alignment is specified.
4063 If not, we pick a default alignment for atomic objects. */
4065 ;
4079 /* See if we need to pad the type. If we did, and made a record,
4080 the name of the new type may be changed. So get it back for
4081 us when we make the new TYPE_DECL below. */
4086 {
4090 }
4094 /* If we are at global level, GCC will have applied variable_size to
4095 the type, but that won't have done anything. So, if it's not
4096 a constant or self-referential, call elaborate_expression_1 to
4097 make a variable for the size rather than calculating it each time.
4098 Handle both the RM size and the actual size. */
4103 {
4107 {
4114 }
4115 else
4116 {
4123 /* ??? For now, store the size as a multiple of the alignment
4124 in bytes so that we can see the alignment from the tree. */
4126 = build_binary_op
4128 elaborate_expression_1
4139 SET_TYPE_ADA_SIZE
4142 gnat_entity,
4146 }
4147 }
4149 /* If this is a record type or subtype, call elaborate_expression_1 on
4150 any field position. Do this for both global and local types.
4151 Skip any fields that we haven't made trees for to avoid problems with
4152 class wide types. */
4157 {
4160 /* ??? Unfortunately, GCC needs to be able to prove the
4161 alignment of this offset and if it's a variable, it can't.
4162 In GCC 3.4, we'll use DECL_OFFSET_ALIGN in some way, but
4163 right now, we have to put in an explicit multiply and
4164 divide by that value. */
4167 = build_binary_op
4169 elaborate_expression_1
4178 }
4182 | (TYPE_QUAL_VOLATILE
4195 else
4197 }
4200 {
4203 /* Back-annotate the Alignment of the type if not already in the
4204 tree. Likewise for sizes. */
4210 {
4211 /* If the size is self-referential, we annotate the maximum
4212 value of that size. */
4221 {
4222 /* In this mode the tag and the parent components are not
4223 generated by the front-end, so the sizes must be adjusted
4224 explicitly now. */
4230 {
4231 size_offset
4235 }
4236 else
4244 }
4245 }
4249 }
4259 /* If we haven't already, associate the ..._DECL node that we just made with
4260 the input GNAT entity node. */
4264 /* If this is an enumeral or floating-point type, we were not able to set
4265 the bounds since they refer to the type. These bounds are always static.
4267 For enumeration types, also write debugging information and declare the
4268 enumeration literal table, if needed. */
4272 {
4275 /* If this is a padded type, we need to use the underlying type. */
4280 /* If this is a floating point type and we haven't set a floating
4281 point type yet, use this in the evaluation of the bounds. */
4291 {
4294 /* Since this has both a typedef and a tag, avoid outputting
4295 the name twice. */
4298 }
4299 }
4301 /* If we deferred processing of incomplete types, re-enable it. If there
4302 were no other disables and we have some to process, do so. */
4304 {
4310 {
4317 }
4318 }
4320 /* If we are not defining this type, see if it's in the incomplete list.
4321 If so, handle that list entry now. */
4323 {
4328 {
4332 }
4333 }
4335 /* If there are no incomplete types and we have deferred emission
4336 of debug information, check whether we have finished defining
4337 all nested records.
4338 If so, handle the list now. */
4341 defer_debug_level--;
4344 && !defer_incomplete_level
4346 {
4352 {
4355 }
4358 }
4361 force_global--;
4370 }
4372 /* Similar, but if the returned value is a COMPONENT_REF, return the
4373 FIELD_DECL. */
4375 tree
4377 {
4384 }
4386 /* Return true if DISCR1 and DISCR2 represent the same discriminant. */
4388 static
4390 {
4397 return
4399 }
4400 \f
4401 /* Given GNAT_ENTITY, elaborate all expressions that are required to
4402 be elaborated at the point of its definition, but do nothing else. */
4404 void
4406 {
4408 {
4415 {
4419 /* ??? Tests for avoiding static constraint error expression
4420 is needed until the front stops generating bogus conversions
4421 on bounds of real types. */
4430 }
4433 {
4437 /* If this is a record extension, go a level further to find the
4438 record definition. */
4441 }
4451 {
4452 Node_Id gnat_discriminant_expr;
4453 Entity_Id gnat_field;
4456 gnat_discriminant_expr
4461 /* ??? For now, ignore access discriminants. */
4464 gnat_entity,
4466 }
4469 }
4470 }
4471 \f
4472 /* Mark GNAT_ENTITY as going out of scope at this point. Recursively mark
4473 any entities on its entity chain similarly. */
4475 void
4477 {
4478 Entity_Id gnat_sub_entity;
4481 /* If this has an entity list, process all in the list. */
4498 /* Now clear this if it has been defined, but only do so if it isn't
4499 a subprogram or parameter. We could refine this, but it isn't
4500 worth it. If this is statically allocated, it is supposed to
4501 hang around out of cope. */
4504 {
4507 }
4508 }
4509 \f
4510 /* Set the alias set of GNU_NEW_TYPE to be that of GNU_OLD_TYPE. If this
4511 is a multi-dimensional array type, do this recursively. */
4513 static void
4515 {
4516 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
4517 of a one-dimensional array, since the padding has the same alias set
4518 as the field type, but if it's a multi-dimensional array, we need to
4519 see the inner types. */
4525 /* We need to be careful here in case GNU_OLD_TYPE is an unconstrained
4526 array. In that case, it doesn't have the same shape as GNU_NEW_TYPE,
4527 so we need to go down to what does. */
4529 gnu_old_type
4539 }
4540 \f
4541 /* Return a TREE_LIST describing the substitutions needed to reflect
4542 discriminant substitutions from GNAT_SUBTYPE to GNAT_TYPE and add
4543 them to GNU_LIST. If GNAT_TYPE is not specified, use the base type
4544 of GNAT_SUBTYPE. The substitutions can be in any order. TREE_PURPOSE
4545 gives the tree for the discriminant and TREE_VALUES is the replacement
4546 value. They are in the form of operands to substitute_in_expr.
4547 DEFINITION is as in gnat_to_gnu_entity. */
4549 static tree
4552 {
4553 Entity_Id gnat_discrim;
4554 Node_Id gnat_value;
4565 /* Ignore access discriminants. */
4568 elaborate_expression
4572 gnu_list);
4575 }
4576 \f
4577 /* Return true if the size represented by GNU_SIZE can be handled by an
4578 allocation. If STATIC_P is true, consider only what can be done with a
4579 static allocation. */
4581 static bool
4583 {
4584 HOST_WIDE_INT our_size;
4586 /* If this is not a static allocation, the only case we want to forbid
4587 is an overflowing size. That will be converted into a raise a
4588 Storage_Error. */
4593 /* Otherwise, we need to deal with both variable sizes and constant
4594 sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
4595 since assemblers may not like very large sizes. */
4601 }
4602 \f
4603 /* Prepend to ATTR_LIST the list of attributes for GNAT_ENTITY, if any. */
4605 static void
4607 {
4608 Node_Id gnat_temp;
4613 {
4623 {
4625 (gnat_to_gnu
4632 (gnat_to_gnu
4633 (Expression
4636 }
4639 {
4666 }
4673 /* If we have an argument specified together with an attribute name,
4674 make it a single TREE_VALUE entry in a list of arguments, as GCC
4675 expects it. */
4678 else
4681 attr->error_point
4685 }
4686 }
4687 \f
4688 /* Get the unpadded version of a GNAT type. */
4690 tree
4692 {
4699 }
4700 \f
4701 /* Called when we need to protect a variable object using a save_expr. */
4703 tree
4705 {
4712 {
4720 }
4721 else
4723 }
4724 \f
4725 /* Given a GNAT tree GNAT_EXPR, for an expression which is a value within a
4726 type definition (either a bound or a discriminant value) for GNAT_ENTITY,
4727 return the GCC tree to use for that expression. GNU_NAME is the
4728 qualification to use if an external name is appropriate and DEFINITION is
4729 nonzero if this is a definition of GNAT_ENTITY. If NEED_VALUE is nonzero,
4730 we need a result. Otherwise, we are just elaborating this for
4731 side-effects. If NEED_DEBUG is nonzero we need the symbol for debugging
4732 purposes even if it isn't needed for code generation. */
4734 static tree
4738 {
4739 tree gnu_expr;
4741 /* If we already elaborated this expression (e.g., it was involved
4742 in the definition of a private type), use the old value. */
4746 /* If we don't need a value and this is static or a discriminant, we
4747 don't need to do anything. */
4754 /* Otherwise, convert this tree to its GCC equivalent. */
4755 gnu_expr
4759 /* Save the expression in case we try to elaborate this entity again. Since
4760 this is not a DECL, don't check it. Don't save if it's a discriminant. */
4765 }
4767 /* Similar, but take a GNU expression. */
4769 static tree
4773 {
4775 /* Strip any conversions to see if the expression is a readonly variable.
4776 ??? This really should remain readonly, but we have to think about
4777 the typing of the tree here. */
4782 /* In most cases, we won't see a naked FIELD_DECL here because a
4783 discriminant reference will have been replaced with a COMPONENT_REF
4784 when the type is being elaborated. However, there are some cases
4785 involving child types where we will. So convert it to a COMPONENT_REF
4786 here. We have to hope it will be at the highest level of the
4787 expression in these cases. */
4793 /* If GNU_EXPR is neither a placeholder nor a constant, nor a variable
4794 that is a constant, make a variable that is initialized to contain the
4795 bound when the package containing the definition is elaborated. If
4796 this entity is defined at top level and a bound or discriminant value
4797 isn't a constant or a reference to a discriminant, replace the bound
4798 by the variable; otherwise use a SAVE_EXPR if needed. Note that we
4799 rely here on the fact that an expression cannot contain both the
4800 discriminant and some other variable. */
4808 /* If this is a static expression or contains a discriminant, we don't
4809 need the variable for debugging (and can't elaborate anyway if a
4810 discriminant). */
4816 /* Now create the variable if we need it. */
4818 gnu_decl
4825 /* We only need to use this variable if we are in global context since GCC
4826 can do the right thing in the local case. */
4831 else
4833 }
4834 \f
4835 /* Create a record type that contains a field of TYPE with a starting bit
4836 position so that it is aligned to ALIGN bits and is SIZE bytes long. */
4838 tree
4840 {
4845 place));
4854 /* The bit position is obtained by "and"ing the alignment minus 1
4855 with the two's complement of the address and multiplying
4856 by the number of bits per unit. Do all this in sizetype. */
4861 size_addr_place),
4864 bitsize_unit_node);
4866 /* Create the field, with -1 as the 'addressable' indication to avoid the
4867 creation of a bitfield. We don't need one, it would have damaging
4868 consequences on the alignment computation, and create_field_decl would
4869 make one without this special argument, for instance because of the
4870 complex position expression. */
4879 bitsize_unit_node),
4885 }
4886 \f
4887 /* TYPE is a RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE, with BLKmode that's
4888 being used as the field type of a packed record. See if we can rewrite it
4889 as a record that has a non-BLKmode type, which we can pack tighter. If so,
4890 return the new type. If not, return the original type. */
4892 static tree
4894 {
4897 tree old_field;
4899 /* Copy the name and flags from the old type to that of the new and set
4900 the alignment to try for an integral type. For QUAL_UNION_TYPE,
4901 also copy the size. */
4910 {
4913 }
4919 /* Now copy the fields, keeping the position and size. */
4922 {
4924 tree new_field;
4940 SET_DECL_ORIGINAL_FIELD
4949 }
4954 }
4955 \f
4956 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
4957 if needed. We have already verified that SIZE and TYPE are large enough.
4959 GNAT_ENTITY and NAME_TRAILER are used to name the resulting record and
4960 to issue a warning.
4962 IS_USER_TYPE is true if we must be sure we complete the original type.
4964 DEFINITION is true if this type is being defined.
4966 SAME_RM_SIZE is true if the RM_Size of the resulting type is to be
4967 set to its TYPE_SIZE; otherwise, it's set to the RM_Size of the original
4968 type. */
4970 tree
4974 {
4976 tree record;
4977 tree field;
4979 /* If TYPE is a padded type, see if it agrees with any size and alignment
4980 we were given. If so, return the original type. Otherwise, strip
4981 off the padding, since we will either be returning the inner type
4982 or repadding it. If no size or alignment is specified, use that of
4983 the original padded type. */
4986 {
5003 }
5005 /* If the size is either not being changed or is being made smaller (which
5006 is not done here (and is only valid for bitfields anyway), show the size
5007 isn't changing. Likewise, clear the alignment if it isn't being
5008 changed. Then return if we aren't doing anything. */
5022 /* We used to modify the record in place in some cases, but that could
5023 generate incorrect debugging information. So make a new record
5024 type and name. */
5030 /* If we were making a type, complete the original type and give it a
5031 name. */
5038 gnat_entity);
5040 /* If we are changing the alignment and the input type is a record with
5041 BLKmode and a small constant size, try to make a form that has an
5042 integral mode. That might allow this record to have an integral mode,
5043 which will be much more efficient. There is no point in doing this if a
5044 size is specified unless it is also smaller than the biggest alignment
5045 and it is incorrect to do this if the size of the original type is not a
5046 multiple of the alignment. */
5052 && (!size
5074 /* Keep the RM_Size of the padded record as that of the old record
5075 if requested. */
5078 /* Unless debugging information isn't being written for the input type,
5079 write a record that shows what we are a subtype of and also make a
5080 variable that indicates our size, if variable. */
5084 {
5105 }
5112 /* If the size was widened explicitly, maybe give a warning. */
5118 {
5131 /* Generate message only for entities that come from source, since
5132 if we have an entity created by expansion, the message will be
5133 generated for some other corresponding source entity. */
5136 gnat_entity,
5143 }
5146 }
5147 \f
5148 /* Given a GNU tree and a GNAT list of choices, generate an expression to test
5149 the value passed against the list of choices. */
5151 tree
5153 {
5154 Node_Id choice;
5155 Node_Id gnat_temp;
5160 {
5162 {
5167 /* There's no good type to use here, so we might as well use
5168 integer_type_node. */
5169 this_test
5183 this_test
5193 /* This represents either a subtype range, an enumeration
5194 literal, or a constant Ekind says which. If an enumeration
5195 literal or constant, fall through to the next case. */
5198 {
5204 this_test
5211 }
5212 /* ... fall through ... */
5217 single);
5226 }
5230 }
5233 }
5234 \f
5235 /* Return a GCC tree for a field corresponding to GNAT_FIELD to be
5236 placed in GNU_RECORD_TYPE.
5238 PACKED is 1 if the enclosing record is packed and -1 if the enclosing
5239 record has a Component_Alignment of Storage_Unit.
5241 DEFINITION is true if this field is for a record being defined. */
5243 static tree
5246 {
5251 tree gnu_field;
5252 bool needs_strict_alignment
5256 /* If this field requires strict alignment or contains an item of
5257 variable sized, pretend it isn't packed. */
5261 /* For packed records, this is one of the few occasions on which we use
5262 the official RM size for discrete or fixed-point components, instead
5263 of the normal GNAT size stored in Esize. See description in Einfo:
5264 "Handling of Type'Size Values" for further details. */
5274 /* If we have a specified size that's smaller than that of the field type,
5275 or a position is specified, and the field type is also a record that's
5276 BLKmode and with a small constant size, see if we can get an integral
5277 mode form of the type when appropriate. If we can, show a size was
5278 specified for the field if there wasn't one already, so we know to make
5279 this a bitfield and avoid making things wider.
5281 Doing this is first useful if the record is packed because we can then
5282 place the field at a non-byte-aligned position and so achieve tighter
5283 packing.
5285 This is in addition *required* if the field shares a byte with another
5286 field and the front-end lets the back-end handle the references, because
5287 GCC does not handle BLKmode bitfields properly.
5289 We avoid the transformation if it is not required or potentially useful,
5290 as it might entail an increase of the field's alignment and have ripple
5291 effects on the outer record type. A typical case is a field known to be
5292 byte aligned and not to share a byte with another field.
5294 Besides, we don't even look the possibility of a transformation in cases
5295 known to be in error already, for instance when an invalid size results
5296 from a component clause. */
5303 || (gnu_size
5306 {
5307 /* See what the alternate type and size would be. */
5310 bool has_byte_aligned_clause
5315 /* Compute whether we should avoid the substitution. */
5317 /* There is no point substituting if there is no change. */
5319 ||
5320 /* ... nor when the field is known to be byte aligned and not to
5321 share a byte with another field. */
5322 (has_byte_aligned_clause
5324 ||
5325 /* The size of an aliased field must be an exact multiple of the
5326 type's alignment, which the substitution might increase. Reject
5327 substitutions that would so invalidate a component clause when the
5328 specified position is byte aligned, as the change would have no
5329 real benefit from the packing standpoint anyway. */
5331 && has_byte_aligned_clause
5333 );
5335 /* Substitute unless told otherwise. */
5337 {
5342 }
5343 }
5345 /* If we are packing the record and the field is BLKmode, round the
5346 size up to a byte boundary. */
5351 {
5356 /* Ensure the position does not overlap with the parent subtype,
5357 if there is one. */
5359 {
5360 tree gnu_parent
5366 {
5367 post_error_ne_tree
5371 }
5372 }
5374 /* If this field needs strict alignment, ensure the record is
5375 sufficiently aligned and that that position and size are
5376 consistent with the alignment. */
5378 {
5385 /* If Atomic, the size must match exactly that of the field. */
5388 {
5389 post_error_ne_tree
5395 }
5397 /* If Aliased, the size must match exactly the rounded size. We
5398 used to be more accommodating here and accept greater sizes, but
5399 fully supporting this case on big-endian platforms would require
5400 switching to a more involved layout for the field. */
5402 && gnu_size
5404 {
5405 post_error_ne_tree
5408 gnu_rounded_size);
5410 }
5415 {
5417 post_error_ne_num
5423 post_error_ne_num
5429 post_error_ne_num
5433 else
5437 }
5438 }
5442 }
5444 /* If the record has rep clauses and this is the tag field, make a rep
5445 clause for it as well. */
5448 {
5451 }
5453 /* We need to make the size the maximum for the type if it is
5454 self-referential and an unconstrained type. In that case, we can't
5455 pack the field since we can't make a copy to align it. */
5457 && !gnu_size
5460 {
5463 }
5465 /* If no size is specified (or if there was an error), don't specify a
5466 position. */
5469 else
5470 {
5471 /* If the field's type is justified modular, we would need to remove
5472 the wrapper to (better) meet the layout requirements. However we
5473 can do so only if the field is not aliased to preserve the unique
5474 layout and if the prescribed size is not greater than that of the
5475 packed array to preserve the justification. */
5483 gnu_field_type
5488 }
5493 /* Now create the decl for the field. */
5505 }
5506 \f
5507 /* Return true if TYPE is a type with variable size, a padding type with a
5508 field of variable size or is a record that has a field such a field. */
5510 static bool
5512 {
5513 tree field;
5515 /* We need not be concerned about this at all if we don't have
5516 strict alignment. */
5534 }
5535 \f
5536 /* Return a GCC tree for a record type given a GNAT Component_List and a chain
5537 of GCC trees for fields that are in the record and have already been
5538 processed. When called from gnat_to_gnu_entity during the processing of a
5539 record type definition, the GCC nodes for the discriminants will be on
5540 the chain. The other calls to this function are recursive calls from
5541 itself for the Component_List of a variant and the chain is empty.
5543 PACKED is 1 if this is for a record with "pragma pack" and -1 is this is
5544 for a record type with "pragma component_alignment (storage_unit)".
5546 DEFINITION is true if we are defining this record.
5548 P_GNU_REP_LIST, if nonzero, is a pointer to a list to which each field
5549 with a rep clause is to be added. If it is nonzero, that is all that
5550 should be done with such fields.
5552 CANCEL_ALIGNMENT, if true, means the alignment should be zeroed before
5553 laying out the record. This means the alignment only serves to force fields
5554 to be bitfields, but not require the record to be that aligned. This is
5555 used for variants.
5557 ALL_REP, if true, means a rep clause was found for all the fields. This
5558 simplifies the logic since we know we're not in the mixed case.
5560 DEFER_DEBUG, if true, means that the debugging routines should not be
5561 called when finishing constructing the record type.
5563 UNCHECKED_UNION, if tree, means that we are building a type for a record
5564 with a Pragma Unchecked_Union.
5566 The processing of the component list fills in the chain with all of the
5567 fields of the record and then the record type is finished. */
5569 static void
5574 {
5575 Node_Id component_decl;
5576 Entity_Id gnat_field;
5577 Node_Id variant_part;
5583 /* For each variable within each component declaration create a GCC field
5584 and add it to the list, skipping any pragmas in the list. */
5590 {
5595 else
5596 {
5600 /* If this is the _Tag field, put it before any discriminants,
5601 instead of after them as is the case for all other fields.
5602 Ignore field of void type if only annotating. */
5605 else
5606 {
5609 }
5610 }
5613 }
5615 /* At the end of the component list there may be a variant part. */
5618 /* We create a QUAL_UNION_TYPE for the variant part since the variants are
5619 mutually exclusive and should go in the same memory. To do this we need
5620 to treat each variant as a record whose elements are created from the
5621 component list for the variant. So here we create the records from the
5622 lists for the variants and put them all into the QUAL_UNION_TYPE.
5623 If this is an Unchecked_Union, we make a UNION_TYPE instead or
5624 use GNU_RECORD_TYPE if there are no fields so far. */
5626 {
5628 Node_Id variant;
5630 tree gnu_var_name
5634 tree gnu_union_type;
5635 tree gnu_union_name;
5636 tree gnu_union_field;
5647 else
5648 {
5650 gnu_union_type
5655 }
5660 {
5662 tree gnu_inner_name;
5663 tree gnu_qual;
5671 /* Set the alignment of the inner type in case we need to make
5672 inner objects into bitfields, but then clear it out
5673 so the record actually gets only the alignment required. */
5677 /* Similarly, if the outer record has a size specified and all fields
5678 have record rep clauses, we can propagate the size into the
5679 variant part. */
5681 {
5685 }
5687 /* Create the record for the variant. Note that we defer emitting
5688 debug info for it until after we are sure to actually use it. */
5699 /* If this is an Unchecked_Union and we have exactly one field,
5700 use that field here. */
5704 else
5705 {
5706 /* Emit debug info for the record. We used to throw away
5707 empty records but we no longer do that because we need
5708 them to generate complete debug info for the variant;
5709 otherwise, the union type definition will be lacking
5710 the fields associated with these empty variants. */
5715 (all_rep_and_size
5718 (all_rep_and_size
5726 }
5730 }
5732 /* Only make the QUAL_UNION_TYPE if there are any non-empty variants. */
5734 {
5736 {
5740 }
5745 /* If GNU_UNION_TYPE is our record type, it means we must have an
5746 Unchecked_Union with no fields. Verify that and, if so, just
5747 return. */
5749 {
5752 }
5754 gnu_union_field
5756 packed,
5763 }
5764 }
5766 /* Scan GNU_FIELD_LIST and see if any fields have rep clauses. If they
5767 do, pull them out and put them into GNU_OUR_REP_LIST. We have to do this
5768 in a separate pass since we want to handle the discriminants but can't
5769 play with them until we've used them in debugging data above.
5771 ??? Note: if we then reorder them, debugging information will be wrong,
5772 but there's nothing that can be done about this at the moment. */
5775 {
5777 {
5782 else
5788 }
5789 else
5790 {
5793 }
5794 }
5796 /* If we have any items in our rep'ed field list, it is not the case that all
5797 the fields in the record have rep clauses, and P_REP_LIST is nonzero,
5798 set it and ignore the items. */
5802 {
5803 /* Otherwise, sort the fields by bit position and put them into their
5804 own record if we have any fields without rep clauses. */
5805 tree gnu_rep_type
5817 /* Put the fields in the list in order of increasing position, which
5818 means we start from the end. */
5821 {
5825 }
5828 {
5834 }
5835 else
5836 {
5839 }
5840 }
5847 }
5848 \f
5849 /* Called via qsort from the above. Returns -1, 1, depending on the
5850 bit positions and ordinals of the two fields. Use DECL_UID to ensure
5851 a stable sort. */
5853 static int
5855 {
5863 else
5865 }
5866 \f
5867 /* Given GNU_SIZE, a GCC tree representing a size, return a Uint to be
5868 placed into an Esize, Component_Bit_Offset, or Component_Size value
5869 in the GNAT tree. */
5871 static Uint
5873 {
5875 TCode tcode;
5880 /* See if we've already saved the value for this node. */
5884 /* If we do not return inside this switch, TCODE will be set to the
5885 code to use for a Create_Node operand and LEN (set above) will be
5886 the number of recursive calls for us to make. */
5889 {
5894 /* This may have come from a conversion from some smaller type,
5895 so ensure this is in bitsizetype. */
5898 /* For negative values, use NEGATE_EXPR of the supplied value. */
5900 {
5901 /* The ridiculous code below is to handle the case of the largest
5902 negative integer. */
5905 tree temp;
5908 {
5909 negative_size
5912 bitsize_one_node));
5914 }
5921 }
5928 /* This peculiar test is to make sure that the size fits in an int
5929 on machines where HOST_WIDE_INT is not "int". */
5932 else
5936 /* The only case we handle here is a simple discriminant reference. */
5944 else
5950 /* Now just list the operations we handle. */
5982 }
5984 /* Now get each of the operands that's relevant for this code. If any
5985 cannot be expressed as a repinfo node, say we can't. */
5990 {
5994 }
5999 }
6001 /* Given GNAT_ENTITY, a record type, and GNU_TYPE, its corresponding
6002 GCC type, set Component_Bit_Offset and Esize to the position and size
6003 used by Gigi. */
6005 static void
6007 {
6008 tree gnu_list;
6009 tree gnu_entry;
6010 Entity_Id gnat_field;
6012 /* We operate by first making a list of all fields and their positions
6013 (we can get the sizes easily at any time) by a recursive call
6014 and then update all the sizes into the tree. */
6017 BIGGEST_ALIGNMENT);
6024 {
6028 gnu_list);
6031 {
6033 {
6034 /* In this mode the tag and parent components have not been
6035 generated, so we add the appropriate offset to each
6036 component. For a component appearing in the current
6037 extension, the offset is the size of the parent. */
6040 parent_offset
6042 bitsizetype);
6043 else
6045 }
6047 Set_Component_Bit_Offset
6049 annotate_value
6054 parent_offset)));
6058 }
6061 {
6062 /* If there is no gnu_entry, this is an inherited component whose
6063 position is the same as in the parent type. */
6064 Set_Component_Bit_Offset
6069 }
6070 }
6071 }
6073 /* Scan all fields in GNU_TYPE and build entries where TREE_PURPOSE is the
6074 FIELD_DECL and TREE_VALUE a TREE_LIST with TREE_PURPOSE being the byte
6075 position and TREE_VALUE being a TREE_LIST with TREE_PURPOSE the value to be
6076 placed into DECL_OFFSET_ALIGN and TREE_VALUE the bit position. GNU_POS is
6077 to be added to the position, GNU_BITPOS to the bit position, OFFSET_ALIGN is
6078 the present value of DECL_OFFSET_ALIGN and GNU_LIST is a list of the entries
6079 so far. */
6081 static tree
6084 {
6085 tree gnu_field;
6090 {
6095 unsigned int our_offset_align
6098 gnu_result
6103 NULL_TREE),
6104 gnu_result);
6107 gnu_result
6110 our_offset_align);
6111 }
6114 }
6115 \f
6116 /* UINT_SIZE is a Uint giving the specified size for an object of GNU_TYPE
6117 corresponding to GNAT_OBJECT. If size is valid, return a tree corresponding
6118 to its value. Otherwise return 0. KIND is VAR_DECL is we are specifying
6119 the size for an object, TYPE_DECL for the size of a type, and FIELD_DECL
6120 for the size of a field. COMPONENT_P is true if we are being called
6121 to process the Component_Size of GNAT_OBJECT. This is used for error
6122 message handling and to indicate to use the object size of GNU_TYPE.
6123 ZERO_OK is true if a size of zero is permitted; if ZERO_OK is false,
6124 it means that a size of zero should be treated as an unspecified size. */
6126 static tree
6129 {
6130 Node_Id gnat_error_node;
6131 tree type_size
6133 tree size;
6135 /* Find the node to use for errors. */
6142 else
6145 /* Return 0 if no size was specified, either because Esize was not Present or
6146 the specified size was zero. */
6150 /* Get the size as a tree. Give an error if a size was specified, but cannot
6151 be represented as in sizetype. */
6154 {
6159 }
6161 /* Ignore a negative size since that corresponds to our back-annotation.
6162 Also ignore a zero size unless a size clause exists. */
6166 /* The size of objects is always a multiple of a byte. */
6169 {
6173 else
6177 }
6179 /* If this is an integral type or a packed array type, the front-end has
6180 verified the size, so we need not do it here (which would entail
6181 checking against the bounds). However, if this is an aliased object, it
6182 may not be smaller than the type of the object. */
6187 /* If the object is a record that contains a template, add the size of
6188 the template to the specified size. */
6193 /* Modify the size of the type to be that of the maximum size if it has a
6194 discriminant or the size of a thin pointer if this is a fat pointer. */
6200 /* If this is an access type, the minimum size is that given by the smallest
6201 integral mode that's valid for pointers. */
6203 {
6209 ;
6212 }
6214 /* If the size of the object is a constant, the new size must not be
6215 smaller. */
6219 {
6221 post_error_ne_tree
6224 else
6231 post_error_ne_tree_2
6241 }
6244 }
6245 \f
6246 /* Similarly, but both validate and process a value of RM_Size. This
6247 routine is only called for types. */
6249 static void
6251 {
6252 /* Only give an error if a Value_Size clause was explicitly given.
6253 Otherwise, we'd be duplicating an error on the Size clause. */
6254 Node_Id gnat_attr_node
6257 tree size;
6259 /* Get the size as a tree. Do nothing if none was specified, either
6260 because RM_Size was not Present or if the specified size was zero.
6261 Give an error if a size was specified, but cannot be represented as
6262 in sizetype. */
6268 {
6271 gnat_entity);
6274 }
6276 /* Ignore a negative size since that corresponds to our back-annotation.
6277 Also ignore a zero size unless a size clause exists, a Value_Size
6278 clause exists, or this is an integer type, in which case the
6279 front end will have always set it. */
6286 /* If the old size is self-referential, get the maximum size. */
6290 /* If the size of the object is a constant, the new size must not be
6291 smaller (the front end checks this for scalar types). */
6296 {
6298 post_error_ne_tree
6303 }
6305 /* Otherwise, set the RM_Size. */
6316 }
6317 \f
6318 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
6319 If TYPE is the best type, return it. Otherwise, make a new type. We
6320 only support new integral and pointer types. BIASED_P is nonzero if
6321 we are making a biased type. */
6323 static tree
6325 {
6326 tree new_type;
6330 /* If size indicates an error, just return TYPE to avoid propagating the
6331 error. Likewise if it's too large to represent. */
6337 {
6340 /* Only do something if the type is not already the proper size and is
6341 not a packed array type. */
6353 new_type
6365 /* Do something if this is a fat pointer, in which case we
6366 may need to return the thin pointer. */
6368 return
6369 build_pointer_type
6374 /* Only do something if this is a thin pointer, in which case we
6375 may need to return the fat pointer. */
6377 return
6384 }
6387 }
6388 \f
6389 /* ALIGNMENT is a Uint giving the alignment specified for GNAT_ENTITY,
6390 a type or object whose present alignment is ALIGN. If this alignment is
6391 valid, return it. Otherwise, give an error and return ALIGN. */
6393 static unsigned int
6395 {
6399 #ifndef MAX_OFILE_ALIGNMENT
6400 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
6401 #endif
6406 /* Don't worry about checking alignment if alignment was not specified
6407 by the source program and we already posted an error for this entity. */
6412 /* Within GCC, an alignment is an integer, so we must make sure a
6413 value is specified that fits in that range. Also, alignments of
6414 more than MAX_OFILE_ALIGNMENT can't be supported. */
6428 else
6432 }
6433 \f
6434 /* Verify that OBJECT, a type or decl, is something we can implement
6435 atomically. If not, give an error for GNAT_ENTITY. COMP_P is true
6436 if we require atomic components. */
6438 static void
6440 {
6442 Node_Id gnat_node;
6445 tree size;
6447 /* There are three case of what OBJECT can be. It can be a type, in which
6448 case we take the size, alignment and mode from the type. It can be a
6449 declaration that was indirect, in which case the relevant values are
6450 that of the type being pointed to, or it can be a normal declaration,
6451 in which case the values are of the decl. The code below assumes that
6452 OBJECT is either a type or a decl. */
6454 {
6458 }
6460 {
6464 }
6465 else
6466 {
6470 }
6472 /* Consider all floating-point types atomic and any types that that are
6473 represented by integers no wider than a machine word. */
6480 /* For the moment, also allow anything that has an alignment equal
6481 to its size and which is smaller than a word. */
6489 {
6497 }
6502 else
6505 }
6506 \f
6507 /* Check if FTYPE1 and FTYPE2, two potentially different function type nodes,
6508 have compatible signatures so that a call using one type may be safely
6509 issued if the actual target function type is the other. Return 1 if it is
6510 the case, 0 otherwise, and post errors on the incompatibilities.
6512 This is used when an Ada subprogram is mapped onto a GCC builtin, to ensure
6513 that calls to the subprogram will have arguments suitable for the later
6514 underlying builtin expansion. */
6516 static int
6518 {
6519 /* As of now, we only perform very trivial tests and consider it's the
6520 programmer's responsibility to ensure the type correctness in the Ada
6521 declaration, as in the regular Import cases.
6523 Mismatches typically result in either error messages from the builtin
6524 expander, internal compiler errors, or in a real call sequence. This
6525 should be refined to issue diagnostics helping error detection and
6526 correction. */
6528 /* Almost fake test, ensuring a use of each argument. */
6533 }
6534 \f
6535 /* Given a type T, a FIELD_DECL F, and a replacement value R, return a new type
6536 with all size expressions that contain F updated by replacing F with R.
6537 This is identical to GCC's substitute_in_type except that it knows about
6538 TYPE_INDEX_TYPE. If F is NULL_TREE, always make a new RECORD_TYPE, even if
6539 nothing has changed. */
6541 tree
6543 {
6545 tree tem;
6548 {
6554 {
6563 SET_TYPE_INDEX_TYPE
6566 }
6573 {
6587 }
6601 /* Don't know how to do these yet. */
6605 {
6619 /* If we had bounded the sizes of T by a constant, bound the sizes of
6620 NEW by the same constant. */
6630 }
6635 {
6636 tree field;
6637 bool changed_field
6644 /* Start out with no fields, make new fields, and chain them
6645 in. If we haven't actually changed the type of any field,
6646 discard everything we've done and return the old type. */
6652 {
6663 /* If this is an internal field and the type of this field is
6664 a UNION_TYPE or RECORD_TYPE with no elements, ignore it. If
6665 the type just has one element, treat that as the field.
6666 But don't do this if we are processing a QUAL_UNION_TYPE. */
6671 {
6676 {
6677 tree next_new_field
6680 /* Make sure omitting the union doesn't change
6681 the layout. */
6684 }
6685 }
6692 /* If the size of the old field was set at a constant,
6693 propagate the size in case the type's size was variable.
6694 (This occurs in the case of a variant or discriminated
6695 record with a default size used as a field of another
6696 record.) */
6705 {
6711 /* Do the substitution inside the qualifier and if we find
6712 that this field will not be present, omit it. */
6717 }
6721 else
6726 /* If this is a qualified type and this field will always be
6727 present, we are done. */
6731 }
6733 /* If this used to be a qualified union type, but we now know what
6734 field will be present, make this a normal union. */
6745 /* If the size was originally a constant use it. */
6748 {
6752 }
6755 }
6759 }
6760 }
6761 \f
6762 /* Return the "RM size" of GNU_TYPE. This is the actual number of bits
6763 needed to represent the object. */
6765 tree
6767 {
6768 /* For integer types, this is the precision. For record types, we store
6769 the size explicitly. For other types, this is just the size. */
6775 /* Return the rm_size of the actual data plus the size of the template. */
6776 return
6786 else
6788 }
6789 \f
6790 /* Return an identifier representing the external name to be used for
6791 GNAT_ENTITY. If SUFFIX is specified, the name is followed by "___"
6792 and the specified suffix. */
6794 tree
6796 {
6805 /* A variable using the Stdcall convention (meaning we are running
6806 on a Windows box) live in a DLL. Here we adjust its name to use
6807 the jump-table, the _imp__NAME contains the address for the NAME
6808 variable. */
6811 {
6818 }
6821 }
6823 /* Return the name to be used for GNAT_ENTITY. If a type, create a
6824 fully-qualified name, possibly with type information encoding.
6825 Otherwise, return the name. */
6827 tree
6829 {
6832 }
6834 /* Given GNU_ID, an IDENTIFIER_NODE containing a name and SUFFIX, a
6835 string, return a new IDENTIFIER_NODE that is the concatenation of
6836 the name in GNU_ID and SUFFIX. */
6838 tree
6840 {
6849 }