| blob | 063d34c722402c32bbd12ac359b6c2ed8cd587b8 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2015, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
20 * *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
23 * *
24 ****************************************************************************/
83 /* If nonzero, pretend we are allocating at global level. */
86 /* The default alignment of "double" floating-point types, i.e. floating
87 point types whose size is equal to 64 bits, or 0 if this alignment is
88 not specifically capped. */
91 /* The default alignment of "double" or larger scalar types, i.e. scalar
92 types whose size is greater or equal to 64 bits, or 0 if this alignment
93 is not specifically capped. */
96 /* True if floating-point arithmetics may use wider intermediate results. */
99 /* Tree nodes for the various types and decls we create. */
102 /* Functions to call for each of the possible raise reasons. */
105 /* Likewise, but with extra info for each of the possible raise reasons. */
108 /* Forward declarations for handlers of attributes. */
123 /* Fake handler for attributes we don't properly support, typically because
124 they'd require dragging a lot of the common-c front-end circuitry. */
127 /* Table of machine-independent internal attributes for Ada. We support
128 this minimal set of attributes to accommodate the needs of builtins. */
130 {
131 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
132 affects_type_identity } */
162 /* ??? format and format_arg are heavy and not supported, which actually
163 prevents support for stdio builtins, which we however declare as part
164 of the common builtins.def contents. */
169 };
171 /* Associates a GNAT tree node to a GCC tree node. It is used in
172 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
173 of `save_gnu_tree' for more info. */
176 #define GET_GNU_TREE(GNAT_ENTITY) \
177 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id]
179 #define SET_GNU_TREE(GNAT_ENTITY,VAL) \
180 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] = (VAL)
182 #define PRESENT_GNU_TREE(GNAT_ENTITY) \
183 (associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
185 /* Associates a GNAT entity to a GCC tree node used as a dummy, if any. */
188 #define GET_DUMMY_NODE(GNAT_ENTITY) \
189 dummy_node_table[(GNAT_ENTITY) - First_Node_Id]
191 #define SET_DUMMY_NODE(GNAT_ENTITY,VAL) \
192 dummy_node_table[(GNAT_ENTITY) - First_Node_Id] = (VAL)
194 #define PRESENT_DUMMY_NODE(GNAT_ENTITY) \
195 (dummy_node_table[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
197 /* This variable keeps a table for types for each precision so that we only
198 allocate each of them once. Signed and unsigned types are kept separate.
200 Note that these types are only used when fold-const requests something
201 special. Perhaps we should NOT share these types; we'll see how it
202 goes later. */
205 /* Likewise for float types, but record these by mode. */
208 /* For each binding contour we allocate a binding_level structure to indicate
209 the binding depth. */
212 /* The binding level containing this one (the enclosing binding level). */
214 /* The BLOCK node for this level. */
215 tree block;
216 /* If nonzero, the setjmp buffer that needs to be updated for any
217 variable-sized definition within this context. */
218 tree jmpbuf_decl;
219 };
221 /* The binding level currently in effect. */
224 /* A chain of gnat_binding_level structures awaiting reuse. */
227 /* The context to be used for global declarations. */
230 /* An array of global declarations. */
233 /* An array of builtin function declarations. */
236 /* An array of global renaming pointers. */
239 /* A chain of unused BLOCK nodes. */
242 /* A hash table of padded types. It is modelled on the generic type
243 hash table in tree.c, which must thus be used as a reference. */
247 tree type;
248 };
251 {
255 };
268 /* A linked list used as a queue to defer the initialization of the
269 DECL_CONTEXT attribute of ..._DECL nodes and of the TYPE_CONTEXT attribute
270 of ..._TYPE nodes. */
271 struct deferred_decl_context_node
272 {
277 context to. */
279 };
283 /* Defer the initialization of DECL's DECL_CONTEXT attribute, scheduling to
284 feed it with the elaboration of GNAT_SCOPE. */
288 /* Defer the initialization of TYPE's TYPE_CONTEXT attribute, scheduling to
289 feed it with the DECL_CONTEXT computed as part of N as soon as it is
290 computed. */
292 tree type);
293 \f
294 /* Initialize data structures of the utils.c module. */
296 void
298 {
299 /* Initialize the association of GNAT nodes to GCC trees. */
302 /* Initialize the association of GNAT nodes to GCC trees as dummies. */
305 /* Initialize the hash table of padded types. */
307 }
309 /* Destroy data structures of the utils.c module. */
311 void
313 {
314 /* Destroy the association of GNAT nodes to GCC trees. */
318 /* Destroy the association of GNAT nodes to GCC trees as dummies. */
322 /* Destroy the hash table of padded types. */
326 /* Invalidate the global renaming pointers. */
328 }
329 \f
330 /* GNAT_ENTITY is a GNAT tree node for an entity. Associate GNU_DECL, a GCC
331 tree node, with GNAT_ENTITY. If GNU_DECL is not a ..._DECL node, abort.
332 If NO_CHECK is true, the latter check is suppressed.
334 If GNU_DECL is zero, reset a previous association. */
336 void
338 {
339 /* Check that GNAT_ENTITY is not already defined and that it is being set
340 to something which is a decl. If that is not the case, this usually
341 means GNAT_ENTITY is defined twice, but occasionally is due to some
342 Gigi problem. */
348 }
350 /* GNAT_ENTITY is a GNAT tree node for an entity. Return the GCC tree node
351 that was associated with it. If there is no such tree node, abort.
353 In some cases, such as delayed elaboration or expressions that need to
354 be elaborated only once, GNAT_ENTITY is really not an entity. */
356 tree
358 {
361 }
363 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
365 bool
367 {
369 }
370 \f
371 /* Make a dummy type corresponding to GNAT_TYPE. */
373 tree
375 {
377 tree gnu_type;
379 /* If there was no equivalent type (can only happen when just annotating
380 types) or underlying type, go back to the original type. */
384 /* If it there already a dummy type, use that one. Else make one. */
388 /* If this is a record, make a RECORD_TYPE or UNION_TYPE; else make
389 an ENUMERAL_TYPE. */
403 }
405 /* Return the dummy type that was made for GNAT_TYPE, if any. */
407 tree
409 {
411 }
413 /* Build dummy fat and thin pointer types whose designated type is specified
414 by GNAT_DESIG_TYPE/GNU_DESIG_TYPE and attach them to the latter. */
416 void
418 {
433 /* Build a stub DECL to trigger the special processing for fat pointer types
434 in gnat_pushdecl. */
437 gnu_fat_type);
445 /* Suppress debug info until after the type is completed. */
454 }
455 \f
456 /* Return true if we are in the global binding level. */
458 bool
460 {
462 }
464 /* Enter a new binding level. */
466 void
468 {
471 /* Reuse a struct for this binding level, if there is one. */
473 {
476 }
477 else
480 /* Use a free BLOCK, if any; otherwise, allocate one. */
482 {
486 }
487 else
490 /* Point the BLOCK we just made to its parent. */
498 /* Add this level to the front of the chain (stack) of active levels. */
502 }
504 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
505 and point FNDECL to this BLOCK. */
507 void
509 {
513 }
515 /* Set the jmpbuf_decl for the current binding level to DECL. */
517 void
519 {
521 }
523 /* Get the jmpbuf_decl, if any, for the current binding level. */
525 tree
527 {
529 }
531 /* Exit a binding level. Set any BLOCK into the current code group. */
533 void
535 {
542 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
543 are no variables free the block and merge its subblocks into those of its
544 parent block. Otherwise, add it to the list of its parent. */
546 ;
548 {
554 }
555 else
556 {
561 }
563 /* Free this binding structure. */
567 }
569 /* Exit a binding level and discard the associated BLOCK. */
571 void
573 {
580 /* Free this binding structure. */
584 }
585 \f
586 /* Set the context of TYPE and its parallel types (if any) to CONTEXT. */
588 static void
590 {
596 {
599 /* Give a context to the parallel types and their stub decl, if any.
600 Some parallel types seems to be present in multiple parallel type
601 chains, so don't mess with their context if they already have one. */
603 {
607 }
610 }
611 }
613 /* Return the innermost scope, starting at GNAT_NODE, we are be interested in
614 the debug info, or Empty if there is no such scope. If not NULL, set
615 IS_SUBPROGRAM to whether the returned entity is a subprogram. */
617 static Entity_Id
619 {
620 Entity_Id gnat_entity;
627 else
631 {
633 {
639 /* If the scope is a subprogram, then just rely on
640 current_function_decl, so that we don't have to defer
641 anything. This is needed because other places rely on the
642 validity of the DECL_CONTEXT attribute of FUNCTION_DECL nodes. */
652 /* By default, we are not interested in this particular scope: go to
653 the outer one. */
655 }
657 }
659 }
661 /* If N is NULL, set TYPE's context to CONTEXT. Defer this to the processing of
662 N otherwise. */
664 static void
666 tree context,
668 {
671 else
673 }
675 /* Return global_context. Create it if needed, first. */
677 static tree
679 {
683 }
685 /* Record DECL as belonging to the current lexical scope and use GNAT_NODE
686 for location information and flag propagation. */
688 void
690 {
694 /* If explicitely asked to make DECL global or if it's an imported nested
695 object, short-circuit the regular Scope-based context computation. */
697 {
698 /* Rely on the GNAT scope, or fallback to the current_function_decl if
699 the GNAT scope reached the global scope, if it reached a subprogram
700 or the declaration is a subprogram or a variable (for them we skip
701 intermediate context types because the subprogram body elaboration
702 machinery and the inliner both expect a subprogram context).
704 Falling back to current_function_decl is necessary for implicit
705 subprograms created by gigi, such as the elaboration subprograms. */
707 const Entity_Id gnat_scope
711 && !context_is_subprogram
714 /* Always assume the scope has not been elaborated, thus defer the
715 context propagation to the time its elaboration will be
716 available. */
717 deferred_decl_context
720 /* External declarations (when force_global > 0) may not be in a
721 local context. */
724 }
726 /* If either we are forced to be in global mode or if both the GNAT scope and
727 the current_function_decl did not help determining the context, use the
728 global scope. */
732 /* Functions imported in another function are not really nested.
733 For really nested functions mark them initially as needing
734 a static chain for uses of that flag before unnesting;
735 lower_nested_functions will then recompute it. */
748 /* Set the location of DECL and emit a declaration for it. */
754 /* Put the declaration on the list. The list of declarations is in reverse
755 order. The list will be reversed later. Put global declarations in the
756 globals list and local ones in the current block. But skip TYPE_DECLs
757 for UNCONSTRAINED_ARRAY_TYPE in both cases, as they will cause trouble
758 with the debugger and aren't needed anyway. */
761 {
763 {
766 }
769 else
770 {
773 }
774 }
776 /* For the declaration of a type, set its name either if it isn't already
777 set or if the previous type name was not derived from a source name.
778 We'd rather have the type named with a real name and all the pointer
779 types to the same object have the same node, except when the names are
780 both derived from source names. */
782 {
787 {
788 /* Array types aren't "tagged" types so we force the type to be
789 associated with its typedef in the DWARF back-end, in order to
790 make sure that the latter is always preserved, by creating an
791 on-side copy for DECL_ORIGINAL_TYPE. We used to do the same
792 for pointer types, but to have consistent DWARF output we now
793 create a copy for the type itself and use the original type
794 for DECL_ORIGINAL_TYPE like the C front-end. */
796 {
798 /* Array types need to have a name so that they can be related
799 to their GNAT encodings. */
803 deferred_decl_context);
806 }
807 }
810 {
811 tree tt;
812 /* ??? Copy and original type are not supposed to be variant but we
813 really need a variant for the placeholder machinery to work. */
816 else
817 {
818 /* TYPE_NEXT_PTR_TO is a chain of main variants. */
822 }
826 deferred_decl_context);
833 else
836 }
840 ;
841 else
844 /* Propagate the name to all the anonymous variants. This is needed
845 for the type qualifiers machinery to work properly (see
846 check_qualified_type). Also propagate the context to them. Note that
847 the context will be propagated to all parallel types too thanks to
848 gnat_set_type_context. */
852 {
856 deferred_decl_context);
857 }
858 }
859 }
860 \f
861 /* Create a record type that contains a SIZE bytes long field of TYPE with a
862 starting bit position so that it is aligned to ALIGN bits, and leaving at
863 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
864 record is guaranteed to get. GNAT_NODE is used for the position of the
865 associated TYPE_DECL. */
867 tree
870 {
871 /* We will be crafting a record type with one field at a position set to be
872 the next multiple of ALIGN past record'address + room bytes. We use a
873 record placeholder to express record'address. */
877 tree record_addr_st
880 /* The diagram below summarizes the shape of what we manipulate:
882 <--------- pos ---------->
883 { +------------+-------------+-----------------+
884 record =>{ |############| ... | field (type) |
885 { +------------+-------------+-----------------+
886 |<-- room -->|<- voffset ->|<---- size ----->|
887 o o
888 | |
889 record_addr vblock_addr
891 Every length is in sizetype bytes there, except "pos" which has to be
892 set as a bit position in the GCC tree for the record. */
902 /* Compute VOFFSET and then POS. The next byte position multiple of some
903 alignment after some address is obtained by "and"ing the alignment minus
904 1 with the two's complement of the address. */
909 /* POS = (ROOM + VOFFSET) * BIT_PER_UNIT, in bitsizetype. */
913 bitsize_unit_node);
915 /* Craft the GCC record representation. We exceptionally do everything
916 manually here because 1) our generic circuitry is not quite ready to
917 handle the complex position/size expressions we are setting up, 2) we
918 have a strong simplifying factor at hand: we know the maximum possible
919 value of voffset, and 3) we have to set/reset at least the sizes in
920 accordance with this maximum value anyway, as we need them to convey
921 what should be "alloc"ated for this type.
923 Use -1 as the 'addressable' indication for the field to prevent the
924 creation of a bitfield. We don't need one, it would have damaging
925 consequences on the alignment computation, and create_field_decl would
926 make one without this special argument, for instance because of the
927 complex position expression. */
938 bitsize_unit_node),
947 /* Declare it now since it will never be declared otherwise. This is
948 necessary to ensure that its subtrees are properly marked. */
952 }
954 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
955 as the field type of a packed record if IN_RECORD is true, or as the
956 component type of a packed array if IN_RECORD is false. See if we can
957 rewrite it either as a type that has a non-BLKmode, which we can pack
958 tighter in the packed record case, or as a smaller type. If so, return
959 the new type. If not, return the original type. */
961 tree
963 {
969 /* No point in doing anything if the size is zero. */
975 /* Copy the name and flags from the old type to that of the new.
976 Note that we rely on the pointer equality created here for
977 TYPE_NAME to look through conversions in various places. */
985 /* If we are in a record and have a small size, set the alignment to
986 try for an integral mode. Otherwise set it to try for a smaller
987 type with BLKmode. */
989 {
993 }
994 else
995 {
998 /* Do not try to shrink the size if the RM size is not constant. */
1003 /* Round the RM size up to a unit boundary to get the minimal size
1004 for a BLKmode record. Give up if it's already the size. */
1012 }
1016 /* Now copy the fields, keeping the position and size as we don't want
1017 to change the layout by propagating the packedness downwards. */
1020 {
1029 /* However, for the last field in a not already packed record type
1030 that is of an aggregate type, we need to use the RM size in the
1031 packable version of the record type, see finish_record_type. */
1039 else
1042 new_field
1055 }
1063 /* If this is a padding record, we never want to make the size smaller
1064 than what was specified. For QUAL_UNION_TYPE, also copy the size. */
1066 {
1070 }
1071 else
1072 {
1076 }
1083 /* Try harder to get a packable type if necessary, for example
1084 in case the record itself contains a BLKmode field. */
1089 /* If neither the mode nor the size has shrunk, return the old type. */
1094 }
1096 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
1097 If TYPE is the best type, return it. Otherwise, make a new type. We
1098 only support new integral and pointer types. FOR_BIASED is true if
1099 we are making a biased type. */
1101 tree
1103 {
1106 tree new_type;
1108 /* If size indicates an error, just return TYPE to avoid propagating
1109 the error. Likewise if it's too large to represent. */
1116 {
1123 /* Integer types with precision 0 are forbidden. */
1127 /* Only do something if the type isn't a packed array type and doesn't
1128 already have the proper size and the size isn't too large. */
1137 else
1142 /* Copy the name to show that it's essentially the same type and
1143 not a subrange type. */
1150 /* Do something if this is a fat pointer, in which case we
1151 may need to return the thin pointer. */
1153 {
1157 return
1158 build_pointer_type_for_mode
1161 }
1165 /* Only do something if this is a thin pointer, in which case we
1166 may need to return the fat pointer. */
1168 return
1174 }
1177 }
1179 /* See if the data pointed to by the hash table slot is marked. */
1181 void
1183 {
1189 else
1191 }
1193 /* Return true iff the padded types are equivalent. */
1195 bool
1197 {
1206 /* We consider that the padded types are equivalent if they pad the same type
1207 and have the same size, alignment, RM size and storage order. Taking the
1208 mode into account is redundant since it is determined by the others. */
1209 return
1215 }
1217 /* Look up the padded TYPE in the hash table and return its canonical version
1218 if it exists; otherwise, insert it into the hash table. */
1220 static tree
1222 {
1223 hashval_t hashcode;
1226 hashcode
1243 }
1245 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
1246 if needed. We have already verified that SIZE and ALIGN are large enough.
1247 GNAT_ENTITY is used to name the resulting record and to issue a warning.
1248 IS_COMPONENT_TYPE is true if this is being done for the component type of
1249 an array. IS_USER_TYPE is true if the original type needs to be completed.
1250 DEFINITION is true if this type is being defined. SET_RM_SIZE is true if
1251 the RM size of the resulting type is to be set to SIZE too. */
1253 tree
1257 {
1262 /* If TYPE is a padded type, see if it agrees with any size and alignment
1263 we were given. If so, return the original type. Otherwise, strip
1264 off the padding, since we will either be returning the inner type
1265 or repadding it. If no size or alignment is specified, use that of
1266 the original padded type. */
1268 {
1282 }
1284 /* If the size is either not being changed or is being made smaller (which
1285 is not done here and is only valid for bitfields anyway), show the size
1286 isn't changing. Likewise, clear the alignment if it isn't being
1287 changed. Then return if we aren't doing anything. */
1300 /* If requested, complete the original type and give it a name. */
1307 gnat_entity);
1309 /* We used to modify the record in place in some cases, but that could
1310 generate incorrect debugging information. So make a new record
1311 type and name. */
1323 bitsize_unit_node));
1325 /* If we are changing the alignment and the input type is a record with
1326 BLKmode and a small constant size, try to make a form that has an
1327 integral mode. This might allow the padding record to also have an
1328 integral mode, which will be much more efficient. There is no point
1329 in doing so if a size is specified unless it is also a small constant
1330 size and it is incorrect to do so if we cannot guarantee that the mode
1331 will be naturally aligned since the field must always be addressable.
1333 ??? This might not always be a win when done for a stand-alone object:
1334 since the nominal and the effective type of the object will now have
1335 different modes, a VIEW_CONVERT_EXPR will be required for converting
1336 between them and it might be hard to overcome afterwards, including
1337 at the RTL level when the stand-alone object is accessed as a whole. */
1345 && (!size
1348 {
1353 }
1355 /* Now create the field with the original size. */
1360 /* Do not emit debug info until after the auxiliary record is built. */
1363 /* Set the RM size if requested. */
1365 {
1366 tree canonical_pad_type;
1370 /* If the padded type is complete and has constant size, we canonicalize
1371 it by means of the hash table. This is consistent with the language
1372 semantics and ensures that gigi and the middle-end have a common view
1373 of these padded types. */
1376 {
1379 }
1380 }
1382 /* Unless debugging information isn't being written for the input type,
1383 write a record that shows what we are a subtype of and also make a
1384 variable that indicates our size, if still variable. */
1390 {
1410 }
1414 built:
1415 /* If the size was widened explicitly, maybe give a warning. Take the
1416 original size as the maximum size of the input if there was an
1417 unconstrained record involved and round it up to the specified alignment,
1418 if one was specified. But don't do it if we are just annotating types
1419 and the type is tagged, since tagged types aren't fully laid out in this
1420 mode. */
1440 {
1443 /* For a packed array, post the message on the original array type. */
1454 /* Generate message only for entities that come from source, since
1455 if we have an entity created by expansion, the message will be
1456 generated for some other corresponding source entity. */
1458 {
1467 }
1468 }
1471 }
1473 /* Return a copy of the padded TYPE but with reverse storage order. */
1475 tree
1477 {
1480 #ifdef ENABLE_CHECKING
1481 /* If the inner type is not scalar then the function does nothing. */
1484 #endif
1486 /* This is required for the canonicalization. */
1496 }
1497 \f
1498 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
1499 If this is a multi-dimensional array type, do this recursively.
1501 OP may be
1502 - ALIAS_SET_COPY: the new set is made a copy of the old one.
1503 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
1504 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
1506 void
1508 {
1509 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
1510 of a one-dimensional array, since the padding has the same alias set
1511 as the field type, but if it's a multi-dimensional array, we need to
1512 see the inner types. */
1518 /* Unconstrained array types are deemed incomplete and would thus be given
1519 alias set 0. Retrieve the underlying array type. */
1521 gnu_old_type
1524 gnu_new_type
1533 {
1535 /* The alias set shouldn't be copied between array types with different
1536 aliasing settings because this can break the aliasing relationship
1537 between the array type and its element type. */
1538 #ifndef ENABLE_CHECKING
1540 #endif
1551 {
1555 /* Do nothing if the alias sets conflict. This ensures that we
1556 never call record_alias_subset several times for the same pair
1557 or at all for alias set 0. */
1559 {
1562 else
1564 }
1565 }
1570 }
1573 }
1574 \f
1575 /* Record TYPE as a builtin type for Ada. NAME is the name of the type.
1576 ARTIFICIAL_P is true if it's a type that was generated by the compiler. */
1578 void
1580 {
1589 }
1590 \f
1591 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1592 finish constructing the record type as a fat pointer type. */
1594 void
1596 {
1597 /* Make sure we can put it into a register. */
1601 /* Show what it really is. */
1604 /* Do not emit debug info for it since the types of its fields may still be
1605 incomplete at this point. */
1608 /* Force type_contains_placeholder_p to return true on it. Although the
1609 PLACEHOLDER_EXPRs are referenced only indirectly, this isn't a pointer
1610 type but the representation of the unconstrained array. */
1612 }
1614 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1615 finish constructing the record or union type. If REP_LEVEL is zero, this
1616 record has no representation clause and so will be entirely laid out here.
1617 If REP_LEVEL is one, this record has a representation clause and has been
1618 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
1619 this record is derived from a parent record and thus inherits its layout;
1620 only make a pass on the fields to finalize them. DEBUG_INFO_P is true if
1621 we need to write debug information about this type. */
1623 void
1626 {
1634 tree field;
1638 /* Always attach the TYPE_STUB_DECL for a record type. It is required to
1639 generate debug info and have a parallel type. */
1642 /* Globally initialize the record first. If this is a rep'ed record,
1643 that just means some initializations; otherwise, layout the record. */
1645 {
1654 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
1655 out just like a UNION_TYPE, since the size will be fixed. */
1658 }
1659 else
1660 {
1661 /* Ensure there isn't a size already set. There can be in an error
1662 case where there is a rep clause but all fields have errors and
1663 no longer have a position. */
1666 /* Ensure we use the traditional GCC layout for bitfields when we need
1667 to pack the record type or have a representation clause. The other
1668 possible layout (Microsoft C compiler), if available, would prevent
1669 efficient packing in almost all cases. */
1670 #ifdef TARGET_MS_BITFIELD_LAYOUT
1675 ATTR_FLAG_TYPE_IN_PLACE);
1676 #endif
1679 }
1681 /* At this point, the position and size of each field is known. It was
1682 either set before entry by a rep clause, or by laying out the type above.
1684 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
1685 to compute the Ada size; the GCC size and alignment (for rep'ed records
1686 that are not padding types); and the mode (for rep'ed records). We also
1687 clear the DECL_BIT_FIELD indication for the cases we know have not been
1688 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
1694 {
1698 tree this_ada_size;
1705 else
1708 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
1711 {
1714 /* In the general case, type alignment is required. */
1716 {
1717 /* The enclosing record type must be sufficiently aligned.
1718 Otherwise, if no alignment was specified for it and it
1719 has been laid out already, bump its alignment to the
1720 desired one if this is compatible with its size. */
1722 {
1725 }
1729 {
1733 }
1734 }
1736 /* In the non-strict alignment case, only byte alignment is. */
1741 }
1743 /* If we still have DECL_BIT_FIELD set at this point, we know that the
1744 field is technically not addressable. Except that it can actually
1745 be addressed if it is BLKmode and happens to be properly aligned. */
1751 /* A type must be as aligned as its most aligned field that is not
1752 a bit-field. But this is already enforced by layout_type. */
1758 {
1765 ada_size
1773 /* Since we know here that all fields are sorted in order of
1774 increasing bit position, the size of the record is one
1775 higher than the ending bit of the last field processed
1776 unless we have a rep clause, since in that case we might
1777 have a field outside a QUAL_UNION_TYPE that has a higher ending
1778 position. So use a MAX in that case. Also, if this field is a
1779 QUAL_UNION_TYPE, we need to take into account the previous size in
1780 the case of empty variants. */
1781 ada_size
1784 size
1791 }
1792 }
1798 {
1799 /* If this is a padding record, we never want to make the size smaller
1800 than what was specified in it, if any. */
1804 /* Now set any of the values we've just computed that apply. */
1810 {
1811 tree size_unit = had_size_unit
1815 bitsize_unit_node));
1823 }
1824 }
1828 }
1830 /* Append PARALLEL_TYPE on the chain of parallel types of TYPE. If
1831 PARRALEL_TYPE has no context and its computation is not deferred yet, also
1832 propagate TYPE's context to PARALLEL_TYPE's or defer its propagation to the
1833 moment TYPE will get a context. */
1835 void
1837 {
1845 /* If PARALLEL_TYPE already has a context, we are done. */
1849 /* Otherwise, try to get one from TYPE's context. */
1851 /* TYPE already has a context, so simply propagate it to PARALLEL_TYPE. */
1854 /* ... otherwise TYPE has not context yet. We know it will thanks to
1855 gnat_pushdecl, and then its context will be propagated to PARALLEL_TYPE.
1856 So we have nothing to do in this case. */
1857 }
1859 /* Return true if TYPE has a parallel type. */
1861 static bool
1863 {
1867 }
1869 /* Wrap up compilation of RECORD_TYPE, i.e. output all the debug information
1870 associated with it. It need not be invoked directly in most cases since
1871 finish_record_type takes care of doing so, but this can be necessary if
1872 a parallel type is to be attached to the record type. */
1874 void
1876 {
1878 tree field;
1880 /* If this is a padded type, the bulk of the debug info has already been
1881 generated for the field's type. */
1885 /* If the type already has a parallel type (XVS type), then we're done. */
1890 {
1891 /* We need to make an XVE/XVU record if any field has variable size,
1892 whether or not the record does. For example, if we have a union,
1893 it may be that all fields, rounded up to the alignment, have the
1894 same size, in which case we'll use that size. But the debug
1895 output routines (except Dwarf2) won't be able to output the fields,
1896 so we need to make the special record. */
1898 /* If a field has a non-constant qualifier, the record will have
1899 variable size too. */
1902 {
1905 }
1906 }
1908 /* If this record type is of variable size, make a parallel record type that
1909 will tell the debugger how the former is laid out (see exp_dbug.ads). */
1911 {
1912 tree new_record_type
1919 new_name
1932 /* Now scan all the fields, replacing each field with a new field
1933 corresponding to the new encoding. */
1936 {
1944 /* We're going to do some pattern matching below so remove as many
1945 conversions as possible. */
1948 /* See how the position was modified from the last position.
1950 There are two basic cases we support: a value was added
1951 to the last position or the last position was rounded to
1952 a boundary and they something was added. Check for the
1953 first case first. If not, see if there is any evidence
1954 of rounding. If so, round the last position and retry.
1956 If this is a union, the position can be taken as zero. */
1959 else
1965 {
1971 }
1976 && tree_fits_uhwi_p
1978 {
1980 unsigned HOST_WIDE_INT addend
1982 align
1988 }
1990 {
1994 }
1996 /* If we can't compute a position, set it to zero.
1998 ??? We really should abort here, but it's too much work
1999 to get this correct for all cases. */
2003 /* See if this type is variable-sized and make a pointer type
2004 and indicate the indirection if so. Beware that the debug
2005 back-end may adjust the position computed above according
2006 to the alignment of the field type, i.e. the pointer type
2007 in this case, if we don't preventively counter that. */
2009 {
2012 {
2015 }
2017 }
2019 /* Make a new field name, if necessary. */
2021 {
2027 else
2031 }
2033 new_field
2039 /* If old_field is a QUAL_UNION_TYPE, take its size as being
2040 zero. The only time it's not the last field of the record
2041 is when there are other components at fixed positions after
2042 it (meaning there was a rep clause for every field) and we
2043 want to be able to encode them. */
2047 ? bitsize_zero_node
2050 }
2055 }
2056 }
2058 /* Utility function of above to merge LAST_SIZE, the previous size of a record
2059 with FIRST_BIT and SIZE that describe a field. SPECIAL is true if this
2060 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
2061 replace a value of zero with the old size. If HAS_REP is true, we take the
2062 MAX of the end position of this field with LAST_SIZE. In all other cases,
2063 we use FIRST_BIT plus SIZE. Return an expression for the size. */
2065 static tree
2068 {
2070 tree new_size;
2073 {
2077 }
2079 else
2090 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
2091 when fed through substitute_in_expr) into thinking that a constant
2092 size is not constant. */
2097 }
2099 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
2100 related by the addition of a constant. Return that constant if so. */
2102 static tree
2104 {
2114 else
2116 }
2118 /* Utility function of above to split a tree OP which may be a sum, into a
2119 constant part, which is returned, and a variable part, which is stored
2120 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
2121 bitsizetype. */
2123 static tree
2125 {
2126 /* Strip conversions in order to ease the tree traversal and maximize the
2127 potential for constant or plus/minus discovery. We need to be careful
2128 to always return and set *pvar to bitsizetype trees, but it's worth
2129 the effort. */
2135 {
2138 }
2140 {
2151 }
2152 else
2154 }
2155 \f
2156 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
2157 subprogram. If it is VOID_TYPE, then we are dealing with a procedure,
2158 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
2159 PARM_DECL nodes that are the subprogram parameters. CICO_LIST is the
2160 copy-in/copy-out list to be stored into the TYPE_CICO_LIST field.
2161 RETURN_UNCONSTRAINED_P is true if the function returns an unconstrained
2162 object. RETURN_BY_DIRECT_REF_P is true if the function returns by direct
2163 reference. RETURN_BY_INVISI_REF_P is true if the function returns by
2164 invisible reference. */
2166 tree
2170 {
2171 /* A list of the data type nodes of the subprogram formal parameters.
2172 This list is generated by traversing the input list of PARM_DECL
2173 nodes. */
2182 /* TYPE may have been shared since GCC hashes types. If it has a different
2183 CICO_LIST, make a copy. Likewise for the various flags. */
2186 {
2192 }
2195 }
2196 \f
2197 /* Return a copy of TYPE but safe to modify in any way. */
2199 tree
2201 {
2204 /* Unshare the language-specific data. */
2206 {
2209 }
2211 /* And the contents of the language-specific slot if needed. */
2214 {
2219 }
2221 /* copy_node clears this field instead of copying it, because it is
2222 aliased with TREE_CHAIN. */
2231 }
2232 \f
2233 /* Return a subtype of sizetype with range MIN to MAX and whose
2234 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
2235 of the associated TYPE_DECL. */
2237 tree
2239 {
2240 /* First build a type for the desired range. */
2243 /* Then set the index type. */
2248 }
2250 /* Return a subtype of TYPE with range MIN to MAX. If TYPE is NULL,
2251 sizetype is used. */
2253 tree
2255 {
2256 tree range_type;
2261 /* First build a type with the base range. */
2265 /* Then set the actual range. */
2270 }
2271 \f
2272 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of a type.
2273 TYPE_NAME gives the name of the type and TYPE is a ..._TYPE node giving
2274 its data type. */
2276 tree
2278 {
2279 /* Using a named TYPE_DECL ensures that a type name marker is emitted in
2280 STABS while setting DECL_ARTIFICIAL ensures that no DW_TAG_typedef is
2281 emitted in DWARF. */
2286 }
2288 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type and TYPE
2289 is a ..._TYPE node giving its data type. ARTIFICIAL_P is true if this
2290 is a declaration that was generated by the compiler. DEBUG_INFO_P is
2291 true if we need to write debug information about this type. GNAT_NODE
2292 is used for the position of the decl. */
2294 tree
2297 {
2300 tree type_decl;
2302 /* Only the builtin TYPE_STUB_DECL should be used for dummy types. */
2305 /* If the type hasn't been named yet, we're naming it; preserve an existing
2306 TYPE_STUB_DECL that has been attached to it for some purpose. */
2308 {
2311 }
2312 else
2318 /* Add this decl to the current binding level. */
2321 /* If we're naming the type, equate the TYPE_STUB_DECL to the name. This
2322 causes the name to be also viewed as a "tag" by the debug back-end, with
2323 the advantage that no DW_TAG_typedef is emitted for artificial "tagged"
2324 types in DWARF.
2326 Note that if "type" is used as a DECL_ORIGINAL_TYPE, it may be referenced
2327 from multiple contexts, and "type_decl" references a copy of it: in such a
2328 case, do not mess TYPE_STUB_DECL: we do not want to re-use the TYPE_DECL
2329 with the mechanism above. */
2333 /* Do not generate debug info for UNCONSTRAINED_ARRAY_TYPE that the
2334 back-end doesn't support, and for others if we don't need to. */
2339 }
2340 \f
2341 /* Return a VAR_DECL or CONST_DECL node.
2343 VAR_NAME gives the name of the variable. ASM_NAME is its assembler name
2344 (if provided). TYPE is its data type (a GCC ..._TYPE node). VAR_INIT is
2345 the GCC tree for an optional initial expression; NULL_TREE if none.
2347 CONST_FLAG is true if this variable is constant, in which case we might
2348 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
2350 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
2351 definition to be made visible outside of the current compilation unit, for
2352 instance variable definitions in a package specification.
2354 EXTERN_FLAG is true when processing an external variable declaration (as
2355 opposed to a definition: no storage is to be allocated for the variable).
2357 STATIC_FLAG is only relevant when not at top level. In that case
2358 it indicates whether to always allocate storage to the variable.
2360 GNAT_NODE is used for the position of the decl. */
2362 tree
2367 {
2368 /* Whether the object has static storage duration, either explicitly or by
2369 virtue of being declared at the global level. */
2372 /* Whether the initializer is constant: for an external object or an object
2373 with static storage duration, we check that the initializer is a valid
2374 constant expression for initializing a static variable; otherwise, we
2375 only check that it is constant. */
2376 const bool init_const
2377 = (var_init
2381 != NULL_TREE
2384 /* Whether we will make TREE_CONSTANT the DECL we produce here, in which
2385 case the initializer may be used in lieu of the DECL node (as done in
2386 Identifier_to_gnu). This is useful to prevent the need of elaboration
2387 code when an identifier for which such a DECL is made is in turn used
2388 as an initializer. We used to rely on CONST_DECL vs VAR_DECL for this,
2389 but extra constraints apply to this choice (see below) and they are not
2390 relevant to the distinction we wish to make. */
2393 /* The actual DECL node. CONST_DECL was initially intended for enumerals
2394 and may be used for scalars in general but not for aggregates. */
2395 tree var_decl
2401 /* If this is external, throw away any initializations (they will be done
2402 elsewhere) unless this is a constant for which we would like to remain
2403 able to get the initializer. If we are defining a global here, leave a
2404 constant initialization and save any variable elaborations for the
2405 elaboration routine. If we are just annotating types, throw away the
2406 initialization if it isn't a constant. */
2411 /* At the global level, a non-constant initializer generates elaboration
2412 statements. Check that such statements are allowed, that is to say,
2413 not violating a No_Elaboration_Code restriction. */
2422 /* We need to allocate static storage for an object with static storage
2423 duration if it isn't external. */
2426 /* The object is public if it is external or if it is declared public
2427 and has static storage duration. */
2430 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
2431 try to fiddle with DECL_COMMON. However, on platforms that don't
2432 support global BSS sections, uninitialized global variables would
2433 go in DATA instead, thus increasing the size of the executable. */
2440 /* For an external constant whose initializer is not absolute, do not emit
2441 debug info. In DWARF this would mean a global relocation in a read-only
2442 section which runs afoul of the PE-COFF run-time relocation mechanism. */
2444 && constant_p
2445 && var_init
2456 /* ??? Some attributes cannot be applied to CONST_DECLs. */
2460 /* Add this decl to the current binding level. */
2464 {
2470 }
2473 }
2474 \f
2475 /* Return true if TYPE, an aggregate type, contains (or is) an array. */
2477 static bool
2479 {
2481 {
2485 {
2486 tree field;
2492 }
2499 }
2500 }
2502 /* Return a FIELD_DECL node. FIELD_NAME is the field's name, FIELD_TYPE is
2503 its type and RECORD_TYPE is the type of the enclosing record. If SIZE is
2504 nonzero, it is the specified size of the field. If POS is nonzero, it is
2505 the bit position. PACKED is 1 if the enclosing record is packed, -1 if it
2506 has Component_Alignment of Storage_Unit. If ADDRESSABLE is nonzero, it
2507 means we are allowed to take the address of the field; if it is negative,
2508 we should not make a bitfield, which is used by make_aligning_type. */
2510 tree
2513 {
2520 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
2521 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
2522 Likewise for an aggregate without specified position that contains an
2523 array, because in this case slices of variable length of this array
2524 must be handled by GCC and variable-sized objects need to be aligned
2525 to at least a byte boundary. */
2527 || (!pos
2532 /* If a size is specified, use it. Otherwise, if the record type is packed
2533 compute a size to use, which may differ from the object's natural size.
2534 We always set a size in this case to trigger the checks for bitfield
2535 creation below, which is typically required when no position has been
2536 specified. */
2540 {
2544 }
2546 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
2547 specified for two reasons: first if the size differs from the natural
2548 size. Second, if the alignment is insufficient. There are a number of
2549 ways the latter can be true.
2551 We never make a bitfield if the type of the field has a nonconstant size,
2552 because no such entity requiring bitfield operations should reach here.
2554 We do *preventively* make a bitfield when there might be the need for it
2555 but we don't have all the necessary information to decide, as is the case
2556 of a field with no specified position in a packed record.
2558 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
2559 in layout_decl or finish_record_type to clear the bit_field indication if
2560 it is in fact not needed. */
2562 && size
2567 || packed
2570 {
2574 {
2578 else
2580 }
2581 }
2585 /* Bump the alignment if need be, either for bitfield/packing purposes or
2586 to satisfy the type requirements if no such consideration applies. When
2587 we get the alignment from the type, indicate if this is from an explicit
2588 user request, which prevents stor-layout from lowering it later on. */
2589 {
2590 unsigned int bit_align
2597 {
2600 }
2601 }
2604 {
2605 /* We need to pass in the alignment the DECL is known to have.
2606 This is the lowest-order bit set in POS, but no more than
2607 the alignment of the record, if one is specified. Note
2608 that an alignment of 0 is taken as infinite. */
2613 else
2627 }
2629 /* In addition to what our caller says, claim the field is addressable if we
2630 know that its type is not suitable.
2632 The field may also be "technically" nonaddressable, meaning that even if
2633 we attempt to take the field's address we will actually get the address
2634 of a copy. This is the case for true bitfields, but the DECL_BIT_FIELD
2635 value we have at this point is not accurate enough, so we don't account
2636 for this here and let finish_record_type decide. */
2643 }
2644 \f
2645 /* Return a PARM_DECL node. PARAM_NAME is the name of the parameter and
2646 PARAM_TYPE is its type. READONLY is true if the parameter is readonly
2647 (either an In parameter or an address of a pass-by-ref parameter). */
2649 tree
2651 {
2655 /* Honor TARGET_PROMOTE_PROTOTYPES like the C compiler, as not doing so
2656 can lead to various ABI violations. */
2660 {
2661 /* We have to be careful about biased types here. Make a subtype
2662 of integer_type_node with the proper biasing. */
2665 {
2666 tree subtype
2673 }
2674 else
2676 }
2681 }
2682 \f
2683 /* Process the attributes in ATTR_LIST for NODE, which is either a DECL or
2684 a TYPE. If IN_PLACE is true, the tree pointed to by NODE should not be
2685 changed. GNAT_NODE is used for the position of error messages. */
2687 void
2689 Node_Id gnat_node)
2690 {
2695 {
2704 {
2707 }
2713 else
2720 {
2723 }
2724 else
2743 }
2746 }
2747 \f
2748 /* Record DECL as a global renaming pointer. */
2750 void
2752 {
2755 }
2757 /* Invalidate the global renaming pointers that are not constant, lest their
2758 renamed object contains SAVE_EXPRs tied to an elaboration routine. Note
2759 that we should not blindly invalidate everything here because of the need
2760 to propagate constant values through renaming. */
2762 void
2764 {
2766 tree iter;
2776 }
2778 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
2779 a power of 2. */
2781 bool
2783 {
2792 }
2794 /* Return whether GNAT_NODE is a defining identifier for a renaming that comes
2795 from the parameter association for the instantiation of a generic. We do
2796 not want to emit source location for them: the code generated for their
2797 initialization is likely to disturb debugging. */
2799 bool
2801 {
2808 /* Get the object declaration of the renamed object, if any and if the
2809 renamed object is a mere identifier. */
2819 return
2823 }
2825 /* Defer the initialization of DECL's DECL_CONTEXT attribute, scheduling to
2826 feed it with the elaboration of GNAT_SCOPE. */
2830 {
2833 new_node
2842 }
2844 /* Defer the initialization of TYPE's TYPE_CONTEXT attribute, scheduling to
2845 feed it with the DECL_CONTEXT computed as part of N as soon as it is
2846 computed. */
2848 static void
2850 {
2852 }
2854 /* Get the GENERIC node corresponding to GNAT_SCOPE, if available. Return
2855 NULL_TREE if it is not available. */
2857 static tree
2859 {
2860 tree context;
2864 else
2868 {
2871 /* Skip dummy types: only the final ones can appear in the context
2872 chain. */
2876 /* ..._TYPE nodes are more useful than TYPE_DECL nodes in the context
2877 chain. */
2878 else
2880 }
2883 }
2885 /* Try to process all deferred nodes in the queue. Keep in the queue the ones
2886 that cannot be processed yet, remove the other ones. If FORCE is true,
2887 force the processing for all nodes, use the global context when nodes don't
2888 have a GNU translation. */
2890 void
2892 {
2897 {
2900 Entity_Id gnat_scope;
2904 /* If FORCE, get the innermost elaborated scope. Otherwise, just try to
2905 get the first scope. */
2908 {
2913 }
2915 /* Imported declarations must not be in a local context (i.e. not inside
2916 a function). */
2918 {
2922 {
2927 }
2928 }
2930 /* If FORCE, we want to get rid of all nodes in the queue: in case there
2931 was no elaborated scope, use the global context. */
2936 {
2937 tree t;
2942 /* Propagate it to the TYPE_CONTEXT attributes of the requested
2943 ..._TYPE nodes. */
2945 {
2947 }
2949 }
2951 /* If this node has been successfuly processed, remove it from the
2952 queue. Then move to the next node. */
2954 {
2958 }
2959 else
2961 }
2962 }
2965 /* Return VALUE scaled by the biggest power-of-2 factor of EXPR. */
2967 static unsigned int
2969 {
2972 /* An expression which is a bitwise AND with a mask has a power-of-2 factor
2973 corresponding to the number of trailing zeros of the mask. */
2976 {
2981 {
2984 i++;
2985 }
2986 }
2989 }
2991 /* Given two consecutive field decls PREV_FIELD and CURR_FIELD, return true
2992 unless we can prove these 2 fields are laid out in such a way that no gap
2993 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
2994 is the distance in bits between the end of PREV_FIELD and the starting
2995 position of CURR_FIELD. It is ignored if null. */
2997 static bool
2999 {
3000 /* If this is the first field of the record, there cannot be any gap */
3004 /* If the previous field is a union type, then return false: The only
3005 time when such a field is not the last field of the record is when
3006 there are other components at fixed positions after it (meaning there
3007 was a rep clause for every field), in which case we don't want the
3008 alignment constraint to override them. */
3012 /* If the distance between the end of prev_field and the beginning of
3013 curr_field is constant, then there is a gap if the value of this
3014 constant is not null. */
3018 /* If the size and position of the previous field are constant,
3019 then check the sum of this size and position. There will be a gap
3020 iff it is not multiple of the current field alignment. */
3027 /* If both the position and size of the previous field are multiples
3028 of the current field alignment, there cannot be any gap. */
3033 /* Fallback, return that there may be a potential gap */
3035 }
3037 /* Return a LABEL_DECL with LABEL_NAME. GNAT_NODE is used for the position
3038 of the decl. */
3040 tree
3042 {
3043 tree label_decl
3048 /* Add this decl to the current binding level. */
3052 }
3053 \f
3054 /* Return a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
3055 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
3056 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
3057 PARM_DECL nodes chained through the DECL_CHAIN field).
3059 INLINE_STATUS, PUBLIC_FLAG, EXTERN_FLAG, ARTIFICIAL_FLAG and ATTR_LIST are
3060 used to set the appropriate fields in the FUNCTION_DECL. GNAT_NODE is
3061 used for the position of the decl. */
3063 tree
3068 {
3070 subprog_type);
3079 {
3092 ATTR_FLAG_TYPE_IN_PLACE);
3094 /* ... fall through ... */
3103 }
3116 {
3119 /* The expand_main_function circuitry expects "main_identifier_node" to
3120 designate the DECL_NAME of the 'main' entry point, in turn expected
3121 to be declared as the "main" function literally by default. Ada
3122 program entry points are typically declared with a different name
3123 within the binder generated file, exported as 'main' to satisfy the
3124 system expectations. Force main_identifier_node in this case. */
3127 }
3131 /* Add this decl to the current binding level. */
3134 /* Output the assembler code and/or RTL for the declaration. */
3138 }
3139 \f
3140 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
3141 body. This routine needs to be invoked before processing the declarations
3142 appearing in the subprogram. */
3144 void
3146 {
3147 tree param_decl;
3151 /* This function is being defined. */
3154 /* The failure of this assertion will likely come from a wrong context for
3155 the subprogram body, e.g. another procedure for a procedure declared at
3156 library level. */
3161 /* Enter a new binding level and show that all the parameters belong to
3162 this function. */
3170 }
3172 /* Finish translating the current subprogram and set its BODY. */
3174 void
3176 {
3179 /* Attach the BLOCK for this level to the function and pop the level. */
3184 /* Mark the RESULT_DECL as being in this subprogram. */
3187 /* The body should be a BIND_EXPR whose BLOCK is the top-level one. */
3189 {
3192 }
3197 }
3199 /* Wrap up compilation of SUBPROG_DECL, a subprogram body. */
3201 void
3203 {
3204 /* We cannot track the location of errors past this point. */
3207 /* If we're only annotating types, don't actually compile this function. */
3211 /* Dump functions before gimplification. */
3216 else
3217 /* Register this function with cgraph just far enough to get it
3218 added to our parent's nested function list. */
3220 }
3222 tree
3224 {
3227 }
3229 /* Return an integer type with the number of bits of precision given by
3230 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
3231 it is a signed type. */
3233 tree
3235 {
3236 tree t;
3245 else
3252 {
3255 }
3258 }
3260 /* Likewise for floating-point types. */
3262 static tree
3264 {
3265 tree t;
3277 {
3280 }
3283 }
3285 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
3286 an unsigned type; otherwise a signed type is returned. */
3288 tree
3290 {
3307 {
3312 }
3315 }
3317 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
3319 tree
3321 {
3325 {
3328 }
3332 {
3335 }
3338 }
3340 /* Return the signed version of a TYPE_NODE, a scalar type. */
3342 tree
3344 {
3348 {
3351 }
3355 {
3358 }
3361 }
3363 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
3364 transparently converted to each other. */
3366 int
3368 {
3371 /* This is the default criterion. */
3375 /* We only check structural equivalence here. */
3379 /* Vector types are also compatible if they have the same number of subparts
3380 and the same form of (scalar) element type. */
3387 /* Array types are also compatible if they are constrained and have the same
3388 domain(s), the same component type and the same scalar storage order. */
3404 }
3406 /* Return true if EXPR is a useless type conversion. */
3408 bool
3410 {
3418 }
3420 /* Return true if T, a FUNCTION_TYPE, has the specified list of flags. */
3422 bool
3425 {
3430 }
3431 \f
3432 /* EXP is an expression for the size of an object. If this size contains
3433 discriminant references, replace them with the maximum (if MAX_P) or
3434 minimum (if !MAX_P) possible value of the discriminant. */
3436 tree
3438 {
3443 {
3450 {
3464 }
3468 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
3469 modify. Otherwise, we treat it like a variable. */
3471 {
3475 }
3491 {
3496 /* Special-case wanting the maximum value of a MIN_EXPR.
3497 In that case, if one side overflows, return the other. */
3499 {
3505 }
3507 /* Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
3508 overflowing and the RHS a variable. */
3516 }
3520 {
3544 }
3546 /* Other tree classes cannot happen. */
3549 }
3552 }
3553 \f
3554 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
3555 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
3556 Return a constructor for the template. */
3558 tree
3560 {
3563 tree field;
3575 /* First make the list for a CONSTRUCTOR for the template. Go down the
3576 field list of the template instead of the type chain because this
3577 array might be an Ada array of arrays and we can't tell where the
3578 nested arrays stop being the underlying object. */
3581 (bound_list
3585 {
3588 /* If we have a bound list, get the bounds from there. Likewise
3589 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
3590 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
3591 This will give us a maximum range. */
3599 else
3605 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
3606 substitute it from OBJECT. */
3612 }
3615 }
3616 \f
3617 /* Return true if TYPE is suitable for the element type of a vector. */
3619 static bool
3621 {
3622 machine_mode mode;
3636 }
3638 /* Return a vector type given the SIZE and the INNER_TYPE, or NULL_TREE if
3639 this is not possible. If ATTRIBUTE is non-zero, we are processing the
3640 attribute declaration and want to issue error messages on failure. */
3642 static tree
3644 {
3648 /* Silently punt on variable sizes. We can't make vector types for them,
3649 need to ignore them on front-end generated subtypes of unconstrained
3650 base types, and this attribute is for binding implementors, not end
3651 users, so we should never get there from legitimate explicit uses. */
3657 {
3662 }
3666 {
3670 }
3673 {
3677 }
3681 {
3685 }
3688 }
3690 /* Return a vector type whose representative array type is ARRAY_TYPE, or
3691 NULL_TREE if this is not possible. If ATTRIBUTE is non-zero, we are
3692 processing the attribute and want to issue error messages on failure. */
3694 static tree
3696 {
3699 attribute);
3705 }
3706 \f
3707 /* Build a type to be used to represent an aliased object whose nominal type
3708 is an unconstrained array. This consists of a RECORD_TYPE containing a
3709 field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an ARRAY_TYPE.
3710 If ARRAY_TYPE is that of an unconstrained array, this is used to represent
3711 an arbitrary unconstrained object. Use NAME as the name of the record.
3712 DEBUG_INFO_P is true if we need to write debug information for the type. */
3714 tree
3717 {
3718 tree decl;
3720 tree template_field
3723 tree array_field
3732 /* Declare it now since it will never be declared otherwise. This is
3733 necessary to ensure that its subtrees are properly marked. */
3736 /* template_type will not be used elsewhere than here, so to keep the debug
3737 info clean and in order to avoid scoping issues, make decl its
3738 context. */
3742 }
3744 /* Same, taking a thin or fat pointer type instead of a template type. */
3746 tree
3749 {
3750 tree template_type;
3754 template_type
3759 return
3761 }
3762 \f
3763 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.
3764 In the normal case this is just two adjustments, but we have more to
3765 do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */
3767 void
3769 {
3772 tree t;
3774 /* If this is the main variant, process all the other variants first. */
3779 /* If no pointers and no references, we are done. */
3783 /* Merge the old type qualifiers in the new type.
3785 Each old variant has qualifiers for specific reasons, and the new
3786 designated type as well. Each set of qualifiers represents useful
3787 information grabbed at some point, and merging the two simply unifies
3788 these inputs into the final type description.
3790 Consider for instance a volatile type frozen after an access to constant
3791 type designating it; after the designated type's freeze, we get here with
3792 a volatile NEW_TYPE and a dummy OLD_TYPE with a readonly variant, created
3793 when the access type was processed. We will make a volatile and readonly
3794 designated type, because that's what it really is.
3796 We might also get here for a non-dummy OLD_TYPE variant with different
3797 qualifiers than those of NEW_TYPE, for instance in some cases of pointers
3798 to private record type elaboration (see the comments around the call to
3799 this routine in gnat_to_gnu_entity <E_Access_Type>). We have to merge
3800 the qualifiers in those cases too, to avoid accidentally discarding the
3801 initial set, and will often end up with OLD_TYPE == NEW_TYPE then. */
3802 new_type
3806 /* If old type and new type are identical, there is nothing to do. */
3810 /* Otherwise, first handle the simple case. */
3812 {
3815 /* If pointer or reference already points to new type, nothing to do.
3816 This can happen as update_pointer_to can be invoked multiple times
3817 on the same couple of types because of the type variants. */
3822 /* Chain PTR and its variants at the end. */
3825 {
3829 }
3830 else
3833 /* Now adjust them. */
3836 {
3840 }
3842 /* Chain REF and its variants at the end. */
3845 {
3849 }
3850 else
3853 /* Now adjust them. */
3860 }
3862 /* Now deal with the unconstrained array case. In this case the pointer
3863 is actually a record where both fields are pointers to dummy nodes.
3864 Turn them into pointers to the correct types using update_pointer_to.
3865 Likewise for the pointer to the object record (thin pointer). */
3866 else
3867 {
3872 /* If PTR already points to NEW_TYPE, nothing to do. This can happen
3873 since update_pointer_to can be invoked multiple times on the same
3874 couple of types because of the type variants. */
3878 update_pointer_to
3882 update_pointer_to
3890 }
3891 }
3892 \f
3893 /* Convert EXPR, a pointer to a constrained array, into a pointer to an
3894 unconstrained one. This involves making or finding a template. */
3896 static tree
3898 {
3902 tree template_addr;
3906 /* If EXPR is null, make a fat pointer that contains a null pointer to the
3907 array (compare_fat_pointers ensures that this is the full discriminant)
3908 and a valid pointer to the bounds. This latter property is necessary
3909 since the compiler can hoist the load of the bounds done through it. */
3911 {
3917 else
3918 {
3919 /* The template type can still be dummy at this point so we build an
3920 empty constructor. The middle-end will fill it in with zeros. */
3925 }
3931 /* Do not set TREE_CONSTANT so as to force T to static memory. */
3936 }
3938 /* If EXPR is a thin pointer, make template and data from the record. */
3940 {
3945 /* If we have a TYPE_UNCONSTRAINED_ARRAY attached to the RECORD_TYPE,
3946 the thin pointer value has been shifted so we shift it back to get
3947 the template address. */
3949 {
3950 template_addr
3953 byte_position
3955 template_addr
3957 template_addr);
3958 }
3960 /* Otherwise we explicitly take the address of the fields. */
3961 else
3962 {
3964 template_addr
3972 }
3973 }
3975 /* Otherwise, build the constructor for the template. */
3976 else
3977 template_addr
3980 expr));
3982 /* The final result is a constructor for the fat pointer.
3984 If EXPR is an argument of a foreign convention subprogram, the type it
3985 points to is directly the component type. In this case, the expression
3986 type may not match the corresponding FIELD_DECL type at this point, so we
3987 call "convert" here to fix that up if necessary. This type consistency is
3988 required, for instance because it ensures that possible later folding of
3989 COMPONENT_REFs against this constructor always yields something of the
3990 same type as the initial reference.
3992 Note that the call to "build_template" above is still fine because it
3993 will only refer to the provided TEMPLATE_TYPE in this case. */
3997 }
3998 \f
3999 /* Create an expression whose value is that of EXPR,
4000 converted to type TYPE. The TREE_TYPE of the value
4001 is always TYPE. This function implements all reasonable
4002 conversions; callers should filter out those that are
4003 not permitted by the language being compiled. */
4005 tree
4007 {
4012 /* If the expression is already of the right type, we are done. */
4016 /* If both input and output have padding and are of variable size, do this
4017 as an unchecked conversion. Likewise if one is a mere variant of the
4018 other, so we avoid a pointless unpad/repad sequence. */
4026 ;
4028 /* If the output type has padding, convert to the inner type and make a
4029 constructor to build the record, unless a variable size is involved. */
4031 {
4034 /* If we previously converted from another type and our type is
4035 of variable size, remove the conversion to avoid the need for
4036 variable-sized temporaries. Likewise for a conversion between
4037 original and packable version. */
4045 /* If we are just removing the padding from expr, convert the original
4046 object if we have variable size in order to avoid the need for some
4047 variable-sized temporaries. Likewise if the padding is a variant
4048 of the other, so we avoid a pointless unpad/repad sequence. */
4059 /* If the inner type is of self-referential size and the expression type
4060 is a record, do this as an unchecked conversion. But first pad the
4061 expression if possible to have the same size on both sides. */
4064 {
4068 expr);
4070 }
4072 /* If we are converting between array types with variable size, do the
4073 final conversion as an unchecked conversion, again to avoid the need
4074 for some variable-sized temporaries. If valid, this conversion is
4075 very likely purely technical and without real effects. */
4082 expr),
4089 }
4091 /* If the input type has padding, remove it and convert to the output type.
4092 The conditions ordering is arranged to ensure that the output type is not
4093 a padding type here, as it is not clear whether the conversion would
4094 always be correct if this was to happen. */
4096 {
4097 tree unpadded;
4099 /* If we have just converted to this padded type, just get the
4100 inner expression. */
4106 /* Otherwise, build an explicit component reference. */
4107 else
4108 unpadded
4112 }
4114 /* If the input is a biased type, adjust first. */
4121 /* If the input is a justified modular type, we need to extract the actual
4122 object before converting it to any other type with the exceptions of an
4123 unconstrained array or of a mere type variant. It is useful to avoid the
4124 extraction and conversion in the type variant case because it could end
4125 up replacing a VAR_DECL expr by a constructor and we might be about the
4126 take the address of the result. */
4133 /* If converting to a type that contains a template, convert to the data
4134 type and then build the template. */
4136 {
4141 /* If the source already has a template, get a reference to the
4142 associated array only, as we are going to rebuild a template
4143 for the target type anyway. */
4152 }
4154 /* There are some cases of expressions that we process specially. */
4156 {
4161 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
4162 conversion in gnat_expand_expr. NULL_EXPR does not represent
4163 and actual value, so no conversion is needed. */
4169 /* If we are converting a STRING_CST to another constrained array type,
4170 just make a new one in the proper type. */
4174 {
4178 }
4182 /* If we are converting a VECTOR_CST to a mere type variant, just make
4183 a new one in the proper type. */
4185 {
4189 }
4192 /* If we are converting a CONSTRUCTOR to a mere type variant, or to
4193 another padding type around the same type, just make a new one in
4194 the proper type. */
4201 {
4206 }
4208 /* Likewise for a conversion between original and packable version, or
4209 conversion between types of the same size and with the same list of
4210 fields, but we have to work harder to preserve type consistency. */
4216 {
4225 /* Whether we need to clear TREE_CONSTANT et al. on the output
4226 constructor when we convert in place. */
4230 {
4231 /* Skip the missing fields in the CONSTRUCTOR. */
4233 {
4236 }
4237 /* The field must be the same. */
4240 constructor_elt elt
4244 /* If packing has made this field a bitfield and the input
4245 value couldn't be emitted statically any more, we need to
4246 clear TREE_CONSTANT on our output. */
4256 }
4258 /* If we have been able to match and convert all the input fields
4259 to their output type, convert in place now. We'll fallback to a
4260 view conversion downstream otherwise. */
4262 {
4269 }
4270 }
4272 /* Likewise for a conversion between array type and vector type with a
4273 compatible representative array. */
4277 etype))
4278 {
4283 tree value;
4285 /* Build a VECTOR_CST from a *constant* array constructor. */
4287 {
4290 /* Iterate through elements and check if all constructor
4291 elements are *_CSTs. */
4294 {
4297 }
4302 }
4304 /* Otherwise, build a regular vector constructor. */
4307 {
4310 }
4315 }
4319 /* First retrieve the underlying array. */
4326 {
4327 /* GCC 4.x is very sensitive to type consistency overall, and view
4328 conversions thus are very frequent. Even though just "convert"ing
4329 the inner operand to the output type is fine in most cases, it
4330 might expose unexpected input/output type mismatches in special
4331 circumstances so we avoid such recursive calls when we can. */
4334 /* If we are converting back to the original type, we can just
4335 lift the input conversion. This is a common occurrence with
4336 switches back-and-forth amongst type variants. */
4340 /* Otherwise, if we're converting between two aggregate or vector
4341 types, we might be allowed to substitute the VIEW_CONVERT_EXPR
4342 target type in place or to just convert the inner expression. */
4345 {
4346 /* If we are converting between mere variants, we can just
4347 substitute the VIEW_CONVERT_EXPR in place. */
4351 /* Otherwise, we may just bypass the input view conversion unless
4352 one of the types is a fat pointer, which is handled by
4353 specialized code below which relies on exact type matching. */
4357 }
4360 }
4364 }
4366 /* Check for converting to a pointer to an unconstrained array. */
4370 /* If we are converting between two aggregate or vector types that are mere
4371 variants, just make a VIEW_CONVERT_EXPR. Likewise when we are converting
4372 to a vector type from its representative array type. */
4379 etype)))
4382 /* If we are converting between tagged types, try to upcast properly. */
4385 {
4393 }
4395 /* If we are converting from a smaller form of record type back to it, just
4396 make a VIEW_CONVERT_EXPR. But first pad the expression to have the same
4397 size on both sides. */
4400 {
4403 expr);
4405 }
4407 /* In all other cases of related types, make a NOP_EXPR. */
4412 {
4428 /* ... fall through ... */
4432 /* If we are converting an additive expression to an integer type
4433 with lower precision, be wary of the optimization that can be
4434 applied by convert_to_integer. There are 2 problematic cases:
4435 - if the first operand was originally of a biased type,
4436 because we could be recursively called to convert it
4437 to an intermediate type and thus rematerialize the
4438 additive operator endlessly,
4439 - if the expression contains a placeholder, because an
4440 intermediate conversion that changes the sign could
4441 be inserted and thus introduce an artificial overflow
4442 at compile time when the placeholder is substituted. */
4447 {
4454 }
4460 /* If converting between two thin pointers, adjust if needed to account
4461 for differing offsets from the base pointer, depending on whether
4462 there is a TYPE_UNCONSTRAINED_ARRAY attached to the record type. */
4464 {
4465 tree etype_pos
4469 tree type_pos
4481 }
4483 /* If converting fat pointer to normal or thin pointer, get the pointer
4484 to the array and then convert it. */
4486 expr
4496 {
4502 expr));
4504 }
4506 /* ... fall through ... */
4509 /* In these cases, assume the front-end has validated the conversion.
4510 If the conversion is valid, it will be a bit-wise conversion, so
4511 it can be viewed as an unchecked conversion. */
4515 /* This is a either a conversion between a tagged type and some
4516 subtype, which we have to mark as a UNION_TYPE because of
4517 overlapping fields or a conversion of an Unchecked_Union. */
4521 /* If the input is a VECTOR_TYPE, convert to the representative
4522 array type first. */
4524 {
4528 }
4530 /* If EXPR is a constrained array, take its address, convert it to a
4531 fat pointer, and then dereference it. Likewise if EXPR is a
4532 record containing both a template and a constrained array.
4533 Note that a record representing a justified modular type
4534 always represents a packed constrained array. */
4539 return
4540 build_unary_op
4546 /* Do something very similar for converting one unconstrained
4547 array to another. */
4549 return
4554 else
4562 }
4563 }
4565 /* Create an expression whose value is that of EXPR converted to the common
4566 index type, which is sizetype. EXPR is supposed to be in the base type
4567 of the GNAT index type. Calling it is equivalent to doing
4569 convert (sizetype, expr)
4571 but we try to distribute the type conversion with the knowledge that EXPR
4572 cannot overflow in its type. This is a best-effort approach and we fall
4573 back to the above expression as soon as difficulties are encountered.
4575 This is necessary to overcome issues that arise when the GNAT base index
4576 type and the GCC common index type (sizetype) don't have the same size,
4577 which is quite frequent on 64-bit architectures. In this case, and if
4578 the GNAT base index type is signed but the iteration type of the loop has
4579 been forced to unsigned, the loop scalar evolution engine cannot compute
4580 a simple evolution for the general induction variables associated with the
4581 array indices, because it will preserve the wrap-around semantics in the
4582 unsigned type of their "inner" part. As a result, many loop optimizations
4583 are blocked.
4585 The solution is to use a special (basic) induction variable that is at
4586 least as large as sizetype, and to express the aforementioned general
4587 induction variables in terms of this induction variable, eliminating
4588 the problematic intermediate truncation to the GNAT base index type.
4589 This is possible as long as the original expression doesn't overflow
4590 and if the middle-end hasn't introduced artificial overflows in the
4591 course of the various simplification it can make to the expression. */
4593 tree
4595 {
4599 /* If the type is unsigned, overflow is allowed so we cannot be sure that
4600 EXPR doesn't overflow. Keep it simple if optimization is disabled. */
4605 {
4607 /* The main effect of the function: replace a loop parameter with its
4608 associated special induction variable. */
4613 CASE_CONVERT:
4614 {
4616 /* Bail out as soon as we suspect some sort of type frobbing. */
4620 }
4622 /* ... fall through ... */
4646 }
4649 }
4650 \f
4651 /* Remove all conversions that are done in EXP. This includes converting
4652 from a padded type or to a justified modular type. If TRUE_ADDRESS
4653 is true, always return the address of the containing object even if
4654 the address is not bit-aligned. */
4656 tree
4658 {
4660 {
4665 return
4674 CASE_CONVERT:
4681 }
4684 }
4685 \f
4686 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
4687 refers to the underlying array. If it has TYPE_CONTAINS_TEMPLATE_P,
4688 likewise return an expression pointing to the underlying array. */
4690 tree
4692 {
4697 {
4700 {
4708 {
4709 tree op1
4712 NULL_TREE,
4715 tree op2
4718 NULL_TREE,
4725 }
4726 else
4727 {
4734 }
4735 }
4744 /* If this is a padded type and it contains a template, convert to the
4745 unpadded type first. */
4749 {
4752 }
4755 {
4761 /* If the array type is padded, convert to the unpadded type. */
4764 }
4769 }
4772 }
4773 \f
4774 /* Return true if EXPR is an expression that can be folded as an operand
4775 of a VIEW_CONVERT_EXPR. See ada-tree.h for a complete rationale. */
4777 static bool
4779 {
4782 /* The folder will fold NOP_EXPRs between integral types with the same
4783 precision (in the middle-end's sense). We cannot allow it if the
4784 types don't have the same precision in the Ada sense as well. */
4791 /* Defer to the folder for non-integral conversions. */
4795 /* Only fold conversions that preserve both precisions. */
4801 }
4803 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
4804 If NOTRUNC_P is true, truncation operations should be suppressed.
4806 Special care is required with (source or target) integral types whose
4807 precision is not equal to their size, to make sure we fetch or assign
4808 the value bits whose location might depend on the endianness, e.g.
4810 Rmsize : constant := 8;
4811 subtype Int is Integer range 0 .. 2 ** Rmsize - 1;
4813 type Bit_Array is array (1 .. Rmsize) of Boolean;
4814 pragma Pack (Bit_Array);
4816 function To_Bit_Array is new Unchecked_Conversion (Int, Bit_Array);
4818 Value : Int := 2#1000_0001#;
4819 Vbits : Bit_Array := To_Bit_Array (Value);
4821 we expect the 8 bits at Vbits'Address to always contain Value, while
4822 their original location depends on the endianness, at Value'Address
4823 on a little-endian architecture but not on a big-endian one. */
4825 tree
4827 {
4831 tree tem;
4834 /* If the expression is already of the right type, we are done. */
4838 /* If both types types are integral just do a normal conversion.
4839 Likewise for a conversion to an unconstrained array. */
4847 {
4849 {
4854 }
4857 {
4863 }
4864 else
4866 }
4868 /* If we are converting to an integral type whose precision is not equal
4869 to its size, first unchecked convert to a record type that contains a
4870 field of the given precision. Then extract the result from the field.
4872 There is a subtlety if the source type is an aggregate type with reverse
4873 storage order because its representation is not contiguous in the native
4874 storage order, i.e. a direct unchecked conversion to an integral type
4875 with N bits of precision cannot read the first N bits of the aggregate
4876 type. To overcome it, we do an unchecked conversion to an integral type
4877 with reverse storage order and return the resulting value. This also
4878 ensures that the result of the unchecked conversion doesn't depend on
4879 the endianness of the target machine, but only on the storage order of
4880 the aggregate type.
4882 Finally, for the sake of consistency, we do the unchecked conversion
4883 to an integral type with reverse storage order as soon as the source
4884 type is an aggregate type with reverse storage order, even if there
4885 are no considerations of precision or size involved. */
4892 {
4903 else
4915 }
4917 /* Similarly if we are converting from an integral type whose precision is
4918 not equal to its size, first copy into a field of the given precision
4919 and unchecked convert the record type.
4921 The same considerations as above apply if the target type is an aggregate
4922 type with reverse storage order and we also proceed similarly. */
4929 {
4942 else
4955 }
4957 /* If we are converting from a scalar type to a type with a different size,
4958 we need to pad to have the same size on both sides.
4960 ??? We cannot do it unconditionally because unchecked conversions are
4961 used liberally by the front-end to implement polymorphism, e.g. in:
4963 S191s : constant ada__tags__addr_ptr := ada__tags__addr_ptr!(S190s);
4964 return p___size__4 (p__object!(S191s.all));
4966 so we skip all expressions that are references. */
4971 {
4973 {
4976 expr);
4978 }
4979 else
4980 {
4986 }
4987 }
4989 /* We have a special case when we are converting between two unconstrained
4990 array types. In that case, take the address, convert the fat pointer
4991 types, and dereference. */
4996 expr)));
4998 /* Another special case is when we are converting to a vector type from its
4999 representative array type; this a regular conversion. */
5003 etype))
5006 /* And, if the array type is not the representative, we try to build an
5007 intermediate vector type of which the array type is the representative
5008 and to do the unchecked conversion between the vector types, in order
5009 to enable further simplifications in the middle-end. */
5013 {
5016 }
5018 /* If we are converting a CONSTRUCTOR to a more aligned RECORD_TYPE, bump
5019 the alignment of the CONSTRUCTOR to speed up the copy operation. */
5023 {
5026 expr);
5028 }
5030 /* Otherwise, just build a VIEW_CONVERT_EXPR of the expression. */
5031 else
5032 {
5038 else
5040 }
5042 /* If the result is an integral type whose precision is not equal to its
5043 size, sign- or zero-extend the result. We need not do this if the input
5044 is an integral type of the same precision and signedness or if the output
5045 is a biased type or if both the input and output are unsigned. */
5058 {
5059 tree base_type
5061 tree shift_expr
5064 bitsize_int
5067 expr
5072 shift_expr),
5073 shift_expr));
5074 }
5076 /* An unchecked conversion should never raise Constraint_Error. The code
5077 below assumes that GCC's conversion routines overflow the same way that
5078 the underlying hardware does. This is probably true. In the rare case
5079 when it is false, we can rely on the fact that such conversions are
5080 erroneous anyway. */
5084 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
5085 show no longer constant. */
5088 OEP_ONLY_CONST))
5092 }
5093 \f
5094 /* Return the appropriate GCC tree code for the specified GNAT_TYPE,
5095 the latter being a record type as predicated by Is_Record_Type. */
5097 enum tree_code
5099 {
5102 /* Return UNION_TYPE if it's an Unchecked_Union whose non-discriminant
5103 fields are all in the variant part. Otherwise, return RECORD_TYPE. */
5108 component_list
5118 }
5120 /* Return true if GNAT_TYPE is a "double" floating-point type, i.e. whose
5121 size is equal to 64 bits, or an array of such a type. Set ALIGN_CLAUSE
5122 according to the presence of an alignment clause on the type or, if it
5123 is an array, on the component type. */
5125 bool
5127 {
5133 {
5137 }
5146 }
5148 /* Return true if GNAT_TYPE is a "double" or larger scalar type, i.e. whose
5149 size is greater or equal to 64 bits, or an array of such a type. Set
5150 ALIGN_CLAUSE according to the presence of an alignment clause on the
5151 type or, if it is an array, on the component type. */
5153 bool
5155 {
5161 {
5165 }
5174 }
5176 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
5177 component of an aggregate type. */
5179 bool
5181 {
5182 /* If the type is passed by reference, we may have pointers to the
5183 component so it cannot be made non-aliased. */
5187 /* We used to say that any component of aggregate type is aliased
5188 because the front-end may take 'Reference of it. The front-end
5189 has been enhanced in the meantime so as to use a renaming instead
5190 in most cases, but the back-end can probably take the address of
5191 such a component too so we go for the conservative stance.
5193 For instance, we might need the address of any array type, even
5194 if normally passed by copy, to construct a fat pointer if the
5195 component is used as an actual for an unconstrained formal.
5197 Likewise for record types: even if a specific record subtype is
5198 passed by copy, the parent type might be passed by ref (e.g. if
5199 it's of variable size) and we might take the address of a child
5200 component to pass to a parent formal. We have no way to check
5201 for such conditions here. */
5206 }
5208 /* Return true if TYPE is a smaller form of ORIG_TYPE. */
5210 bool
5212 {
5215 /* We're not interested in variants here. */
5219 /* Like a variant, a packable version keeps the original TYPE_NAME. */
5230 }
5232 /* Perform final processing on global variables. */
5236 void
5238 {
5240 tree iter;
5242 /* If we have declared types as used at the global level, insert them in
5243 the global hash table. We use a dummy variable for this purpose. */
5245 {
5250 dummy_global
5252 void_type_node);
5260 {
5263 }
5264 }
5266 /* Output debug information for all global type declarations first. This
5267 ensures that global types whose compilation hasn't been finalized yet,
5268 for example pointers to Taft amendment types, have their compilation
5269 finalized in the right context. */
5274 /* Proceed to optimize and emit assembly. */
5277 /* After cgraph has had a chance to emit everything that's going to
5278 be emitted, output debug information for the rest of globals. */
5280 {
5286 }
5287 }
5289 /* ************************************************************************
5290 * * GCC builtins support *
5291 * ************************************************************************ */
5293 /* The general scheme is fairly simple:
5295 For each builtin function/type to be declared, gnat_install_builtins calls
5296 internal facilities which eventually get to gnat_pushdecl, which in turn
5297 tracks the so declared builtin function decls in the 'builtin_decls' global
5298 datastructure. When an Intrinsic subprogram declaration is processed, we
5299 search this global datastructure to retrieve the associated BUILT_IN DECL
5300 node. */
5302 /* Search the chain of currently available builtin declarations for a node
5303 corresponding to function NAME (an IDENTIFIER_NODE). Return the first node
5304 found, if any, or NULL_TREE otherwise. */
5305 tree
5307 {
5309 tree decl;
5316 }
5318 /* The code below eventually exposes gnat_install_builtins, which declares
5319 the builtin types and functions we might need, either internally or as
5320 user accessible facilities.
5322 ??? This is a first implementation shot, still in rough shape. It is
5323 heavily inspired from the "C" family implementation, with chunks copied
5324 verbatim from there.
5326 Two obvious TODO candidates are
5327 o Use a more efficient name/decl mapping scheme
5328 o Devise a middle-end infrastructure to avoid having to copy
5329 pieces between front-ends. */
5331 /* ----------------------------------------------------------------------- *
5332 * BUILTIN ELEMENTARY TYPES *
5333 * ----------------------------------------------------------------------- */
5335 /* Standard data types to be used in builtin argument declarations. */
5337 enum c_tree_index
5338 {
5340 CTI_STRING_TYPE,
5341 CTI_CONST_STRING_TYPE,
5343 CTI_MAX
5344 };
5348 #define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
5349 #define string_type_node c_global_trees[CTI_STRING_TYPE]
5350 #define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
5352 /* ??? In addition some attribute handlers, we currently don't support a
5353 (small) number of builtin-types, which in turns inhibits support for a
5354 number of builtin functions. */
5355 #define wint_type_node void_type_node
5356 #define intmax_type_node void_type_node
5357 #define uintmax_type_node void_type_node
5359 /* Build the void_list_node (void_type_node having been created). */
5361 static tree
5363 {
5366 }
5368 /* Used to help initialize the builtin-types.def table. When a type of
5369 the correct size doesn't exist, use error_mark_node instead of NULL.
5370 The later results in segfaults even when a decl using the type doesn't
5371 get invoked. */
5373 static tree
5375 {
5378 }
5380 /* Build/push the elementary type decls that builtin functions/types
5381 will need. */
5383 static void
5385 {
5391 const_string_type_node
5394 }
5396 /* ----------------------------------------------------------------------- *
5397 * BUILTIN FUNCTION TYPES *
5398 * ----------------------------------------------------------------------- */
5400 /* Now, builtin function types per se. */
5402 enum c_builtin_type
5403 {
5404 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5405 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5406 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5407 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5408 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5409 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5410 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5411 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5412 ARG6) NAME,
5413 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5414 ARG6, ARG7) NAME,
5415 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5416 ARG6, ARG7, ARG8) NAME,
5417 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5418 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5419 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5420 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5421 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5422 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5423 NAME,
5424 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5425 ARG6, ARG7) NAME,
5426 #define DEF_FUNCTION_TYPE_VAR_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5427 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
5428 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5430 #undef DEF_PRIMITIVE_TYPE
5431 #undef DEF_FUNCTION_TYPE_0
5432 #undef DEF_FUNCTION_TYPE_1
5433 #undef DEF_FUNCTION_TYPE_2
5434 #undef DEF_FUNCTION_TYPE_3
5435 #undef DEF_FUNCTION_TYPE_4
5436 #undef DEF_FUNCTION_TYPE_5
5437 #undef DEF_FUNCTION_TYPE_6
5438 #undef DEF_FUNCTION_TYPE_7
5439 #undef DEF_FUNCTION_TYPE_8
5440 #undef DEF_FUNCTION_TYPE_VAR_0
5441 #undef DEF_FUNCTION_TYPE_VAR_1
5442 #undef DEF_FUNCTION_TYPE_VAR_2
5443 #undef DEF_FUNCTION_TYPE_VAR_3
5444 #undef DEF_FUNCTION_TYPE_VAR_4
5445 #undef DEF_FUNCTION_TYPE_VAR_5
5446 #undef DEF_FUNCTION_TYPE_VAR_7
5447 #undef DEF_FUNCTION_TYPE_VAR_11
5448 #undef DEF_POINTER_TYPE
5449 BT_LAST
5450 };
5454 /* A temporary array used in communication with def_fn_type. */
5457 /* A helper function for install_builtin_types. Build function type
5458 for DEF with return type RET and N arguments. If VAR is true, then the
5459 function should be variadic after those N arguments.
5461 Takes special care not to ICE if any of the types involved are
5462 error_mark_node, which indicates that said type is not in fact available
5463 (see builtin_type_for_size). In which case the function type as a whole
5464 should be error_mark_node. */
5466 static void
5468 {
5469 tree t;
5476 {
5482 }
5489 else
5492 egress:
5495 }
5497 /* Build the builtin function types and install them in the builtin_types
5498 array for later use in builtin function decls. */
5500 static void
5502 {
5503 tree va_list_ref_type_node;
5504 tree va_list_arg_type_node;
5507 {
5510 }
5511 else
5512 {
5515 }
5517 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5518 builtin_types[ENUM] = VALUE;
5519 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5520 def_fn_type (ENUM, RETURN, 0, 0);
5521 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5522 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5523 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5524 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5525 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5526 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5527 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5528 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5529 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5530 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5531 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5532 ARG6) \
5533 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5534 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5535 ARG6, ARG7) \
5536 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5537 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5538 ARG6, ARG7, ARG8) \
5539 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5540 ARG7, ARG8);
5541 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5542 def_fn_type (ENUM, RETURN, 1, 0);
5543 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5544 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5545 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5546 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5547 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5548 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5549 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5550 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5551 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5552 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5553 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5554 ARG6, ARG7) \
5555 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5556 #define DEF_FUNCTION_TYPE_VAR_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5557 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
5558 def_fn_type (ENUM, RETURN, 1, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5559 ARG7, ARG8, ARG9, ARG10, ARG11);
5560 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5561 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5565 #undef DEF_PRIMITIVE_TYPE
5566 #undef DEF_FUNCTION_TYPE_0
5567 #undef DEF_FUNCTION_TYPE_1
5568 #undef DEF_FUNCTION_TYPE_2
5569 #undef DEF_FUNCTION_TYPE_3
5570 #undef DEF_FUNCTION_TYPE_4
5571 #undef DEF_FUNCTION_TYPE_5
5572 #undef DEF_FUNCTION_TYPE_6
5573 #undef DEF_FUNCTION_TYPE_7
5574 #undef DEF_FUNCTION_TYPE_8
5575 #undef DEF_FUNCTION_TYPE_VAR_0
5576 #undef DEF_FUNCTION_TYPE_VAR_1
5577 #undef DEF_FUNCTION_TYPE_VAR_2
5578 #undef DEF_FUNCTION_TYPE_VAR_3
5579 #undef DEF_FUNCTION_TYPE_VAR_4
5580 #undef DEF_FUNCTION_TYPE_VAR_5
5581 #undef DEF_FUNCTION_TYPE_VAR_7
5582 #undef DEF_FUNCTION_TYPE_VAR_11
5583 #undef DEF_POINTER_TYPE
5585 }
5587 /* ----------------------------------------------------------------------- *
5588 * BUILTIN ATTRIBUTES *
5589 * ----------------------------------------------------------------------- */
5591 enum built_in_attribute
5592 {
5593 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5594 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5595 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5596 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5597 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5599 #undef DEF_ATTR_NULL_TREE
5600 #undef DEF_ATTR_INT
5601 #undef DEF_ATTR_STRING
5602 #undef DEF_ATTR_IDENT
5603 #undef DEF_ATTR_TREE_LIST
5604 ATTR_LAST
5605 };
5609 static void
5611 {
5612 /* Fill in the built_in_attributes array. */
5613 #define DEF_ATTR_NULL_TREE(ENUM) \
5614 built_in_attributes[(int) ENUM] = NULL_TREE;
5615 #define DEF_ATTR_INT(ENUM, VALUE) \
5616 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5617 #define DEF_ATTR_STRING(ENUM, VALUE) \
5618 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5619 #define DEF_ATTR_IDENT(ENUM, STRING) \
5620 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5621 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5622 built_in_attributes[(int) ENUM] \
5623 = tree_cons (built_in_attributes[(int) PURPOSE], \
5624 built_in_attributes[(int) VALUE], \
5625 built_in_attributes[(int) CHAIN]);
5627 #undef DEF_ATTR_NULL_TREE
5628 #undef DEF_ATTR_INT
5629 #undef DEF_ATTR_STRING
5630 #undef DEF_ATTR_IDENT
5631 #undef DEF_ATTR_TREE_LIST
5632 }
5634 /* Handle a "const" attribute; arguments as in
5635 struct attribute_spec.handler. */
5637 static tree
5641 {
5644 else
5648 }
5650 /* Handle a "nothrow" attribute; arguments as in
5651 struct attribute_spec.handler. */
5653 static tree
5657 {
5660 else
5664 }
5666 /* Handle a "pure" attribute; arguments as in
5667 struct attribute_spec.handler. */
5669 static tree
5672 {
5675 /* ??? TODO: Support types. */
5676 else
5677 {
5681 }
5684 }
5686 /* Handle a "no vops" attribute; arguments as in
5687 struct attribute_spec.handler. */
5689 static tree
5693 {
5697 }
5699 /* Helper for nonnull attribute handling; fetch the operand number
5700 from the attribute argument list. */
5702 static bool
5704 {
5705 /* Verify the arg number is a constant. */
5711 }
5713 /* Handle the "nonnull" attribute. */
5714 static tree
5718 {
5722 /* If no arguments are specified, all pointer arguments should be
5723 non-null. Verify a full prototype is given so that the arguments
5724 will have the correct types when we actually check them later. */
5726 {
5728 {
5731 }
5733 }
5735 /* Argument list specified. Verify that each argument number references
5736 a pointer argument. */
5738 {
5742 {
5747 }
5750 {
5751 function_args_iterator iter;
5752 tree argument;
5756 {
5760 }
5764 {
5770 }
5773 {
5779 }
5780 }
5781 }
5784 }
5786 /* Handle a "sentinel" attribute. */
5788 static tree
5791 {
5793 {
5798 }
5799 else
5800 {
5802 {
5807 }
5808 }
5811 {
5815 {
5818 }
5819 else
5820 {
5822 {
5825 }
5826 }
5827 }
5830 }
5832 /* Handle a "noreturn" attribute; arguments as in
5833 struct attribute_spec.handler. */
5835 static tree
5838 {
5841 /* See FIXME comment in c_common_attribute_table. */
5847 = build_pointer_type
5850 else
5851 {
5855 }
5858 }
5860 /* Handle a "leaf" attribute; arguments as in
5861 struct attribute_spec.handler. */
5863 static tree
5866 {
5868 {
5871 }
5873 {
5876 }
5879 }
5881 /* Handle a "always_inline" attribute; arguments as in
5882 struct attribute_spec.handler. */
5884 static tree
5887 {
5889 {
5890 /* Set the attribute and mark it for disregarding inline limits. */
5892 }
5893 else
5894 {
5897 }
5900 }
5902 /* Handle a "malloc" attribute; arguments as in
5903 struct attribute_spec.handler. */
5905 static tree
5908 {
5912 else
5913 {
5917 }
5920 }
5922 /* Fake handler for attributes we don't properly support. */
5924 tree
5930 {
5932 }
5934 /* Handle a "type_generic" attribute. */
5936 static tree
5940 {
5941 /* Ensure we have a function type. */
5944 /* Ensure we have a variadic function. */
5948 }
5950 /* Handle a "vector_size" attribute; arguments as in
5951 struct attribute_spec.handler. */
5953 static tree
5956 {
5958 tree vector_type;
5962 /* We need to provide for vector pointers, vector arrays, and
5963 functions returning vectors. For example:
5965 __attribute__((vector_size(16))) short *foo;
5967 In this case, the mode is SI, but the type being modified is
5968 HI, so we need to look further. */
5978 /* Build back pointers if needed. */
5982 }
5984 /* Handle a "vector_type" attribute; arguments as in
5985 struct attribute_spec.handler. */
5987 static tree
5990 {
5992 tree vector_type;
5997 {
6001 }
6011 }
6013 /* ----------------------------------------------------------------------- *
6014 * BUILTIN FUNCTIONS *
6015 * ----------------------------------------------------------------------- */
6017 /* Worker for DEF_BUILTIN. Possibly define a builtin function with one or two
6018 names. Does not declare a non-__builtin_ function if flag_no_builtin, or
6019 if nonansi_p and flag_no_nonansi_builtin. */
6021 static void
6029 {
6030 tree decl;
6033 /* Preserve an already installed decl. It most likely was setup in advance
6034 (e.g. as part of the internal builtins) for specific reasons. */
6045 fnattrs);
6047 /* ??? This is normally further controlled by command-line options
6048 like -fno-builtin, but we don't have them for Ada. */
6053 }
6059 /* Install what the common builtins.def offers. */
6061 static void
6063 {
6064 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
6065 NONANSI_P, ATTRS, IMPLICIT, COND) \
6066 if (NAME && COND) \
6067 def_builtin_1 (ENUM, NAME, CLASS, \
6068 builtin_types[(int) TYPE], \
6069 builtin_types[(int) LIBTYPE], \
6070 BOTH_P, FALLBACK_P, NONANSI_P, \
6071 built_in_attributes[(int) ATTRS], IMPLICIT);
6073 #undef DEF_BUILTIN
6074 }
6076 /* ----------------------------------------------------------------------- *
6077 * BUILTIN FUNCTIONS *
6078 * ----------------------------------------------------------------------- */
6080 /* Install the builtin functions we might need. */
6082 void
6084 {
6089 /* Install builtins used by generic middle-end pieces first. Some of these
6090 know about internal specificities and control attributes accordingly, for
6091 instance __builtin_alloca vs no-throw and -fstack-check. We will ignore
6092 the generic definition from builtins.def. */
6095 /* Now, install the target specific builtins, such as the AltiVec family on
6096 ppc, and the common set as exposed by builtins.def. */
6099 }