| blob | 01a60280e630948f9886b37988ffb0e050fcd687 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2013, 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 ****************************************************************************/
62 /* If nonzero, pretend we are allocating at global level. */
65 /* The default alignment of "double" floating-point types, i.e. floating
66 point types whose size is equal to 64 bits, or 0 if this alignment is
67 not specifically capped. */
70 /* The default alignment of "double" or larger scalar types, i.e. scalar
71 types whose size is greater or equal to 64 bits, or 0 if this alignment
72 is not specifically capped. */
75 /* Tree nodes for the various types and decls we create. */
78 /* Functions to call for each of the possible raise reasons. */
81 /* Likewise, but with extra info for each of the possible raise reasons. */
84 /* Forward declarations for handlers of attributes. */
98 /* Fake handler for attributes we don't properly support, typically because
99 they'd require dragging a lot of the common-c front-end circuitry. */
102 /* Table of machine-independent internal attributes for Ada. We support
103 this minimal set of attributes to accommodate the needs of builtins. */
105 {
106 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
107 affects_type_identity } */
135 /* ??? format and format_arg are heavy and not supported, which actually
136 prevents support for stdio builtins, which we however declare as part
137 of the common builtins.def contents. */
142 };
144 /* Associates a GNAT tree node to a GCC tree node. It is used in
145 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
146 of `save_gnu_tree' for more info. */
149 #define GET_GNU_TREE(GNAT_ENTITY) \
150 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id]
152 #define SET_GNU_TREE(GNAT_ENTITY,VAL) \
153 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] = (VAL)
155 #define PRESENT_GNU_TREE(GNAT_ENTITY) \
156 (associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
158 /* Associates a GNAT entity to a GCC tree node used as a dummy, if any. */
161 #define GET_DUMMY_NODE(GNAT_ENTITY) \
162 dummy_node_table[(GNAT_ENTITY) - First_Node_Id]
164 #define SET_DUMMY_NODE(GNAT_ENTITY,VAL) \
165 dummy_node_table[(GNAT_ENTITY) - First_Node_Id] = (VAL)
167 #define PRESENT_DUMMY_NODE(GNAT_ENTITY) \
168 (dummy_node_table[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
170 /* This variable keeps a table for types for each precision so that we only
171 allocate each of them once. Signed and unsigned types are kept separate.
173 Note that these types are only used when fold-const requests something
174 special. Perhaps we should NOT share these types; we'll see how it
175 goes later. */
178 /* Likewise for float types, but record these by mode. */
181 /* For each binding contour we allocate a binding_level structure to indicate
182 the binding depth. */
185 /* The binding level containing this one (the enclosing binding level). */
187 /* The BLOCK node for this level. */
188 tree block;
189 /* If nonzero, the setjmp buffer that needs to be updated for any
190 variable-sized definition within this context. */
191 tree jmpbuf_decl;
192 };
194 /* The binding level currently in effect. */
197 /* A chain of gnat_binding_level structures awaiting reuse. */
200 /* The context to be used for global declarations. */
203 /* An array of global declarations. */
206 /* An array of builtin function declarations. */
209 /* An array of global renaming pointers. */
212 /* A chain of unused BLOCK nodes. */
219 /* A hash table of padded types. It is modelled on the generic type
220 hash table in tree.c, which must thus be used as a reference. */
223 tree type;
224 };
228 htab_t pad_type_hash_table;
237 \f
238 /* Initialize data structures of the utils.c module. */
240 void
242 {
243 /* Initialize the association of GNAT nodes to GCC trees. */
246 /* Initialize the association of GNAT nodes to GCC trees as dummies. */
249 /* Initialize the hash table of padded types. */
252 }
254 /* Destroy data structures of the utils.c module. */
256 void
258 {
259 /* Destroy the association of GNAT nodes to GCC trees. */
263 /* Destroy the association of GNAT nodes to GCC trees as dummies. */
267 /* Destroy the hash table of padded types. */
271 /* Invalidate the global renaming pointers. */
273 }
274 \f
275 /* GNAT_ENTITY is a GNAT tree node for an entity. Associate GNU_DECL, a GCC
276 tree node, with GNAT_ENTITY. If GNU_DECL is not a ..._DECL node, abort.
277 If NO_CHECK is true, the latter check is suppressed.
279 If GNU_DECL is zero, reset a previous association. */
281 void
283 {
284 /* Check that GNAT_ENTITY is not already defined and that it is being set
285 to something which is a decl. If that is not the case, this usually
286 means GNAT_ENTITY is defined twice, but occasionally is due to some
287 Gigi problem. */
293 }
295 /* GNAT_ENTITY is a GNAT tree node for an entity. Return the GCC tree node
296 that was associated with it. If there is no such tree node, abort.
298 In some cases, such as delayed elaboration or expressions that need to
299 be elaborated only once, GNAT_ENTITY is really not an entity. */
301 tree
303 {
306 }
308 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
310 bool
312 {
314 }
315 \f
316 /* Make a dummy type corresponding to GNAT_TYPE. */
318 tree
320 {
322 tree gnu_type;
324 /* If there is an equivalent type, get its underlying type. */
328 /* If there was no equivalent type (can only happen when just annotating
329 types) or underlying type, go back to the original type. */
333 /* If it there already a dummy type, use that one. Else make one. */
337 /* If this is a record, make a RECORD_TYPE or UNION_TYPE; else make
338 an ENUMERAL_TYPE. */
352 }
354 /* Return the dummy type that was made for GNAT_TYPE, if any. */
356 tree
358 {
360 }
362 /* Build dummy fat and thin pointer types whose designated type is specified
363 by GNAT_DESIG_TYPE/GNU_DESIG_TYPE and attach them to the latter. */
365 void
367 {
382 /* Build a stub DECL to trigger the special processing for fat pointer types
383 in gnat_pushdecl. */
386 gnu_fat_type);
394 /* Suppress debug info until after the type is completed. */
403 }
404 \f
405 /* Return true if we are in the global binding level. */
407 bool
409 {
411 }
413 /* Enter a new binding level. */
415 void
417 {
420 /* Reuse a struct for this binding level, if there is one. */
422 {
425 }
426 else
429 /* Use a free BLOCK, if any; otherwise, allocate one. */
431 {
435 }
436 else
439 /* Point the BLOCK we just made to its parent. */
447 /* Add this level to the front of the chain (stack) of active levels. */
451 }
453 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
454 and point FNDECL to this BLOCK. */
456 void
458 {
462 }
464 /* Set the jmpbuf_decl for the current binding level to DECL. */
466 void
468 {
470 }
472 /* Get the jmpbuf_decl, if any, for the current binding level. */
474 tree
476 {
478 }
480 /* Exit a binding level. Set any BLOCK into the current code group. */
482 void
484 {
491 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
492 are no variables free the block and merge its subblocks into those of its
493 parent block. Otherwise, add it to the list of its parent. */
495 ;
497 {
503 }
504 else
505 {
510 }
512 /* Free this binding structure. */
516 }
518 /* Exit a binding level and discard the associated BLOCK. */
520 void
522 {
529 /* Free this binding structure. */
533 }
534 \f
535 /* Set the context of TYPE and its parallel types (if any) to CONTEXT. */
537 static void
539 {
545 {
548 }
549 }
551 /* Record DECL as belonging to the current lexical scope and use GNAT_NODE
552 for location information and flag propagation. */
554 void
556 {
557 /* If DECL is public external or at top level, it has global context. */
559 {
563 }
564 else
565 {
568 /* Functions imported in another function are not really nested.
569 For really nested functions mark them initially as needing
570 a static chain for uses of that flag before unnesting;
571 lower_nested_functions will then recompute it. */
574 }
578 /* Set the location of DECL and emit a declaration for it. */
584 /* Put the declaration on the list. The list of declarations is in reverse
585 order. The list will be reversed later. Put global declarations in the
586 globals list and local ones in the current block. But skip TYPE_DECLs
587 for UNCONSTRAINED_ARRAY_TYPE in both cases, as they will cause trouble
588 with the debugger and aren't needed anyway. */
591 {
593 {
596 }
599 else
600 {
603 }
604 }
606 /* For the declaration of a type, set its name if it either is not already
607 set or if the previous type name was not derived from a source name.
608 We'd rather have the type named with a real name and all the pointer
609 types to the same object have the same POINTER_TYPE node. Code in the
610 equivalent function of c-decl.c makes a copy of the type node here, but
611 that may cause us trouble with incomplete types. We make an exception
612 for fat pointer types because the compiler automatically builds them
613 for unconstrained array types and the debugger uses them to represent
614 both these and pointers to these. */
616 {
620 {
621 /* Array and pointer types aren't "tagged" types so we force the
622 type to be associated with its typedef in the DWARF back-end,
623 in order to make sure that the latter is always preserved. */
627 {
635 }
636 }
638 {
639 /* We need a variant for the placeholder machinery to work. */
647 else
651 }
653 ;
654 else
657 /* Propagate the name to all the anonymous variants. This is needed
658 for the type qualifiers machinery to work properly. */
662 {
665 }
666 }
667 }
668 \f
669 /* Create a record type that contains a SIZE bytes long field of TYPE with a
670 starting bit position so that it is aligned to ALIGN bits, and leaving at
671 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
672 record is guaranteed to get. GNAT_NODE is used for the position of the
673 associated TYPE_DECL. */
675 tree
678 {
679 /* We will be crafting a record type with one field at a position set to be
680 the next multiple of ALIGN past record'address + room bytes. We use a
681 record placeholder to express record'address. */
685 tree record_addr_st
688 /* The diagram below summarizes the shape of what we manipulate:
690 <--------- pos ---------->
691 { +------------+-------------+-----------------+
692 record =>{ |############| ... | field (type) |
693 { +------------+-------------+-----------------+
694 |<-- room -->|<- voffset ->|<---- size ----->|
695 o o
696 | |
697 record_addr vblock_addr
699 Every length is in sizetype bytes there, except "pos" which has to be
700 set as a bit position in the GCC tree for the record. */
712 /* Compute VOFFSET and then POS. The next byte position multiple of some
713 alignment after some address is obtained by "and"ing the alignment minus
714 1 with the two's complement of the address. */
719 /* POS = (ROOM + VOFFSET) * BIT_PER_UNIT, in bitsizetype. */
723 bitsize_unit_node);
725 /* Craft the GCC record representation. We exceptionally do everything
726 manually here because 1) our generic circuitry is not quite ready to
727 handle the complex position/size expressions we are setting up, 2) we
728 have a strong simplifying factor at hand: we know the maximum possible
729 value of voffset, and 3) we have to set/reset at least the sizes in
730 accordance with this maximum value anyway, as we need them to convey
731 what should be "alloc"ated for this type.
733 Use -1 as the 'addressable' indication for the field to prevent the
734 creation of a bitfield. We don't need one, it would have damaging
735 consequences on the alignment computation, and create_field_decl would
736 make one without this special argument, for instance because of the
737 complex position expression. */
748 bitsize_unit_node),
757 /* Declare it now since it will never be declared otherwise. This is
758 necessary to ensure that its subtrees are properly marked. */
762 }
764 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
765 as the field type of a packed record if IN_RECORD is true, or as the
766 component type of a packed array if IN_RECORD is false. See if we can
767 rewrite it either as a type that has a non-BLKmode, which we can pack
768 tighter in the packed record case, or as a smaller type. If so, return
769 the new type. If not, return the original type. */
771 tree
773 {
779 /* No point in doing anything if the size is zero. */
785 /* Copy the name and flags from the old type to that of the new.
786 Note that we rely on the pointer equality created here for
787 TYPE_NAME to look through conversions in various places. */
794 /* If we are in a record and have a small size, set the alignment to
795 try for an integral mode. Otherwise set it to try for a smaller
796 type with BLKmode. */
798 {
802 }
803 else
804 {
807 /* Do not try to shrink the size if the RM size is not constant. */
812 /* Round the RM size up to a unit boundary to get the minimal size
813 for a BLKmode record. Give up if it's already the size. */
821 }
825 /* Now copy the fields, keeping the position and size as we don't want
826 to change the layout by propagating the packedness downwards. */
829 {
838 /* However, for the last field in a not already packed record type
839 that is of an aggregate type, we need to use the RM size in the
840 packable version of the record type, see finish_record_type. */
848 else
851 new_field
864 }
871 /* If this is a padding record, we never want to make the size smaller
872 than what was specified. For QUAL_UNION_TYPE, also copy the size. */
874 {
878 }
879 else
880 {
884 }
891 /* Try harder to get a packable type if necessary, for example
892 in case the record itself contains a BLKmode field. */
897 /* If neither the mode nor the size has shrunk, return the old type. */
902 }
904 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
905 If TYPE is the best type, return it. Otherwise, make a new type. We
906 only support new integral and pointer types. FOR_BIASED is true if
907 we are making a biased type. */
909 tree
911 {
914 tree new_type;
916 /* If size indicates an error, just return TYPE to avoid propagating
917 the error. Likewise if it's too large to represent. */
924 {
931 /* Integer types with precision 0 are forbidden. */
935 /* Only do something if the type isn't a packed array type and doesn't
936 already have the proper size and the size isn't too large. */
945 else
954 /* Copy the name to show that it's essentially the same type and
955 not a subrange type. */
962 /* Do something if this is a fat pointer, in which case we
963 may need to return the thin pointer. */
965 {
969 return
970 build_pointer_type_for_mode
973 }
977 /* Only do something if this is a thin pointer, in which case we
978 may need to return the fat pointer. */
980 return
986 }
989 }
991 /* See if the data pointed to by the hash table slot is marked. */
993 static int
995 {
999 }
1001 /* Return the cached hash value. */
1003 static hashval_t
1005 {
1007 }
1009 /* Return 1 iff the padded types are equivalent. */
1011 static int
1013 {
1024 /* We consider that the padded types are equivalent if they pad the same
1025 type and have the same size, alignment and RM size. Taking the mode
1026 into account is redundant since it is determined by the others. */
1027 return
1032 }
1034 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
1035 if needed. We have already verified that SIZE and TYPE are large enough.
1036 GNAT_ENTITY is used to name the resulting record and to issue a warning.
1037 IS_COMPONENT_TYPE is true if this is being done for the component type of
1038 an array. IS_USER_TYPE is true if the original type needs to be completed.
1039 DEFINITION is true if this type is being defined. SET_RM_SIZE is true if
1040 the RM size of the resulting type is to be set to SIZE too. */
1042 tree
1046 {
1050 /* If TYPE is a padded type, see if it agrees with any size and alignment
1051 we were given. If so, return the original type. Otherwise, strip
1052 off the padding, since we will either be returning the inner type
1053 or repadding it. If no size or alignment is specified, use that of
1054 the original padded type. */
1056 {
1073 }
1075 /* If the size is either not being changed or is being made smaller (which
1076 is not done here and is only valid for bitfields anyway), show the size
1077 isn't changing. Likewise, clear the alignment if it isn't being
1078 changed. Then return if we aren't doing anything. */
1091 /* If requested, complete the original type and give it a name. */
1098 gnat_entity);
1100 /* We used to modify the record in place in some cases, but that could
1101 generate incorrect debugging information. So make a new record
1102 type and name. */
1114 bitsize_unit_node));
1116 /* If we are changing the alignment and the input type is a record with
1117 BLKmode and a small constant size, try to make a form that has an
1118 integral mode. This might allow the padding record to also have an
1119 integral mode, which will be much more efficient. There is no point
1120 in doing so if a size is specified unless it is also a small constant
1121 size and it is incorrect to do so if we cannot guarantee that the mode
1122 will be naturally aligned since the field must always be addressable.
1124 ??? This might not always be a win when done for a stand-alone object:
1125 since the nominal and the effective type of the object will now have
1126 different modes, a VIEW_CONVERT_EXPR will be required for converting
1127 between them and it might be hard to overcome afterwards, including
1128 at the RTL level when the stand-alone object is accessed as a whole. */
1136 && (!size
1139 {
1144 }
1146 /* Now create the field with the original size. */
1151 /* Do not emit debug info until after the auxiliary record is built. */
1154 /* Set the RM size if requested. */
1156 {
1159 /* If the padded type is complete and has constant size, we canonicalize
1160 it by means of the hash table. This is consistent with the language
1161 semantics and ensures that gigi and the middle-end have a common view
1162 of these padded types. */
1164 {
1165 hashval_t hashcode;
1179 {
1182 }
1188 INSERT);
1190 }
1191 }
1193 /* Unless debugging information isn't being written for the input type,
1194 write a record that shows what we are a subtype of and also make a
1195 variable that indicates our size, if still variable. */
1201 {
1227 }
1231 built:
1232 /* If the size was widened explicitly, maybe give a warning. Take the
1233 original size as the maximum size of the input if there was an
1234 unconstrained record involved and round it up to the specified alignment,
1235 if one was specified. But don't do it if we are just annotating types
1236 and the type is tagged, since tagged types aren't fully laid out in this
1237 mode. */
1257 {
1270 /* Generate message only for entities that come from source, since
1271 if we have an entity created by expansion, the message will be
1272 generated for some other corresponding source entity. */
1274 {
1283 }
1284 }
1287 }
1288 \f
1289 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
1290 If this is a multi-dimensional array type, do this recursively.
1292 OP may be
1293 - ALIAS_SET_COPY: the new set is made a copy of the old one.
1294 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
1295 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
1297 void
1299 {
1300 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
1301 of a one-dimensional array, since the padding has the same alias set
1302 as the field type, but if it's a multi-dimensional array, we need to
1303 see the inner types. */
1309 /* Unconstrained array types are deemed incomplete and would thus be given
1310 alias set 0. Retrieve the underlying array type. */
1312 gnu_old_type
1315 gnu_new_type
1324 {
1326 /* The alias set shouldn't be copied between array types with different
1327 aliasing settings because this can break the aliasing relationship
1328 between the array type and its element type. */
1329 #ifndef ENABLE_CHECKING
1331 #endif
1342 {
1346 /* Do nothing if the alias sets conflict. This ensures that we
1347 never call record_alias_subset several times for the same pair
1348 or at all for alias set 0. */
1350 {
1353 else
1355 }
1356 }
1361 }
1364 }
1365 \f
1366 /* Record TYPE as a builtin type for Ada. NAME is the name of the type.
1367 ARTIFICIAL_P is true if it's a type that was generated by the compiler. */
1369 void
1371 {
1380 }
1381 \f
1382 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1383 finish constructing the record type as a fat pointer type. */
1385 void
1387 {
1388 /* Make sure we can put it into a register. */
1392 /* Show what it really is. */
1395 /* Do not emit debug info for it since the types of its fields may still be
1396 incomplete at this point. */
1399 /* Force type_contains_placeholder_p to return true on it. Although the
1400 PLACEHOLDER_EXPRs are referenced only indirectly, this isn't a pointer
1401 type but the representation of the unconstrained array. */
1403 }
1405 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1406 finish constructing the record or union type. If REP_LEVEL is zero, this
1407 record has no representation clause and so will be entirely laid out here.
1408 If REP_LEVEL is one, this record has a representation clause and has been
1409 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
1410 this record is derived from a parent record and thus inherits its layout;
1411 only make a pass on the fields to finalize them. DEBUG_INFO_P is true if
1412 we need to write debug information about this type. */
1414 void
1417 {
1425 tree field;
1429 /* Always attach the TYPE_STUB_DECL for a record type. It is required to
1430 generate debug info and have a parallel type. */
1435 /* Globally initialize the record first. If this is a rep'ed record,
1436 that just means some initializations; otherwise, layout the record. */
1438 {
1447 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
1448 out just like a UNION_TYPE, since the size will be fixed. */
1451 }
1452 else
1453 {
1454 /* Ensure there isn't a size already set. There can be in an error
1455 case where there is a rep clause but all fields have errors and
1456 no longer have a position. */
1459 /* Ensure we use the traditional GCC layout for bitfields when we need
1460 to pack the record type or have a representation clause. The other
1461 possible layout (Microsoft C compiler), if available, would prevent
1462 efficient packing in almost all cases. */
1463 #ifdef TARGET_MS_BITFIELD_LAYOUT
1468 ATTR_FLAG_TYPE_IN_PLACE);
1469 #endif
1472 }
1474 /* At this point, the position and size of each field is known. It was
1475 either set before entry by a rep clause, or by laying out the type above.
1477 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
1478 to compute the Ada size; the GCC size and alignment (for rep'ed records
1479 that are not padding types); and the mode (for rep'ed records). We also
1480 clear the DECL_BIT_FIELD indication for the cases we know have not been
1481 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
1487 {
1491 tree this_ada_size;
1498 else
1501 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
1504 {
1507 /* In the general case, type alignment is required. */
1509 {
1510 /* The enclosing record type must be sufficiently aligned.
1511 Otherwise, if no alignment was specified for it and it
1512 has been laid out already, bump its alignment to the
1513 desired one if this is compatible with its size. */
1515 {
1518 }
1522 {
1526 }
1527 }
1529 /* In the non-strict alignment case, only byte alignment is. */
1534 }
1536 /* If we still have DECL_BIT_FIELD set at this point, we know that the
1537 field is technically not addressable. Except that it can actually
1538 be addressed if it is BLKmode and happens to be properly aligned. */
1544 /* A type must be as aligned as its most aligned field that is not
1545 a bit-field. But this is already enforced by layout_type. */
1551 {
1558 ada_size
1566 /* Since we know here that all fields are sorted in order of
1567 increasing bit position, the size of the record is one
1568 higher than the ending bit of the last field processed
1569 unless we have a rep clause, since in that case we might
1570 have a field outside a QUAL_UNION_TYPE that has a higher ending
1571 position. So use a MAX in that case. Also, if this field is a
1572 QUAL_UNION_TYPE, we need to take into account the previous size in
1573 the case of empty variants. */
1574 ada_size
1577 size
1584 }
1585 }
1591 {
1592 /* If this is a padding record, we never want to make the size smaller
1593 than what was specified in it, if any. */
1597 /* Now set any of the values we've just computed that apply. */
1603 {
1604 tree size_unit = had_size_unit
1608 bitsize_unit_node));
1616 }
1617 }
1621 }
1623 /* Append PARALLEL_TYPE on the chain of parallel types of TYPE. */
1625 void
1627 {
1634 }
1636 /* Return true if TYPE has a parallel type. */
1638 static bool
1640 {
1644 }
1646 /* Wrap up compilation of RECORD_TYPE, i.e. output all the debug information
1647 associated with it. It need not be invoked directly in most cases since
1648 finish_record_type takes care of doing so, but this can be necessary if
1649 a parallel type is to be attached to the record type. */
1651 void
1653 {
1655 tree field;
1657 /* If this is a padded type, the bulk of the debug info has already been
1658 generated for the field's type. */
1662 /* If the type already has a parallel type (XVS type), then we're done. */
1667 {
1668 /* We need to make an XVE/XVU record if any field has variable size,
1669 whether or not the record does. For example, if we have a union,
1670 it may be that all fields, rounded up to the alignment, have the
1671 same size, in which case we'll use that size. But the debug
1672 output routines (except Dwarf2) won't be able to output the fields,
1673 so we need to make the special record. */
1675 /* If a field has a non-constant qualifier, the record will have
1676 variable size too. */
1679 {
1682 }
1683 }
1685 /* If this record type is of variable size, make a parallel record type that
1686 will tell the debugger how the former is laid out (see exp_dbug.ads). */
1688 {
1689 tree new_record_type
1699 new_name
1712 /* Now scan all the fields, replacing each field with a new field
1713 corresponding to the new encoding. */
1716 {
1724 /* We're going to do some pattern matching below so remove as many
1725 conversions as possible. */
1728 /* See how the position was modified from the last position.
1730 There are two basic cases we support: a value was added
1731 to the last position or the last position was rounded to
1732 a boundary and they something was added. Check for the
1733 first case first. If not, see if there is any evidence
1734 of rounding. If so, round the last position and retry.
1736 If this is a union, the position can be taken as zero. */
1739 else
1745 {
1751 }
1756 && host_integerp
1758 {
1760 unsigned HOST_WIDE_INT addend
1762 align
1768 }
1770 {
1774 }
1776 /* If we can't compute a position, set it to zero.
1778 ??? We really should abort here, but it's too much work
1779 to get this correct for all cases. */
1783 /* See if this type is variable-sized and make a pointer type
1784 and indicate the indirection if so. Beware that the debug
1785 back-end may adjust the position computed above according
1786 to the alignment of the field type, i.e. the pointer type
1787 in this case, if we don't preventively counter that. */
1789 {
1792 {
1795 }
1797 }
1799 /* Make a new field name, if necessary. */
1801 {
1807 else
1811 }
1813 new_field
1819 /* If old_field is a QUAL_UNION_TYPE, take its size as being
1820 zero. The only time it's not the last field of the record
1821 is when there are other components at fixed positions after
1822 it (meaning there was a rep clause for every field) and we
1823 want to be able to encode them. */
1827 ? bitsize_zero_node
1830 }
1835 }
1836 }
1838 /* Utility function of above to merge LAST_SIZE, the previous size of a record
1839 with FIRST_BIT and SIZE that describe a field. SPECIAL is true if this
1840 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
1841 replace a value of zero with the old size. If HAS_REP is true, we take the
1842 MAX of the end position of this field with LAST_SIZE. In all other cases,
1843 we use FIRST_BIT plus SIZE. Return an expression for the size. */
1845 static tree
1848 {
1850 tree new_size;
1853 {
1857 }
1859 else
1870 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
1871 when fed through substitute_in_expr) into thinking that a constant
1872 size is not constant. */
1877 }
1879 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
1880 related by the addition of a constant. Return that constant if so. */
1882 static tree
1884 {
1894 else
1896 }
1898 /* Utility function of above to split a tree OP which may be a sum, into a
1899 constant part, which is returned, and a variable part, which is stored
1900 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
1901 bitsizetype. */
1903 static tree
1905 {
1906 /* Strip conversions in order to ease the tree traversal and maximize the
1907 potential for constant or plus/minus discovery. We need to be careful
1908 to always return and set *pvar to bitsizetype trees, but it's worth
1909 the effort. */
1915 {
1918 }
1920 {
1931 }
1932 else
1934 }
1935 \f
1936 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
1937 subprogram. If it is VOID_TYPE, then we are dealing with a procedure,
1938 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
1939 PARM_DECL nodes that are the subprogram parameters. CICO_LIST is the
1940 copy-in/copy-out list to be stored into the TYPE_CICO_LIST field.
1941 RETURN_UNCONSTRAINED_P is true if the function returns an unconstrained
1942 object. RETURN_BY_DIRECT_REF_P is true if the function returns by direct
1943 reference. RETURN_BY_INVISI_REF_P is true if the function returns by
1944 invisible reference. */
1946 tree
1950 {
1951 /* A list of the data type nodes of the subprogram formal parameters.
1952 This list is generated by traversing the input list of PARM_DECL
1953 nodes. */
1962 /* TYPE may have been shared since GCC hashes types. If it has a different
1963 CICO_LIST, make a copy. Likewise for the various flags. */
1966 {
1972 }
1975 }
1976 \f
1977 /* Return a copy of TYPE but safe to modify in any way. */
1979 tree
1981 {
1984 /* Unshare the language-specific data. */
1986 {
1989 }
1991 /* And the contents of the language-specific slot if needed. */
1994 {
1999 }
2001 /* copy_node clears this field instead of copying it, because it is
2002 aliased with TREE_CHAIN. */
2011 }
2012 \f
2013 /* Return a subtype of sizetype with range MIN to MAX and whose
2014 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
2015 of the associated TYPE_DECL. */
2017 tree
2019 {
2020 /* First build a type for the desired range. */
2023 /* Then set the index type. */
2028 }
2030 /* Return a subtype of TYPE with range MIN to MAX. If TYPE is NULL,
2031 sizetype is used. */
2033 tree
2035 {
2036 tree range_type;
2041 /* First build a type with the base range. */
2045 /* Then set the actual range. */
2050 }
2051 \f
2052 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of a type.
2053 TYPE_NAME gives the name of the type and TYPE is a ..._TYPE node giving
2054 its data type. */
2056 tree
2058 {
2059 /* Using a named TYPE_DECL ensures that a type name marker is emitted in
2060 STABS while setting DECL_ARTIFICIAL ensures that no DW_TAG_typedef is
2061 emitted in DWARF. */
2067 }
2069 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type and TYPE
2070 is a ..._TYPE node giving its data type. ARTIFICIAL_P is true if this
2071 is a declaration that was generated by the compiler. DEBUG_INFO_P is
2072 true if we need to write debug information about this type. GNAT_NODE
2073 is used for the position of the decl. */
2075 tree
2078 {
2081 tree type_decl;
2083 /* Only the builtin TYPE_STUB_DECL should be used for dummy types. */
2086 /* If the type hasn't been named yet, we're naming it; preserve an existing
2087 TYPE_STUB_DECL that has been attached to it for some purpose. */
2089 {
2092 }
2093 else
2099 /* Add this decl to the current binding level. */
2102 /* If we're naming the type, equate the TYPE_STUB_DECL to the name.
2103 This causes the name to be also viewed as a "tag" by the debug
2104 back-end, with the advantage that no DW_TAG_typedef is emitted
2105 for artificial "tagged" types in DWARF. */
2109 /* Do not generate debug info for UNCONSTRAINED_ARRAY_TYPE that the
2110 back-end doesn't support, and for others if we don't need to. */
2115 }
2116 \f
2117 /* Return a VAR_DECL or CONST_DECL node.
2119 VAR_NAME gives the name of the variable. ASM_NAME is its assembler name
2120 (if provided). TYPE is its data type (a GCC ..._TYPE node). VAR_INIT is
2121 the GCC tree for an optional initial expression; NULL_TREE if none.
2123 CONST_FLAG is true if this variable is constant, in which case we might
2124 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
2126 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
2127 definition to be made visible outside of the current compilation unit, for
2128 instance variable definitions in a package specification.
2130 EXTERN_FLAG is true when processing an external variable declaration (as
2131 opposed to a definition: no storage is to be allocated for the variable).
2133 STATIC_FLAG is only relevant when not at top level. In that case
2134 it indicates whether to always allocate storage to the variable.
2136 GNAT_NODE is used for the position of the decl. */
2138 tree
2143 {
2144 /* Whether the initializer is a constant initializer. At the global level
2145 or for an external object or an object to be allocated in static memory,
2146 we check that it is a valid constant expression for use in initializing
2147 a static variable; otherwise, we only check that it is constant. */
2148 bool init_const
2155 /* Whether we will make TREE_CONSTANT the DECL we produce here, in which
2156 case the initializer may be used in-lieu of the DECL node (as done in
2157 Identifier_to_gnu). This is useful to prevent the need of elaboration
2158 code when an identifier for which such a decl is made is in turn used as
2159 an initializer. We used to rely on CONST vs VAR_DECL for this purpose,
2160 but extra constraints apply to this choice (see below) and are not
2161 relevant to the distinction we wish to make. */
2164 /* The actual DECL node. CONST_DECL was initially intended for enumerals
2165 and may be used for scalars in general but not for aggregates. */
2166 tree var_decl
2172 /* If this is external, throw away any initializations (they will be done
2173 elsewhere) unless this is a constant for which we would like to remain
2174 able to get the initializer. If we are defining a global here, leave a
2175 constant initialization and save any variable elaborations for the
2176 elaboration routine. If we are just annotating types, throw away the
2177 initialization if it isn't a constant. */
2182 /* At the global level, an initializer requiring code to be generated
2183 produces elaboration statements. Check that such statements are allowed,
2184 that is, not violating a No_Elaboration_Code restriction. */
2196 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
2197 try to fiddle with DECL_COMMON. However, on platforms that don't
2198 support global BSS sections, uninitialized global variables would
2199 go in DATA instead, thus increasing the size of the executable. */
2206 /* At the global binding level, we need to allocate static storage for the
2207 variable if it isn't external. Otherwise, we allocate automatic storage
2208 unless requested not to. */
2212 /* For an external constant whose initializer is not absolute, do not emit
2213 debug info. In DWARF this would mean a global relocation in a read-only
2214 section which runs afoul of the PE-COFF run-time relocation mechanism. */
2216 && constant_p
2217 && var_init
2225 /* ??? Some attributes cannot be applied to CONST_DECLs. */
2229 /* Add this decl to the current binding level. */
2233 {
2239 }
2242 }
2243 \f
2244 /* Return true if TYPE, an aggregate type, contains (or is) an array. */
2246 static bool
2248 {
2250 {
2254 {
2255 tree field;
2261 }
2268 }
2269 }
2271 /* Return a FIELD_DECL node. FIELD_NAME is the field's name, FIELD_TYPE is
2272 its type and RECORD_TYPE is the type of the enclosing record. If SIZE is
2273 nonzero, it is the specified size of the field. If POS is nonzero, it is
2274 the bit position. PACKED is 1 if the enclosing record is packed, -1 if it
2275 has Component_Alignment of Storage_Unit. If ADDRESSABLE is nonzero, it
2276 means we are allowed to take the address of the field; if it is negative,
2277 we should not make a bitfield, which is used by make_aligning_type. */
2279 tree
2282 {
2289 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
2290 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
2291 Likewise for an aggregate without specified position that contains an
2292 array, because in this case slices of variable length of this array
2293 must be handled by GCC and variable-sized objects need to be aligned
2294 to at least a byte boundary. */
2296 || (!pos
2301 /* If a size is specified, use it. Otherwise, if the record type is packed
2302 compute a size to use, which may differ from the object's natural size.
2303 We always set a size in this case to trigger the checks for bitfield
2304 creation below, which is typically required when no position has been
2305 specified. */
2309 {
2313 }
2315 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
2316 specified for two reasons: first if the size differs from the natural
2317 size. Second, if the alignment is insufficient. There are a number of
2318 ways the latter can be true.
2320 We never make a bitfield if the type of the field has a nonconstant size,
2321 because no such entity requiring bitfield operations should reach here.
2323 We do *preventively* make a bitfield when there might be the need for it
2324 but we don't have all the necessary information to decide, as is the case
2325 of a field with no specified position in a packed record.
2327 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
2328 in layout_decl or finish_record_type to clear the bit_field indication if
2329 it is in fact not needed. */
2331 && size
2336 || packed
2339 {
2343 {
2347 else
2349 }
2350 }
2354 /* Bump the alignment if need be, either for bitfield/packing purposes or
2355 to satisfy the type requirements if no such consideration applies. When
2356 we get the alignment from the type, indicate if this is from an explicit
2357 user request, which prevents stor-layout from lowering it later on. */
2358 {
2359 unsigned int bit_align
2366 {
2369 }
2370 }
2373 {
2374 /* We need to pass in the alignment the DECL is known to have.
2375 This is the lowest-order bit set in POS, but no more than
2376 the alignment of the record, if one is specified. Note
2377 that an alignment of 0 is taken as infinite. */
2382 else
2396 }
2398 /* In addition to what our caller says, claim the field is addressable if we
2399 know that its type is not suitable.
2401 The field may also be "technically" nonaddressable, meaning that even if
2402 we attempt to take the field's address we will actually get the address
2403 of a copy. This is the case for true bitfields, but the DECL_BIT_FIELD
2404 value we have at this point is not accurate enough, so we don't account
2405 for this here and let finish_record_type decide. */
2412 }
2413 \f
2414 /* Return a PARM_DECL node. PARAM_NAME is the name of the parameter and
2415 PARAM_TYPE is its type. READONLY is true if the parameter is readonly
2416 (either an In parameter or an address of a pass-by-ref parameter). */
2418 tree
2420 {
2424 /* Honor TARGET_PROMOTE_PROTOTYPES like the C compiler, as not doing so
2425 can lead to various ABI violations. */
2429 {
2430 /* We have to be careful about biased types here. Make a subtype
2431 of integer_type_node with the proper biasing. */
2434 {
2435 tree subtype
2442 }
2443 else
2445 }
2450 }
2451 \f
2452 /* Process the attributes in ATTR_LIST for NODE, which is either a DECL or
2453 a TYPE. If IN_PLACE is true, the tree pointed to by NODE should not be
2454 changed. GNAT_NODE is used for the position of error messages. */
2456 void
2458 Node_Id gnat_node)
2459 {
2464 {
2473 {
2476 }
2482 else
2489 {
2494 }
2495 else
2514 }
2517 }
2518 \f
2519 /* Record DECL as a global renaming pointer. */
2521 void
2523 {
2526 }
2528 /* Invalidate the global renaming pointers. */
2530 void
2532 {
2534 tree iter;
2543 }
2545 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
2546 a power of 2. */
2548 bool
2550 {
2559 }
2561 /* Return VALUE scaled by the biggest power-of-2 factor of EXPR. */
2563 static unsigned int
2565 {
2568 /* An expression which is a bitwise AND with a mask has a power-of-2 factor
2569 corresponding to the number of trailing zeros of the mask. */
2572 {
2577 {
2580 i++;
2581 }
2582 }
2585 }
2587 /* Given two consecutive field decls PREV_FIELD and CURR_FIELD, return true
2588 unless we can prove these 2 fields are laid out in such a way that no gap
2589 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
2590 is the distance in bits between the end of PREV_FIELD and the starting
2591 position of CURR_FIELD. It is ignored if null. */
2593 static bool
2595 {
2596 /* If this is the first field of the record, there cannot be any gap */
2600 /* If the previous field is a union type, then return false: The only
2601 time when such a field is not the last field of the record is when
2602 there are other components at fixed positions after it (meaning there
2603 was a rep clause for every field), in which case we don't want the
2604 alignment constraint to override them. */
2608 /* If the distance between the end of prev_field and the beginning of
2609 curr_field is constant, then there is a gap if the value of this
2610 constant is not null. */
2614 /* If the size and position of the previous field are constant,
2615 then check the sum of this size and position. There will be a gap
2616 iff it is not multiple of the current field alignment. */
2623 /* If both the position and size of the previous field are multiples
2624 of the current field alignment, there cannot be any gap. */
2629 /* Fallback, return that there may be a potential gap */
2631 }
2633 /* Return a LABEL_DECL with LABEL_NAME. GNAT_NODE is used for the position
2634 of the decl. */
2636 tree
2638 {
2639 tree label_decl
2644 /* Add this decl to the current binding level. */
2648 }
2649 \f
2650 /* Return a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
2651 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
2652 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
2653 PARM_DECL nodes chained through the DECL_CHAIN field).
2655 INLINE_STATUS, PUBLIC_FLAG, EXTERN_FLAG, ARTIFICIAL_FLAG and ATTR_LIST are
2656 used to set the appropriate fields in the FUNCTION_DECL. GNAT_NODE is
2657 used for the position of the decl. */
2659 tree
2664 {
2666 subprog_type);
2671 /* If this is a non-inline function nested inside an inlined external
2672 function, we cannot honor both requests without cloning the nested
2673 function in the current unit since it is private to the other unit.
2674 We could inline the nested function as well but it's probably better
2675 to err on the side of too little inlining. */
2677 && !public_flag
2678 && current_function_decl
2687 {
2702 }
2715 {
2718 /* The expand_main_function circuitry expects "main_identifier_node" to
2719 designate the DECL_NAME of the 'main' entry point, in turn expected
2720 to be declared as the "main" function literally by default. Ada
2721 program entry points are typically declared with a different name
2722 within the binder generated file, exported as 'main' to satisfy the
2723 system expectations. Force main_identifier_node in this case. */
2726 }
2730 /* Add this decl to the current binding level. */
2733 /* Output the assembler code and/or RTL for the declaration. */
2737 }
2738 \f
2739 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
2740 body. This routine needs to be invoked before processing the declarations
2741 appearing in the subprogram. */
2743 void
2745 {
2746 tree param_decl;
2750 /* This function is being defined. */
2755 /* Enter a new binding level and show that all the parameters belong to
2756 this function. */
2764 }
2766 /* Finish translating the current subprogram and set its BODY. */
2768 void
2770 {
2773 /* Attach the BLOCK for this level to the function and pop the level. */
2778 /* Mark the RESULT_DECL as being in this subprogram. */
2781 /* The body should be a BIND_EXPR whose BLOCK is the top-level one. */
2783 {
2786 }
2791 }
2793 /* Wrap up compilation of SUBPROG_DECL, a subprogram body. */
2795 void
2797 {
2798 /* We cannot track the location of errors past this point. */
2801 /* If we're only annotating types, don't actually compile this function. */
2805 /* Dump functions before gimplification. */
2810 else
2811 /* Register this function with cgraph just far enough to get it
2812 added to our parent's nested function list. */
2814 }
2816 tree
2818 {
2821 }
2823 /* Return an integer type with the number of bits of precision given by
2824 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
2825 it is a signed type. */
2827 tree
2829 {
2830 tree t;
2839 else
2846 {
2849 }
2852 }
2854 /* Likewise for floating-point types. */
2856 static tree
2858 {
2859 tree t;
2871 {
2874 }
2877 }
2879 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
2880 an unsigned type; otherwise a signed type is returned. */
2882 tree
2884 {
2901 {
2906 }
2909 }
2911 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
2913 tree
2915 {
2919 {
2922 }
2926 {
2929 }
2932 }
2934 /* Return the signed version of a TYPE_NODE, a scalar type. */
2936 tree
2938 {
2942 {
2945 }
2949 {
2952 }
2955 }
2957 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
2958 transparently converted to each other. */
2960 int
2962 {
2965 /* This is the default criterion. */
2969 /* We only check structural equivalence here. */
2973 /* Vector types are also compatible if they have the same number of subparts
2974 and the same form of (scalar) element type. */
2981 /* Array types are also compatible if they are constrained and have the same
2982 domain(s) and the same component type. */
2997 }
2999 /* Return true if EXPR is a useless type conversion. */
3001 bool
3003 {
3011 }
3013 /* Return true if T, a FUNCTION_TYPE, has the specified list of flags. */
3015 bool
3018 {
3023 }
3024 \f
3025 /* EXP is an expression for the size of an object. If this size contains
3026 discriminant references, replace them with the maximum (if MAX_P) or
3027 minimum (if !MAX_P) possible value of the discriminant. */
3029 tree
3031 {
3036 {
3043 {
3057 }
3061 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
3062 modify. Otherwise, we treat it like a variable. */
3067 return
3082 {
3087 /* Special-case wanting the maximum value of a MIN_EXPR.
3088 In that case, if one side overflows, return the other. */
3090 {
3096 }
3098 /* Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
3099 overflowing and the RHS a variable. */
3107 }
3111 {
3135 }
3137 /* Other tree classes cannot happen. */
3140 }
3143 }
3144 \f
3145 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
3146 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
3147 Return a constructor for the template. */
3149 tree
3151 {
3154 tree field;
3166 /* First make the list for a CONSTRUCTOR for the template. Go down the
3167 field list of the template instead of the type chain because this
3168 array might be an Ada array of arrays and we can't tell where the
3169 nested arrays stop being the underlying object. */
3172 (bound_list
3176 {
3179 /* If we have a bound list, get the bounds from there. Likewise
3180 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
3181 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
3182 This will give us a maximum range. */
3190 else
3196 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
3197 substitute it from OBJECT. */
3203 }
3206 }
3207 \f
3208 /* Helper routine to make a descriptor field. FIELD_LIST is the list of decls
3209 being built; the new decl is chained on to the front of the list. */
3211 static tree
3214 {
3215 tree field
3222 }
3224 /* Build a 32-bit VMS descriptor from a Mechanism_Type, which must specify a
3225 descriptor type, and the GCC type of an object. Each FIELD_DECL in the
3226 type contains in its DECL_INITIAL the expression to use when a constructor
3227 is made for the type. GNAT_ENTITY is an entity used to print out an error
3228 message if the mechanism cannot be applied to an object of that type and
3229 also for the name. */
3231 tree
3233 {
3241 /* If TYPE is an unconstrained array, use the underlying array type. */
3245 /* If this is an array, compute the number of dimensions in the array,
3246 get the index types, and point to the inner type. */
3249 else
3254 ;
3264 else
3270 /* Now get the DTYPE value. */
3272 {
3278 {
3288 }
3289 else
3291 {
3307 }
3318 {
3327 }
3328 else
3338 }
3340 /* Get the CLASS value. */
3342 {
3362 }
3364 /* Make the type for a descriptor for VMS. The first four fields are the
3365 same for all types. */
3366 field_list
3371 field_list);
3372 field_list
3375 field_list
3382 /* Ensure that only 32-bit pointers are passed in 32-bit descriptors. Note
3383 that we cannot build a template call to the CE routine as it would get a
3384 wrong source location; instead we use a second placeholder for it. */
3388 Pmode != SImode
3395 field_list
3397 field_list);
3400 {
3409 field_list
3411 record_type,
3415 field_list);
3416 field_list
3418 record_type,
3422 field_list);
3429 field_list
3433 field_list
3437 field_list
3439 record_type,
3443 /* Set FL_COLUMN, FL_COEFF, and
3444 FL_BOUNDS. */
3446 && TYPE_CONVENTION_FORTRAN_P
3449 field_list);
3451 field_list
3455 field_list
3458 field_list);
3460 /* Now build a pointer to the 0,0,0... element. */
3468 field_list
3471 field_list);
3473 /* Next come the addressing coefficients. */
3476 {
3478 tree idx_length
3489 field_list
3495 }
3497 /* Finally here are the bounds. */
3499 {
3503 field_list
3506 field_list);
3509 field_list
3512 field_list);
3513 }
3518 }
3523 }
3525 /* Build a 64-bit VMS descriptor from a Mechanism_Type, which must specify a
3526 descriptor type, and the GCC type of an object. Each FIELD_DECL in the
3527 type contains in its DECL_INITIAL the expression to use when a constructor
3528 is made for the type. GNAT_ENTITY is an entity used to print out an error
3529 message if the mechanism cannot be applied to an object of that type and
3530 also for the name. */
3532 tree
3534 {
3536 tree pointer64_type;
3542 /* If TYPE is an unconstrained array, use the underlying array type. */
3546 /* If this is an array, compute the number of dimensions in the array,
3547 get the index types, and point to the inner type. */
3550 else
3555 ;
3565 else
3571 /* Now get the DTYPE value. */
3573 {
3579 {
3589 }
3590 else
3592 {
3608 }
3619 {
3628 }
3629 else
3639 }
3641 /* Get the CLASS value. */
3643 {
3658 }
3660 /* Make the type for a 64-bit descriptor for VMS. The first six fields
3661 are the same for all types. */
3662 field_list
3665 field_list
3668 field_list
3671 field_list
3674 field_list
3676 record_type,
3679 field_list);
3683 field_list
3687 field_list);
3690 {
3696 field_list
3698 record_type,
3702 field_list);
3703 field_list
3705 record_type,
3709 field_list);
3714 field_list
3718 field_list
3724 /* Set FL_COLUMN, FL_COEFF, and
3725 FL_BOUNDS. */
3729 field_list
3732 field_list);
3734 field_list
3738 field_list
3741 field_list
3744 field_list);
3746 /* Now build a pointer to the 0,0,0... element. */
3754 field_list
3757 field_list);
3759 /* Next come the addressing coefficients. */
3762 {
3764 tree idx_length
3774 field_list
3780 }
3782 /* Finally here are the bounds. */
3784 {
3788 field_list
3790 record_type,
3794 field_list
3796 record_type,
3798 }
3803 }
3808 }
3810 /* Fill in a VMS descriptor of GNU_TYPE for GNU_EXPR and return the result.
3811 GNAT_ACTUAL is the actual parameter for which the descriptor is built. */
3813 tree
3815 {
3817 tree field;
3823 /* We may need to substitute both GNU_EXPR and a CALL_EXPR to the raise CE
3824 routine in case we have a 32-bit descriptor. */
3827 N_Raise_Constraint_Error),
3828 gnu_expr);
3831 {
3832 tree value
3835 gnu_expr));
3837 }
3840 }
3842 /* Convert GNU_EXPR, a pointer to a 64bit VMS descriptor, to GNU_TYPE, a
3843 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3844 which the VMS descriptor is passed. */
3846 static tree
3848 {
3851 /* The CLASS field is the 3rd field in the descriptor. */
3853 /* The POINTER field is the 6th field in the descriptor. */
3856 /* Retrieve the value of the POINTER field. */
3857 tree gnu_expr64
3864 {
3871 /* See the head comment of build_vms_descriptor. */
3876 /* Convert POINTER to the pointer-to-array type. */
3880 {
3883 /* Build {1, LENGTH} template; LENGTH64 is the 5th field. */
3889 integer_one_node));
3895 /* For class S, we are done. */
3899 /* Test that we really have a SB descriptor, like DEC Ada. */
3903 /* If so, there is already a template in the descriptor and
3904 it is located right after the POINTER field. The fields are
3905 64bits so they must be repacked. */
3912 ufield = convert
3915 /* Build the template in the form of a constructor. */
3919 ufield);
3922 /* Otherwise use the {1, LENGTH} template we build above. */
3925 template_tree),
3926 template_addr);
3930 /* The AFLAGS field is the 3rd field after the pointer in the
3931 descriptor. */
3934 /* The DIMCT field is the next field in the descriptor after
3935 aflags. */
3938 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
3939 or FL_COEFF or FL_BOUNDS not set. */
3943 dimct,
3945 size_one_node)),
3950 u));
3951 /* There is already a template in the descriptor and it is located
3952 in block 3. The fields are 64bits so they must be repacked. */
3960 ufield = convert
3963 /* Build the template in the form of a constructor. */
3967 ufield);
3971 N_Raise_Constraint_Error),
3972 template_tree);
3973 template_addr
3982 }
3984 /* Build the fat pointer in the form of a constructor. */
3988 template_addr);
3990 }
3992 else
3994 }
3996 /* Convert GNU_EXPR, a pointer to a 32bit VMS descriptor, to GNU_TYPE, a
3997 regular pointer or fat pointer type. GNAT_SUBPROG is the subprogram to
3998 which the VMS descriptor is passed. */
4000 static tree
4002 {
4005 /* The CLASS field is the 3rd field in the descriptor. */
4007 /* The POINTER field is the 4th field in the descriptor. */
4010 /* Retrieve the value of the POINTER field. */
4011 tree gnu_expr32
4018 {
4025 /* See the head comment of build_vms_descriptor. */
4029 /* Convert POINTER to the pointer-to-array type. */
4033 {
4036 /* Build {1, LENGTH} template; LENGTH is the 1st field. */
4042 integer_one_node));
4048 /* For class S, we are done. */
4052 /* Test that we really have a SB descriptor, like DEC Ada. */
4056 /* If so, there is already a template in the descriptor and
4057 it is located right after the POINTER field. */
4059 template_tree
4061 /* Otherwise use the {1, LENGTH} template we build above. */
4064 template_tree),
4065 template_addr);
4069 /* The AFLAGS field is the 7th field in the descriptor. */
4072 /* The DIMCT field is the 8th field in the descriptor. */
4075 /* Raise CONSTRAINT_ERROR if either more than 1 dimension
4076 or FL_COEFF or FL_BOUNDS not set. */
4080 dimct,
4082 size_one_node)),
4087 u));
4088 /* There is already a template in the descriptor and it is
4089 located at the start of block 3 (12th field). */
4091 template_tree
4095 N_Raise_Constraint_Error),
4096 template_tree);
4097 template_addr
4106 }
4108 /* Build the fat pointer in the form of a constructor. */
4112 template_addr);
4115 }
4117 else
4119 }
4121 /* Convert GNU_EXPR, a pointer to a VMS descriptor, to GNU_TYPE, a regular
4122 pointer or fat pointer type. GNU_EXPR_ALT_TYPE is the alternate (32-bit)
4123 pointer type of GNU_EXPR. GNAT_SUBPROG is the subprogram to which the
4124 descriptor is passed. */
4126 tree
4128 Entity_Id gnat_subprog)
4129 {
4137 /* If the field name is not MBO, it must be 32-bit and no alternate.
4138 Otherwise primary must be 64-bit and alternate 32-bit. */
4140 {
4143 }
4145 /* Build the test for 64-bit descriptor. */
4148 is64bit
4152 integer_one_node),
4155 integer_minus_one_node));
4157 /* Build the 2 possible end results. */
4162 }
4163 \f
4164 /* Build a type to be used to represent an aliased object whose nominal type
4165 is an unconstrained array. This consists of a RECORD_TYPE containing a
4166 field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an ARRAY_TYPE.
4167 If ARRAY_TYPE is that of an unconstrained array, this is used to represent
4168 an arbitrary unconstrained object. Use NAME as the name of the record.
4169 DEBUG_INFO_P is true if we need to write debug information for the type. */
4171 tree
4174 {
4176 tree template_field
4179 tree array_field
4188 /* Declare it now since it will never be declared otherwise. This is
4189 necessary to ensure that its subtrees are properly marked. */
4193 }
4195 /* Same, taking a thin or fat pointer type instead of a template type. */
4197 tree
4200 {
4201 tree template_type;
4205 template_type
4210 return
4212 }
4213 \f
4214 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.
4215 In the normal case this is just two adjustments, but we have more to
4216 do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */
4218 void
4220 {
4223 tree t;
4225 /* If this is the main variant, process all the other variants first. */
4230 /* If no pointers and no references, we are done. */
4234 /* Merge the old type qualifiers in the new type.
4236 Each old variant has qualifiers for specific reasons, and the new
4237 designated type as well. Each set of qualifiers represents useful
4238 information grabbed at some point, and merging the two simply unifies
4239 these inputs into the final type description.
4241 Consider for instance a volatile type frozen after an access to constant
4242 type designating it; after the designated type's freeze, we get here with
4243 a volatile NEW_TYPE and a dummy OLD_TYPE with a readonly variant, created
4244 when the access type was processed. We will make a volatile and readonly
4245 designated type, because that's what it really is.
4247 We might also get here for a non-dummy OLD_TYPE variant with different
4248 qualifiers than those of NEW_TYPE, for instance in some cases of pointers
4249 to private record type elaboration (see the comments around the call to
4250 this routine in gnat_to_gnu_entity <E_Access_Type>). We have to merge
4251 the qualifiers in those cases too, to avoid accidentally discarding the
4252 initial set, and will often end up with OLD_TYPE == NEW_TYPE then. */
4253 new_type
4257 /* If old type and new type are identical, there is nothing to do. */
4261 /* Otherwise, first handle the simple case. */
4263 {
4266 /* If pointer or reference already points to new type, nothing to do.
4267 This can happen as update_pointer_to can be invoked multiple times
4268 on the same couple of types because of the type variants. */
4273 /* Chain PTR and its variants at the end. */
4276 {
4280 }
4281 else
4284 /* Now adjust them. */
4287 {
4291 }
4293 /* Chain REF and its variants at the end. */
4296 {
4300 }
4301 else
4304 /* Now adjust them. */
4311 }
4313 /* Now deal with the unconstrained array case. In this case the pointer
4314 is actually a record where both fields are pointers to dummy nodes.
4315 Turn them into pointers to the correct types using update_pointer_to.
4316 Likewise for the pointer to the object record (thin pointer). */
4317 else
4318 {
4323 /* If PTR already points to NEW_TYPE, nothing to do. This can happen
4324 since update_pointer_to can be invoked multiple times on the same
4325 couple of types because of the type variants. */
4329 update_pointer_to
4333 update_pointer_to
4341 }
4342 }
4343 \f
4344 /* Convert EXPR, a pointer to a constrained array, into a pointer to an
4345 unconstrained one. This involves making or finding a template. */
4347 static tree
4349 {
4353 tree template_tree;
4357 /* If EXPR is null, make a fat pointer that contains a null pointer to the
4358 array (compare_fat_pointers ensures that this is the full discriminant)
4359 and a valid pointer to the bounds. This latter property is necessary
4360 since the compiler can hoist the load of the bounds done through it. */
4362 {
4368 else
4369 {
4370 /* The template type can still be dummy at this point so we build an
4371 empty constructor. The middle-end will fill it in with zeros. */
4373 NULL);
4377 }
4383 /* Do not set TREE_CONSTANT so as to force T to static memory. */
4388 }
4390 /* If EXPR is a thin pointer, make template and data from the record. */
4392 {
4398 else
4399 {
4400 /* If we have a TYPE_UNCONSTRAINED_ARRAY attached to the RECORD_TYPE,
4401 the thin pointer value has been shifted so we first need to shift
4402 it back to get the template address. */
4404 expr
4407 byte_position
4410 }
4416 }
4418 /* Otherwise, build the constructor for the template. */
4419 else
4422 /* The final result is a constructor for the fat pointer.
4424 If EXPR is an argument of a foreign convention subprogram, the type it
4425 points to is directly the component type. In this case, the expression
4426 type may not match the corresponding FIELD_DECL type at this point, so we
4427 call "convert" here to fix that up if necessary. This type consistency is
4428 required, for instance because it ensures that possible later folding of
4429 COMPONENT_REFs against this constructor always yields something of the
4430 same type as the initial reference.
4432 Note that the call to "build_template" above is still fine because it
4433 will only refer to the provided TEMPLATE_TYPE in this case. */
4438 template_tree));
4440 }
4441 \f
4442 /* Create an expression whose value is that of EXPR,
4443 converted to type TYPE. The TREE_TYPE of the value
4444 is always TYPE. This function implements all reasonable
4445 conversions; callers should filter out those that are
4446 not permitted by the language being compiled. */
4448 tree
4450 {
4455 /* If the expression is already of the right type, we are done. */
4459 /* If both input and output have padding and are of variable size, do this
4460 as an unchecked conversion. Likewise if one is a mere variant of the
4461 other, so we avoid a pointless unpad/repad sequence. */
4469 ;
4471 /* If the output type has padding, convert to the inner type and make a
4472 constructor to build the record, unless a variable size is involved. */
4474 {
4477 /* If we previously converted from another type and our type is
4478 of variable size, remove the conversion to avoid the need for
4479 variable-sized temporaries. Likewise for a conversion between
4480 original and packable version. */
4488 /* If we are just removing the padding from expr, convert the original
4489 object if we have variable size in order to avoid the need for some
4490 variable-sized temporaries. Likewise if the padding is a variant
4491 of the other, so we avoid a pointless unpad/repad sequence. */
4502 /* If the inner type is of self-referential size and the expression type
4503 is a record, do this as an unchecked conversion. But first pad the
4504 expression if possible to have the same size on both sides. */
4507 {
4511 expr);
4513 }
4515 /* If we are converting between array types with variable size, do the
4516 final conversion as an unchecked conversion, again to avoid the need
4517 for some variable-sized temporaries. If valid, this conversion is
4518 very likely purely technical and without real effects. */
4525 expr),
4532 }
4534 /* If the input type has padding, remove it and convert to the output type.
4535 The conditions ordering is arranged to ensure that the output type is not
4536 a padding type here, as it is not clear whether the conversion would
4537 always be correct if this was to happen. */
4539 {
4540 tree unpadded;
4542 /* If we have just converted to this padded type, just get the
4543 inner expression. */
4549 /* Otherwise, build an explicit component reference. */
4550 else
4551 unpadded
4555 }
4557 /* If the input is a biased type, adjust first. */
4561 expr),
4564 /* If the input is a justified modular type, we need to extract the actual
4565 object before converting it to any other type with the exceptions of an
4566 unconstrained array or of a mere type variant. It is useful to avoid the
4567 extraction and conversion in the type variant case because it could end
4568 up replacing a VAR_DECL expr by a constructor and we might be about the
4569 take the address of the result. */
4576 /* If converting to a type that contains a template, convert to the data
4577 type and then build the template. */
4579 {
4584 /* If the source already has a template, get a reference to the
4585 associated array only, as we are going to rebuild a template
4586 for the target type anyway. */
4595 }
4597 /* There are some cases of expressions that we process specially. */
4599 {
4604 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
4605 conversion in gnat_expand_expr. NULL_EXPR does not represent
4606 and actual value, so no conversion is needed. */
4612 /* If we are converting a STRING_CST to another constrained array type,
4613 just make a new one in the proper type. */
4617 {
4621 }
4625 /* If we are converting a VECTOR_CST to a mere variant type, just make
4626 a new one in the proper type. */
4628 {
4632 }
4635 /* If we are converting a CONSTRUCTOR to a mere variant type, just make
4636 a new one in the proper type. */
4638 {
4643 }
4645 /* Likewise for a conversion between original and packable version, or
4646 conversion between types of the same size and with the same list of
4647 fields, but we have to work harder to preserve type consistency. */
4653 {
4662 /* Whether we need to clear TREE_CONSTANT et al. on the output
4663 constructor when we convert in place. */
4667 {
4668 /* We expect only simple constructors. */
4671 /* The field must be the same. */
4677 /* If packing has made this field a bitfield and the input
4678 value couldn't be emitted statically any more, we need to
4679 clear TREE_CONSTANT on our output. */
4689 }
4691 /* If we have been able to match and convert all the input fields
4692 to their output type, convert in place now. We'll fallback to a
4693 view conversion downstream otherwise. */
4695 {
4702 }
4703 }
4705 /* Likewise for a conversion between array type and vector type with a
4706 compatible representative array. */
4710 etype))
4711 {
4716 tree value;
4718 /* Build a VECTOR_CST from a *constant* array constructor. */
4720 {
4723 /* Iterate through elements and check if all constructor
4724 elements are *_CSTs. */
4727 {
4730 }
4735 }
4737 /* Otherwise, build a regular vector constructor. */
4740 {
4743 }
4748 }
4752 /* First retrieve the underlying array. */
4759 {
4760 /* GCC 4.x is very sensitive to type consistency overall, and view
4761 conversions thus are very frequent. Even though just "convert"ing
4762 the inner operand to the output type is fine in most cases, it
4763 might expose unexpected input/output type mismatches in special
4764 circumstances so we avoid such recursive calls when we can. */
4767 /* If we are converting back to the original type, we can just
4768 lift the input conversion. This is a common occurrence with
4769 switches back-and-forth amongst type variants. */
4773 /* Otherwise, if we're converting between two aggregate or vector
4774 types, we might be allowed to substitute the VIEW_CONVERT_EXPR
4775 target type in place or to just convert the inner expression. */
4778 {
4779 /* If we are converting between mere variants, we can just
4780 substitute the VIEW_CONVERT_EXPR in place. */
4784 /* Otherwise, we may just bypass the input view conversion unless
4785 one of the types is a fat pointer, which is handled by
4786 specialized code below which relies on exact type matching. */
4790 }
4793 }
4797 }
4799 /* Check for converting to a pointer to an unconstrained array. */
4803 /* If we are converting between two aggregate or vector types that are mere
4804 variants, just make a VIEW_CONVERT_EXPR. Likewise when we are converting
4805 to a vector type from its representative array type. */
4812 etype)))
4815 /* If we are converting between tagged types, try to upcast properly. */
4818 {
4826 }
4828 /* If we are converting from a smaller form of record type back to it, just
4829 make a VIEW_CONVERT_EXPR. But first pad the expression to have the same
4830 size on both sides. */
4833 {
4836 expr);
4838 }
4840 /* In all other cases of related types, make a NOP_EXPR. */
4845 {
4860 /* ... fall through ... */
4864 /* If we are converting an additive expression to an integer type
4865 with lower precision, be wary of the optimization that can be
4866 applied by convert_to_integer. There are 2 problematic cases:
4867 - if the first operand was originally of a biased type,
4868 because we could be recursively called to convert it
4869 to an intermediate type and thus rematerialize the
4870 additive operator endlessly,
4871 - if the expression contains a placeholder, because an
4872 intermediate conversion that changes the sign could
4873 be inserted and thus introduce an artificial overflow
4874 at compile time when the placeholder is substituted. */
4879 {
4886 }
4892 /* If converting between two thin pointers, adjust if needed to account
4893 for differing offsets from the base pointer, depending on whether
4894 there is a TYPE_UNCONSTRAINED_ARRAY attached to the record type. */
4896 {
4897 tree etype_pos
4901 tree type_pos
4913 }
4915 /* If converting fat pointer to normal or thin pointer, get the pointer
4916 to the array and then convert it. */
4918 expr
4928 {
4934 expr));
4936 }
4938 /* ... fall through ... */
4941 /* In these cases, assume the front-end has validated the conversion.
4942 If the conversion is valid, it will be a bit-wise conversion, so
4943 it can be viewed as an unchecked conversion. */
4947 /* This is a either a conversion between a tagged type and some
4948 subtype, which we have to mark as a UNION_TYPE because of
4949 overlapping fields or a conversion of an Unchecked_Union. */
4953 /* If the input is a VECTOR_TYPE, convert to the representative
4954 array type first. */
4956 {
4960 }
4962 /* If EXPR is a constrained array, take its address, convert it to a
4963 fat pointer, and then dereference it. Likewise if EXPR is a
4964 record containing both a template and a constrained array.
4965 Note that a record representing a justified modular type
4966 always represents a packed constrained array. */
4971 return
4972 build_unary_op
4978 /* Do something very similar for converting one unconstrained
4979 array to another. */
4981 return
4986 else
4994 }
4995 }
4997 /* Create an expression whose value is that of EXPR converted to the common
4998 index type, which is sizetype. EXPR is supposed to be in the base type
4999 of the GNAT index type. Calling it is equivalent to doing
5001 convert (sizetype, expr)
5003 but we try to distribute the type conversion with the knowledge that EXPR
5004 cannot overflow in its type. This is a best-effort approach and we fall
5005 back to the above expression as soon as difficulties are encountered.
5007 This is necessary to overcome issues that arise when the GNAT base index
5008 type and the GCC common index type (sizetype) don't have the same size,
5009 which is quite frequent on 64-bit architectures. In this case, and if
5010 the GNAT base index type is signed but the iteration type of the loop has
5011 been forced to unsigned, the loop scalar evolution engine cannot compute
5012 a simple evolution for the general induction variables associated with the
5013 array indices, because it will preserve the wrap-around semantics in the
5014 unsigned type of their "inner" part. As a result, many loop optimizations
5015 are blocked.
5017 The solution is to use a special (basic) induction variable that is at
5018 least as large as sizetype, and to express the aforementioned general
5019 induction variables in terms of this induction variable, eliminating
5020 the problematic intermediate truncation to the GNAT base index type.
5021 This is possible as long as the original expression doesn't overflow
5022 and if the middle-end hasn't introduced artificial overflows in the
5023 course of the various simplification it can make to the expression. */
5025 tree
5027 {
5031 /* If the type is unsigned, overflow is allowed so we cannot be sure that
5032 EXPR doesn't overflow. Keep it simple if optimization is disabled. */
5037 {
5039 /* The main effect of the function: replace a loop parameter with its
5040 associated special induction variable. */
5045 CASE_CONVERT:
5046 {
5048 /* Bail out as soon as we suspect some sort of type frobbing. */
5052 }
5054 /* ... fall through ... */
5078 }
5081 }
5082 \f
5083 /* Remove all conversions that are done in EXP. This includes converting
5084 from a padded type or to a justified modular type. If TRUE_ADDRESS
5085 is true, always return the address of the containing object even if
5086 the address is not bit-aligned. */
5088 tree
5090 {
5092 {
5097 return
5106 CASE_CONVERT:
5113 }
5116 }
5117 \f
5118 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
5119 refers to the underlying array. If it has TYPE_CONTAINS_TEMPLATE_P,
5120 likewise return an expression pointing to the underlying array. */
5122 tree
5124 {
5129 {
5132 {
5140 {
5141 tree op1
5144 NULL_TREE,
5147 tree op2
5150 NULL_TREE,
5157 }
5158 else
5159 {
5166 }
5167 }
5176 /* If this is a padded type and it contains a template, convert to the
5177 unpadded type first. */
5181 {
5184 }
5187 {
5193 /* If the array type is padded, convert to the unpadded type. */
5196 }
5201 }
5204 }
5205 \f
5206 /* Return true if EXPR is an expression that can be folded as an operand
5207 of a VIEW_CONVERT_EXPR. See ada-tree.h for a complete rationale. */
5209 static bool
5211 {
5214 /* The folder will fold NOP_EXPRs between integral types with the same
5215 precision (in the middle-end's sense). We cannot allow it if the
5216 types don't have the same precision in the Ada sense as well. */
5223 /* Defer to the folder for non-integral conversions. */
5227 /* Only fold conversions that preserve both precisions. */
5233 }
5235 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
5236 If NOTRUNC_P is true, truncation operations should be suppressed.
5238 Special care is required with (source or target) integral types whose
5239 precision is not equal to their size, to make sure we fetch or assign
5240 the value bits whose location might depend on the endianness, e.g.
5242 Rmsize : constant := 8;
5243 subtype Int is Integer range 0 .. 2 ** Rmsize - 1;
5245 type Bit_Array is array (1 .. Rmsize) of Boolean;
5246 pragma Pack (Bit_Array);
5248 function To_Bit_Array is new Unchecked_Conversion (Int, Bit_Array);
5250 Value : Int := 2#1000_0001#;
5251 Vbits : Bit_Array := To_Bit_Array (Value);
5253 we expect the 8 bits at Vbits'Address to always contain Value, while
5254 their original location depends on the endianness, at Value'Address
5255 on a little-endian architecture but not on a big-endian one. */
5257 tree
5259 {
5265 /* If the expression is already of the right type, we are done. */
5269 /* If both types types are integral just do a normal conversion.
5270 Likewise for a conversion to an unconstrained array. */
5280 {
5282 {
5287 }
5290 {
5296 }
5297 else
5299 }
5301 /* If we are converting to an integral type whose precision is not equal
5302 to its size, first unchecked convert to a record type that contains an
5303 field of the given precision. Then extract the field. */
5308 {
5315 else
5328 }
5330 /* Similarly if we are converting from an integral type whose precision is
5331 not equal to its size, first copy into a field of the given precision
5332 and unchecked convert the record type. */
5337 {
5346 else
5360 }
5362 /* If we are converting from a scalar type to a type with a different size,
5363 we need to pad to have the same size on both sides.
5365 ??? We cannot do it unconditionally because unchecked conversions are
5366 used liberally by the front-end to implement polymorphism, e.g. in:
5368 S191s : constant ada__tags__addr_ptr := ada__tags__addr_ptr!(S190s);
5369 return p___size__4 (p__object!(S191s.all));
5371 so we skip all expressions that are references. */
5376 {
5378 {
5381 expr);
5383 }
5384 else
5385 {
5391 }
5392 }
5394 /* We have a special case when we are converting between two unconstrained
5395 array types. In that case, take the address, convert the fat pointer
5396 types, and dereference. */
5401 expr)));
5403 /* Another special case is when we are converting to a vector type from its
5404 representative array type; this a regular conversion. */
5408 etype))
5411 else
5412 {
5418 else
5420 }
5422 /* If the result is an integral type whose precision is not equal to its
5423 size, sign- or zero-extend the result. We need not do this if the input
5424 is an integral type of the same precision and signedness or if the output
5425 is a biased type or if both the input and output are unsigned. */
5438 {
5439 tree base_type
5441 tree shift_expr
5444 bitsize_int
5447 expr
5452 shift_expr),
5453 shift_expr));
5454 }
5456 /* An unchecked conversion should never raise Constraint_Error. The code
5457 below assumes that GCC's conversion routines overflow the same way that
5458 the underlying hardware does. This is probably true. In the rare case
5459 when it is false, we can rely on the fact that such conversions are
5460 erroneous anyway. */
5464 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
5465 show no longer constant. */
5468 OEP_ONLY_CONST))
5472 }
5473 \f
5474 /* Return the appropriate GCC tree code for the specified GNAT_TYPE,
5475 the latter being a record type as predicated by Is_Record_Type. */
5477 enum tree_code
5479 {
5482 /* Return UNION_TYPE if it's an Unchecked_Union whose non-discriminant
5483 fields are all in the variant part. Otherwise, return RECORD_TYPE. */
5488 component_list
5498 }
5500 /* Return true if GNAT_TYPE is a "double" floating-point type, i.e. whose
5501 size is equal to 64 bits, or an array of such a type. Set ALIGN_CLAUSE
5502 according to the presence of an alignment clause on the type or, if it
5503 is an array, on the component type. */
5505 bool
5507 {
5513 {
5517 }
5526 }
5528 /* Return true if GNAT_TYPE is a "double" or larger scalar type, i.e. whose
5529 size is greater or equal to 64 bits, or an array of such a type. Set
5530 ALIGN_CLAUSE according to the presence of an alignment clause on the
5531 type or, if it is an array, on the component type. */
5533 bool
5535 {
5541 {
5545 }
5554 }
5556 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
5557 component of an aggregate type. */
5559 bool
5561 {
5562 /* If the type is passed by reference, we may have pointers to the
5563 component so it cannot be made non-aliased. */
5567 /* We used to say that any component of aggregate type is aliased
5568 because the front-end may take 'Reference of it. The front-end
5569 has been enhanced in the meantime so as to use a renaming instead
5570 in most cases, but the back-end can probably take the address of
5571 such a component too so we go for the conservative stance.
5573 For instance, we might need the address of any array type, even
5574 if normally passed by copy, to construct a fat pointer if the
5575 component is used as an actual for an unconstrained formal.
5577 Likewise for record types: even if a specific record subtype is
5578 passed by copy, the parent type might be passed by ref (e.g. if
5579 it's of variable size) and we might take the address of a child
5580 component to pass to a parent formal. We have no way to check
5581 for such conditions here. */
5586 }
5588 /* Return true if TYPE is a smaller form of ORIG_TYPE. */
5590 bool
5592 {
5595 /* We're not interested in variants here. */
5599 /* Like a variant, a packable version keeps the original TYPE_NAME. */
5610 }
5612 /* Perform final processing on global variables. */
5616 void
5618 {
5620 tree iter;
5622 /* If we have declared types as used at the global level, insert them in
5623 the global hash table. We use a dummy variable for this purpose. */
5625 {
5630 dummy_global
5632 void_type_node);
5639 {
5642 }
5643 }
5645 /* Output debug information for all global type declarations first. This
5646 ensures that global types whose compilation hasn't been finalized yet,
5647 for example pointers to Taft amendment types, have their compilation
5648 finalized in the right context. */
5653 /* Proceed to optimize and emit assembly. */
5656 /* After cgraph has had a chance to emit everything that's going to
5657 be emitted, output debug information for the rest of globals. */
5659 {
5665 }
5666 }
5668 /* ************************************************************************
5669 * * GCC builtins support *
5670 * ************************************************************************ */
5672 /* The general scheme is fairly simple:
5674 For each builtin function/type to be declared, gnat_install_builtins calls
5675 internal facilities which eventually get to gnat_push_decl, which in turn
5676 tracks the so declared builtin function decls in the 'builtin_decls' global
5677 datastructure. When an Intrinsic subprogram declaration is processed, we
5678 search this global datastructure to retrieve the associated BUILT_IN DECL
5679 node. */
5681 /* Search the chain of currently available builtin declarations for a node
5682 corresponding to function NAME (an IDENTIFIER_NODE). Return the first node
5683 found, if any, or NULL_TREE otherwise. */
5684 tree
5686 {
5688 tree decl;
5695 }
5697 /* The code below eventually exposes gnat_install_builtins, which declares
5698 the builtin types and functions we might need, either internally or as
5699 user accessible facilities.
5701 ??? This is a first implementation shot, still in rough shape. It is
5702 heavily inspired from the "C" family implementation, with chunks copied
5703 verbatim from there.
5705 Two obvious TODO candidates are
5706 o Use a more efficient name/decl mapping scheme
5707 o Devise a middle-end infrastructure to avoid having to copy
5708 pieces between front-ends. */
5710 /* ----------------------------------------------------------------------- *
5711 * BUILTIN ELEMENTARY TYPES *
5712 * ----------------------------------------------------------------------- */
5714 /* Standard data types to be used in builtin argument declarations. */
5716 enum c_tree_index
5717 {
5719 CTI_STRING_TYPE,
5720 CTI_CONST_STRING_TYPE,
5722 CTI_MAX
5723 };
5727 #define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
5728 #define string_type_node c_global_trees[CTI_STRING_TYPE]
5729 #define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
5731 /* ??? In addition some attribute handlers, we currently don't support a
5732 (small) number of builtin-types, which in turns inhibits support for a
5733 number of builtin functions. */
5734 #define wint_type_node void_type_node
5735 #define intmax_type_node void_type_node
5736 #define uintmax_type_node void_type_node
5738 /* Build the void_list_node (void_type_node having been created). */
5740 static tree
5742 {
5745 }
5747 /* Used to help initialize the builtin-types.def table. When a type of
5748 the correct size doesn't exist, use error_mark_node instead of NULL.
5749 The later results in segfaults even when a decl using the type doesn't
5750 get invoked. */
5752 static tree
5754 {
5757 }
5759 /* Build/push the elementary type decls that builtin functions/types
5760 will need. */
5762 static void
5764 {
5770 const_string_type_node
5773 }
5775 /* ----------------------------------------------------------------------- *
5776 * BUILTIN FUNCTION TYPES *
5777 * ----------------------------------------------------------------------- */
5779 /* Now, builtin function types per se. */
5781 enum c_builtin_type
5782 {
5783 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5784 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5785 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5786 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5787 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5788 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5789 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5790 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
5791 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
5792 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8) NAME,
5793 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5794 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5795 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5796 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5797 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5798 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
5799 NAME,
5800 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5802 #undef DEF_PRIMITIVE_TYPE
5803 #undef DEF_FUNCTION_TYPE_0
5804 #undef DEF_FUNCTION_TYPE_1
5805 #undef DEF_FUNCTION_TYPE_2
5806 #undef DEF_FUNCTION_TYPE_3
5807 #undef DEF_FUNCTION_TYPE_4
5808 #undef DEF_FUNCTION_TYPE_5
5809 #undef DEF_FUNCTION_TYPE_6
5810 #undef DEF_FUNCTION_TYPE_7
5811 #undef DEF_FUNCTION_TYPE_8
5812 #undef DEF_FUNCTION_TYPE_VAR_0
5813 #undef DEF_FUNCTION_TYPE_VAR_1
5814 #undef DEF_FUNCTION_TYPE_VAR_2
5815 #undef DEF_FUNCTION_TYPE_VAR_3
5816 #undef DEF_FUNCTION_TYPE_VAR_4
5817 #undef DEF_FUNCTION_TYPE_VAR_5
5818 #undef DEF_POINTER_TYPE
5819 BT_LAST
5820 };
5824 /* A temporary array used in communication with def_fn_type. */
5827 /* A helper function for install_builtin_types. Build function type
5828 for DEF with return type RET and N arguments. If VAR is true, then the
5829 function should be variadic after those N arguments.
5831 Takes special care not to ICE if any of the types involved are
5832 error_mark_node, which indicates that said type is not in fact available
5833 (see builtin_type_for_size). In which case the function type as a whole
5834 should be error_mark_node. */
5836 static void
5838 {
5839 tree t;
5846 {
5852 }
5859 else
5862 egress:
5865 }
5867 /* Build the builtin function types and install them in the builtin_types
5868 array for later use in builtin function decls. */
5870 static void
5872 {
5873 tree va_list_ref_type_node;
5874 tree va_list_arg_type_node;
5877 {
5880 }
5881 else
5882 {
5885 }
5887 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5888 builtin_types[ENUM] = VALUE;
5889 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5890 def_fn_type (ENUM, RETURN, 0, 0);
5891 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5892 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5893 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5894 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5895 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5896 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5897 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5898 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5899 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5900 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5901 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5902 ARG6) \
5903 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5904 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5905 ARG6, ARG7) \
5906 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5907 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5908 ARG6, ARG7, ARG8) \
5909 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5910 ARG7, ARG8);
5911 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5912 def_fn_type (ENUM, RETURN, 1, 0);
5913 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5914 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5915 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5916 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5917 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5918 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5919 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5920 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5921 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5922 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5923 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5924 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5928 #undef DEF_PRIMITIVE_TYPE
5929 #undef DEF_FUNCTION_TYPE_1
5930 #undef DEF_FUNCTION_TYPE_2
5931 #undef DEF_FUNCTION_TYPE_3
5932 #undef DEF_FUNCTION_TYPE_4
5933 #undef DEF_FUNCTION_TYPE_5
5934 #undef DEF_FUNCTION_TYPE_6
5935 #undef DEF_FUNCTION_TYPE_VAR_0
5936 #undef DEF_FUNCTION_TYPE_VAR_1
5937 #undef DEF_FUNCTION_TYPE_VAR_2
5938 #undef DEF_FUNCTION_TYPE_VAR_3
5939 #undef DEF_FUNCTION_TYPE_VAR_4
5940 #undef DEF_FUNCTION_TYPE_VAR_5
5941 #undef DEF_POINTER_TYPE
5943 }
5945 /* ----------------------------------------------------------------------- *
5946 * BUILTIN ATTRIBUTES *
5947 * ----------------------------------------------------------------------- */
5949 enum built_in_attribute
5950 {
5951 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5952 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5953 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5954 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5955 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5957 #undef DEF_ATTR_NULL_TREE
5958 #undef DEF_ATTR_INT
5959 #undef DEF_ATTR_STRING
5960 #undef DEF_ATTR_IDENT
5961 #undef DEF_ATTR_TREE_LIST
5962 ATTR_LAST
5963 };
5967 static void
5969 {
5970 /* Fill in the built_in_attributes array. */
5971 #define DEF_ATTR_NULL_TREE(ENUM) \
5972 built_in_attributes[(int) ENUM] = NULL_TREE;
5973 #define DEF_ATTR_INT(ENUM, VALUE) \
5974 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5975 #define DEF_ATTR_STRING(ENUM, VALUE) \
5976 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5977 #define DEF_ATTR_IDENT(ENUM, STRING) \
5978 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5979 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5980 built_in_attributes[(int) ENUM] \
5981 = tree_cons (built_in_attributes[(int) PURPOSE], \
5982 built_in_attributes[(int) VALUE], \
5983 built_in_attributes[(int) CHAIN]);
5985 #undef DEF_ATTR_NULL_TREE
5986 #undef DEF_ATTR_INT
5987 #undef DEF_ATTR_STRING
5988 #undef DEF_ATTR_IDENT
5989 #undef DEF_ATTR_TREE_LIST
5990 }
5992 /* Handle a "const" attribute; arguments as in
5993 struct attribute_spec.handler. */
5995 static tree
5999 {
6002 else
6006 }
6008 /* Handle a "nothrow" attribute; arguments as in
6009 struct attribute_spec.handler. */
6011 static tree
6015 {
6018 else
6022 }
6024 /* Handle a "pure" attribute; arguments as in
6025 struct attribute_spec.handler. */
6027 static tree
6030 {
6033 /* ??? TODO: Support types. */
6034 else
6035 {
6039 }
6042 }
6044 /* Handle a "no vops" attribute; arguments as in
6045 struct attribute_spec.handler. */
6047 static tree
6051 {
6055 }
6057 /* Helper for nonnull attribute handling; fetch the operand number
6058 from the attribute argument list. */
6060 static bool
6062 {
6063 /* Verify the arg number is a constant. */
6070 }
6072 /* Handle the "nonnull" attribute. */
6073 static tree
6077 {
6081 /* If no arguments are specified, all pointer arguments should be
6082 non-null. Verify a full prototype is given so that the arguments
6083 will have the correct types when we actually check them later. */
6085 {
6087 {
6090 }
6092 }
6094 /* Argument list specified. Verify that each argument number references
6095 a pointer argument. */
6097 {
6101 {
6106 }
6109 {
6110 function_args_iterator iter;
6111 tree argument;
6115 {
6119 }
6123 {
6129 }
6132 {
6138 }
6139 }
6140 }
6143 }
6145 /* Handle a "sentinel" attribute. */
6147 static tree
6150 {
6152 {
6157 }
6158 else
6159 {
6161 {
6166 }
6167 }
6170 {
6174 {
6177 }
6178 else
6179 {
6181 {
6184 }
6185 }
6186 }
6189 }
6191 /* Handle a "noreturn" attribute; arguments as in
6192 struct attribute_spec.handler. */
6194 static tree
6197 {
6200 /* See FIXME comment in c_common_attribute_table. */
6206 = build_pointer_type
6209 else
6210 {
6214 }
6217 }
6219 /* Handle a "leaf" attribute; arguments as in
6220 struct attribute_spec.handler. */
6222 static tree
6226 {
6228 {
6231 }
6233 {
6236 }
6239 }
6241 /* Handle a "malloc" attribute; arguments as in
6242 struct attribute_spec.handler. */
6244 static tree
6247 {
6251 else
6252 {
6256 }
6259 }
6261 /* Fake handler for attributes we don't properly support. */
6263 tree
6269 {
6271 }
6273 /* Handle a "type_generic" attribute. */
6275 static tree
6279 {
6280 /* Ensure we have a function type. */
6283 /* Ensure we have a variadic function. */
6287 }
6289 /* Handle a "vector_size" attribute; arguments as in
6290 struct attribute_spec.handler. */
6292 static tree
6296 {
6306 {
6310 }
6312 /* Get the vector size (in bytes). */
6315 /* We need to provide for vector pointers, vector arrays, and
6316 functions returning vectors. For example:
6318 __attribute__((vector_size(16))) short *foo;
6320 In this case, the mode is SI, but the type being modified is
6321 HI, so we need to look further. */
6328 /* Get the mode of the type being modified. */
6339 {
6343 }
6346 {
6349 }
6352 {
6355 }
6357 /* Calculate how many units fit in the vector. */
6360 {
6363 }
6367 /* Build back pointers if needed. */
6371 }
6373 /* Handle a "vector_type" attribute; arguments as in
6374 struct attribute_spec.handler. */
6376 static tree
6380 {
6381 /* Vector representative type and size. */
6385 /* Vector size in bytes and number of units. */
6388 /* Vector element type and mode. */
6389 tree elem_type;
6395 {
6399 }
6401 /* Silently punt on variable sizes. We can't make vector types for them,
6402 need to ignore them on front-end generated subtypes of unconstrained
6403 bases, and this attribute is for binding implementors, not end-users, so
6404 we should never get there from legitimate explicit uses. */
6409 /* Get the element type/mode and check this is something we know
6410 how to make vectors of. */
6422 {
6426 }
6428 /* Sanity check the vector size and element type consistency. */
6433 {
6436 }
6439 {
6442 }
6446 {
6449 }
6451 /* Build the vector type and replace. */
6457 }
6459 /* ----------------------------------------------------------------------- *
6460 * BUILTIN FUNCTIONS *
6461 * ----------------------------------------------------------------------- */
6463 /* Worker for DEF_BUILTIN. Possibly define a builtin function with one or two
6464 names. Does not declare a non-__builtin_ function if flag_no_builtin, or
6465 if nonansi_p and flag_no_nonansi_builtin. */
6467 static void
6475 {
6476 tree decl;
6479 /* Preserve an already installed decl. It most likely was setup in advance
6480 (e.g. as part of the internal builtins) for specific reasons. */
6491 fnattrs);
6493 /* ??? This is normally further controlled by command-line options
6494 like -fno-builtin, but we don't have them for Ada. */
6499 }
6504 /* Install what the common builtins.def offers. */
6506 static void
6508 {
6509 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
6510 NONANSI_P, ATTRS, IMPLICIT, COND) \
6511 if (NAME && COND) \
6512 def_builtin_1 (ENUM, NAME, CLASS, \
6513 builtin_types[(int) TYPE], \
6514 builtin_types[(int) LIBTYPE], \
6515 BOTH_P, FALLBACK_P, NONANSI_P, \
6516 built_in_attributes[(int) ATTRS], IMPLICIT);
6518 #undef DEF_BUILTIN
6519 }
6521 /* ----------------------------------------------------------------------- *
6522 * BUILTIN FUNCTIONS *
6523 * ----------------------------------------------------------------------- */
6525 /* Install the builtin functions we might need. */
6527 void
6529 {
6534 /* Install builtins used by generic middle-end pieces first. Some of these
6535 know about internal specificities and control attributes accordingly, for
6536 instance __builtin_alloca vs no-throw and -fstack-check. We will ignore
6537 the generic definition from builtins.def. */
6540 /* Now, install the target specific builtins, such as the AltiVec family on
6541 ppc, and the common set as exposed by builtins.def. */
6544 }