| blob | 54815073e60c480b0c7c258cc17f56d3e8d0f800 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2018, 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 ****************************************************************************/
60 /* If nonzero, pretend we are allocating at global level. */
63 /* The default alignment of "double" floating-point types, i.e. floating
64 point types whose size is equal to 64 bits, or 0 if this alignment is
65 not specifically capped. */
68 /* The default alignment of "double" or larger scalar types, i.e. scalar
69 types whose size is greater or equal to 64 bits, or 0 if this alignment
70 is not specifically capped. */
73 /* True if floating-point arithmetics may use wider intermediate results. */
76 /* Tree nodes for the various types and decls we create. */
79 /* Functions to call for each of the possible raise reasons. */
82 /* Likewise, but with extra info for each of the possible raise reasons. */
85 /* Forward declarations for handlers of attributes. */
102 /* Fake handler for attributes we don't properly support, typically because
103 they'd require dragging a lot of the common-c front-end circuitry. */
106 /* Table of machine-independent internal attributes for Ada. We support
107 this minimal set of attributes to accommodate the needs of builtins. */
109 {
110 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
111 affects_type_identity, handler, exclude } */
145 /* ??? format and format_arg are heavy and not supported, which actually
146 prevents support for stdio builtins, which we however declare as part
147 of the common builtins.def contents. */
149 NULL },
151 NULL },
154 };
156 /* Associates a GNAT tree node to a GCC tree node. It is used in
157 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
158 of `save_gnu_tree' for more info. */
161 #define GET_GNU_TREE(GNAT_ENTITY) \
162 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id]
164 #define SET_GNU_TREE(GNAT_ENTITY,VAL) \
165 associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] = (VAL)
167 #define PRESENT_GNU_TREE(GNAT_ENTITY) \
168 (associate_gnat_to_gnu[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
170 /* Associates a GNAT entity to a GCC tree node used as a dummy, if any. */
173 #define GET_DUMMY_NODE(GNAT_ENTITY) \
174 dummy_node_table[(GNAT_ENTITY) - First_Node_Id]
176 #define SET_DUMMY_NODE(GNAT_ENTITY,VAL) \
177 dummy_node_table[(GNAT_ENTITY) - First_Node_Id] = (VAL)
179 #define PRESENT_DUMMY_NODE(GNAT_ENTITY) \
180 (dummy_node_table[(GNAT_ENTITY) - First_Node_Id] != NULL_TREE)
182 /* This variable keeps a table for types for each precision so that we only
183 allocate each of them once. Signed and unsigned types are kept separate.
185 Note that these types are only used when fold-const requests something
186 special. Perhaps we should NOT share these types; we'll see how it
187 goes later. */
190 /* Likewise for float types, but record these by mode. */
193 /* For each binding contour we allocate a binding_level structure to indicate
194 the binding depth. */
197 /* The binding level containing this one (the enclosing binding level). */
199 /* The BLOCK node for this level. */
200 tree block;
201 /* If nonzero, the setjmp buffer that needs to be updated for any
202 variable-sized definition within this context. */
203 tree jmpbuf_decl;
204 };
206 /* The binding level currently in effect. */
209 /* A chain of gnat_binding_level structures awaiting reuse. */
212 /* The context to be used for global declarations. */
215 /* An array of global declarations. */
218 /* An array of builtin function declarations. */
221 /* A chain of unused BLOCK nodes. */
224 /* A hash table of padded types. It is modelled on the generic type
225 hash table in tree.c, which must thus be used as a reference. */
228 {
229 hashval_t hash;
230 tree type;
231 };
234 {
238 static int
240 {
242 }
243 };
256 /* Linked list used as a queue to defer the initialization of the DECL_CONTEXT
257 of ..._DECL nodes and of the TYPE_CONTEXT of ..._TYPE nodes. */
258 struct deferred_decl_context_node
259 {
260 /* The ..._DECL node to work on. */
261 tree decl;
263 /* The corresponding entity's Scope. */
264 Entity_Id gnat_scope;
266 /* The value of force_global when DECL was pushed. */
269 /* The list of ..._TYPE nodes to propagate the context to. */
272 /* The next queue item. */
274 };
278 /* Defer the initialization of DECL's DECL_CONTEXT attribute, scheduling to
279 feed it with the elaboration of GNAT_SCOPE. */
283 /* Defer the initialization of TYPE's TYPE_CONTEXT attribute, scheduling to
284 feed it with the DECL_CONTEXT computed as part of N as soon as it is
285 computed. */
287 tree type);
288 \f
289 /* Initialize data structures of the utils.c module. */
291 void
293 {
294 /* Initialize the association of GNAT nodes to GCC trees. */
297 /* Initialize the association of GNAT nodes to GCC trees as dummies. */
300 /* Initialize the hash table of padded types. */
302 }
304 /* Destroy data structures of the utils.c module. */
306 void
308 {
309 /* Destroy the association of GNAT nodes to GCC trees. */
313 /* Destroy the association of GNAT nodes to GCC trees as dummies. */
317 /* Destroy the hash table of padded types. */
320 }
321 \f
322 /* GNAT_ENTITY is a GNAT tree node for an entity. Associate GNU_DECL, a GCC
323 tree node, with GNAT_ENTITY. If GNU_DECL is not a ..._DECL node, abort.
324 If NO_CHECK is true, the latter check is suppressed.
326 If GNU_DECL is zero, reset a previous association. */
328 void
330 {
331 /* Check that GNAT_ENTITY is not already defined and that it is being set
332 to something which is a decl. If that is not the case, this usually
333 means GNAT_ENTITY is defined twice, but occasionally is due to some
334 Gigi problem. */
340 }
342 /* GNAT_ENTITY is a GNAT tree node for an entity. Return the GCC tree node
343 that was associated with it. If there is no such tree node, abort.
345 In some cases, such as delayed elaboration or expressions that need to
346 be elaborated only once, GNAT_ENTITY is really not an entity. */
348 tree
350 {
353 }
355 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
357 bool
359 {
361 }
362 \f
363 /* Make a dummy type corresponding to GNAT_TYPE. */
365 tree
367 {
371 /* If there was no equivalent type (can only happen when just annotating
372 types) or underlying type, go back to the original type. */
376 /* If it there already a dummy type, use that one. Else make one. */
380 /* If this is a record, make a RECORD_TYPE or UNION_TYPE; else make
381 an ENUMERAL_TYPE. */
394 /* Create a debug type so that debug info consumers only see an unspecified
395 type. */
397 {
403 }
406 }
408 /* Return the dummy type that was made for GNAT_TYPE, if any. */
410 tree
412 {
414 }
416 /* Build dummy fat and thin pointer types whose designated type is specified
417 by GNAT_DESIG_TYPE/GNU_DESIG_TYPE and attach them to the latter. */
419 void
421 {
436 /* Build a stub DECL to trigger the special processing for fat pointer types
437 in gnat_pushdecl. */
440 gnu_fat_type);
448 /* Suppress debug info until after the type is completed. */
458 }
459 \f
460 /* Return true if we are in the global binding level. */
462 bool
464 {
466 }
468 /* Enter a new binding level. */
470 void
472 {
475 /* Reuse a struct for this binding level, if there is one. */
477 {
480 }
481 else
484 /* Use a free BLOCK, if any; otherwise, allocate one. */
486 {
490 }
491 else
494 /* Point the BLOCK we just made to its parent. */
502 /* Add this level to the front of the chain (stack) of active levels. */
506 }
508 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
509 and point FNDECL to this BLOCK. */
511 void
513 {
517 }
519 /* Set the jmpbuf_decl for the current binding level to DECL. */
521 void
523 {
525 }
527 /* Get the jmpbuf_decl, if any, for the current binding level. */
529 tree
531 {
533 }
535 /* Exit a binding level. Set any BLOCK into the current code group. */
537 void
539 {
546 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
547 are no variables free the block and merge its subblocks into those of its
548 parent block. Otherwise, add it to the list of its parent. */
550 ;
552 {
558 }
559 else
560 {
565 }
567 /* Free this binding structure. */
571 }
573 /* Exit a binding level and discard the associated BLOCK. */
575 void
577 {
584 /* Free this binding structure. */
588 }
589 \f
590 /* Set the context of TYPE and its parallel types (if any) to CONTEXT. */
592 static void
594 {
600 {
603 /* Give a context to the parallel types and their stub decl, if any.
604 Some parallel types seems to be present in multiple parallel type
605 chains, so don't mess with their context if they already have one. */
607 {
611 }
614 }
615 }
617 /* Return the innermost scope, starting at GNAT_NODE, we are be interested in
618 the debug info, or Empty if there is no such scope. If not NULL, set
619 IS_SUBPROGRAM to whether the returned entity is a subprogram. */
621 Entity_Id
623 {
624 Entity_Id gnat_entity;
632 else
636 {
638 {
644 /* If the scope is a subprogram, then just rely on
645 current_function_decl, so that we don't have to defer
646 anything. This is needed because other places rely on the
647 validity of the DECL_CONTEXT attribute of FUNCTION_DECL nodes. */
657 /* By default, we are not interested in this particular scope: go to
658 the outer one. */
660 }
663 }
666 }
668 /* If N is NULL, set TYPE's context to CONTEXT. Defer this to the processing
669 of N otherwise. */
671 static void
674 {
677 else
679 }
681 /* Return global_context, but create it first if need be. */
683 static tree
685 {
687 {
688 global_context
691 }
694 }
696 /* Record DECL as belonging to the current lexical scope and use GNAT_NODE
697 for location information and flag propagation. */
699 void
701 {
705 /* If explicitely asked to make DECL global or if it's an imported nested
706 object, short-circuit the regular Scope-based context computation. */
708 {
709 /* Rely on the GNAT scope, or fallback to the current_function_decl if
710 the GNAT scope reached the global scope, if it reached a subprogram
711 or the declaration is a subprogram or a variable (for them we skip
712 intermediate context types because the subprogram body elaboration
713 machinery and the inliner both expect a subprogram context).
715 Falling back to current_function_decl is necessary for implicit
716 subprograms created by gigi, such as the elaboration subprograms. */
718 const Entity_Id gnat_scope
722 && !context_is_subprogram
725 /* Always assume the scope has not been elaborated, thus defer the
726 context propagation to the time its elaboration will be
727 available. */
728 deferred_decl_context
731 /* External declarations (when force_global > 0) may not be in a
732 local context. */
735 }
737 /* If either we are forced to be in global mode or if both the GNAT scope and
738 the current_function_decl did not help in determining the context, use the
739 global scope. */
743 /* Functions imported in another function are not really nested.
744 For really nested functions mark them initially as needing
745 a static chain for uses of that flag before unnesting;
746 lower_nested_functions will then recompute it. */
749 && context
759 /* Set the location of DECL and emit a declaration for it. */
765 /* Put the declaration on the list. The list of declarations is in reverse
766 order. The list will be reversed later. Put global declarations in the
767 globals list and local ones in the current block. But skip TYPE_DECLs
768 for UNCONSTRAINED_ARRAY_TYPE in both cases, as they will cause trouble
769 with the debugger and aren't needed anyway. */
772 {
773 /* External declarations must go to the binding level they belong to.
774 This will make corresponding imported entities are available in the
775 debugger at the proper time. */
782 else
783 {
786 }
787 }
789 /* For the declaration of a type, set its name either if it isn't already
790 set or if the previous type name was not derived from a source name.
791 We'd rather have the type named with a real name and all the pointer
792 types to the same object have the same node, except when the names are
793 both derived from source names. */
795 {
798 /* Array and pointer types aren't tagged types in the C sense so we need
799 to generate a typedef in DWARF for them and make sure it is preserved,
800 unless the type is artificial. */
804 ;
805 /* For array and pointer types, create the DECL_ORIGINAL_TYPE that will
806 generate the typedef in DWARF. Also do that for fat pointer types
807 because, even though they are tagged types in the C sense, they are
808 still XUP types attached to the base array type at this point. */
813 {
818 deferred_decl_context);
824 else
826 /* Array types need to have a name so that they can be related to
827 their GNAT encodings. */
831 }
835 ;
836 else
839 /* Propagate the name to all the variants, this is needed for the type
840 qualifiers machinery to work properly (see check_qualified_type).
841 Also propagate the context to them. Note that it will be propagated
842 to all parallel types too thanks to gnat_set_type_context. */
845 /* ??? Because of the previous kludge, we can have variants of fat
846 pointer types with different names. */
850 {
854 deferred_decl_context);
855 }
856 }
857 }
858 \f
859 /* Create a record type that contains a SIZE bytes long field of TYPE with a
860 starting bit position so that it is aligned to ALIGN bits, and leaving at
861 least ROOM bytes free before the field. BASE_ALIGN is the alignment the
862 record is guaranteed to get. GNAT_NODE is used for the position of the
863 associated TYPE_DECL. */
865 tree
868 {
869 /* We will be crafting a record type with one field at a position set to be
870 the next multiple of ALIGN past record'address + room bytes. We use a
871 record placeholder to express record'address. */
875 tree record_addr_st
878 /* The diagram below summarizes the shape of what we manipulate:
880 <--------- pos ---------->
881 { +------------+-------------+-----------------+
882 record =>{ |############| ... | field (type) |
883 { +------------+-------------+-----------------+
884 |<-- room -->|<- voffset ->|<---- size ----->|
885 o o
886 | |
887 record_addr vblock_addr
889 Every length is in sizetype bytes there, except "pos" which has to be
890 set as a bit position in the GCC tree for the record. */
900 /* Compute VOFFSET and then POS. The next byte position multiple of some
901 alignment after some address is obtained by "and"ing the alignment minus
902 1 with the two's complement of the address. */
907 /* POS = (ROOM + VOFFSET) * BIT_PER_UNIT, in bitsizetype. */
911 bitsize_unit_node);
913 /* Craft the GCC record representation. We exceptionally do everything
914 manually here because 1) our generic circuitry is not quite ready to
915 handle the complex position/size expressions we are setting up, 2) we
916 have a strong simplifying factor at hand: we know the maximum possible
917 value of voffset, and 3) we have to set/reset at least the sizes in
918 accordance with this maximum value anyway, as we need them to convey
919 what should be "alloc"ated for this type.
921 Use -1 as the 'addressable' indication for the field to prevent the
922 creation of a bitfield. We don't need one, it would have damaging
923 consequences on the alignment computation, and create_field_decl would
924 make one without this special argument, for instance because of the
925 complex position expression. */
936 bitsize_unit_node),
945 /* Declare it now since it will never be declared otherwise. This is
946 necessary to ensure that its subtrees are properly marked. */
950 }
952 /* TYPE is a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE that is being used
953 as the field type of a packed record if IN_RECORD is true, or as the
954 component type of a packed array if IN_RECORD is false. See if we can
955 rewrite it either as a type that has non-BLKmode, which we can pack
956 tighter in the packed record case, or as a smaller type with at most
957 MAX_ALIGN alignment if the value is non-zero. If so, return the new
958 type; if not, return the original type. */
960 tree
962 {
968 /* No point in doing anything if the size is zero. */
974 /* Copy the name and flags from the old type to that of the new.
975 Note that we rely on the pointer equality created here for
976 TYPE_NAME to look through conversions in various places. */
984 /* If we are in a record and have a small size, set the alignment to
985 try for an integral mode. Otherwise set it to try for a smaller
986 type with BLKmode. */
988 {
992 }
993 else
994 {
995 /* Do not try to shrink the size if the RM size is not constant. */
1000 /* Round the RM size up to a unit boundary to get the minimal size
1001 for a BLKmode record. Give up if it's already the size and we
1002 don't need to lower the alignment. */
1012 }
1016 /* Now copy the fields, keeping the position and size as we don't want
1017 to change the layout by propagating the packedness downwards. */
1020 {
1029 /* However, for the last field in a not already packed record type
1030 that is of an aggregate type, we need to use the RM size in the
1031 packable version of the record type, see finish_record_type. */
1039 else
1042 new_field
1055 }
1057 /* If this is a padding record, we never want to make the size smaller
1058 than what was specified. For QUAL_UNION_TYPE, also copy the size. */
1060 {
1064 }
1065 else
1066 {
1069 }
1080 /* Try harder to get a packable type if necessary, for example
1081 in case the record itself contains a BLKmode field. */
1087 /* If neither mode nor size nor alignment shrunk, return the old type. */
1092 }
1094 /* Return true if TYPE has an unsigned representation. This needs to be used
1095 when the representation of types whose precision is not equal to their size
1096 is manipulated based on the RM size. */
1100 {
1101 /* This is the common case. */
1105 /* See the E_Signed_Integer_Subtype case of gnat_to_gnu_entity. */
1111 }
1113 /* Given a type TYPE, return a new type whose size is appropriate for SIZE.
1114 If TYPE is the best type, return it. Otherwise, make a new type. We
1115 only support new integral and pointer types. FOR_BIASED is true if
1116 we are making a biased type. */
1118 tree
1120 {
1123 tree new_type;
1125 /* If size indicates an error, just return TYPE to avoid propagating
1126 the error. Likewise if it's too large to represent. */
1133 {
1135 /* Do not mess with boolean types that have foreign convention. */
1139 /* ... fall through ... */
1146 /* Integer types with precision 0 are forbidden. */
1150 /* Only do something if the type isn't a packed array type and doesn't
1151 already have the proper size and the size isn't too large. */
1159 /* The type should be an unsigned type if the original type is unsigned
1160 or if the lower bound is constant and non-negative or if the type is
1161 biased, see E_Signed_Integer_Subtype case of gnat_to_gnu_entity. */
1164 else
1169 /* Copy the name to show that it's essentially the same type and
1170 not a subrange type. */
1177 /* Do something if this is a fat pointer, in which case we
1178 may need to return the thin pointer. */
1180 {
1181 scalar_int_mode p_mode;
1185 return
1186 build_pointer_type_for_mode
1189 }
1193 /* Only do something if this is a thin pointer, in which case we
1194 may need to return the fat pointer. */
1196 return
1202 }
1205 }
1207 /* Return true iff the padded types are equivalent. */
1209 bool
1211 {
1220 /* We consider that the padded types are equivalent if they pad the same type
1221 and have the same size, alignment, RM size and storage order. Taking the
1222 mode into account is redundant since it is determined by the others. */
1223 return
1229 }
1231 /* Compute the hash value for the padded TYPE. */
1233 static hashval_t
1235 {
1236 hashval_t hashcode;
1238 hashcode
1245 }
1247 /* Look up the padded TYPE in the hash table and return its canonical version
1248 if it exists; otherwise, insert it into the hash table. */
1250 static tree
1252 {
1261 {
1266 }
1269 }
1271 /* Ensure that TYPE has SIZE and ALIGN. Make and return a new padded type
1272 if needed. We have already verified that SIZE and ALIGN are large enough.
1273 GNAT_ENTITY is used to name the resulting record and to issue a warning.
1274 IS_COMPONENT_TYPE is true if this is being done for the component type of
1275 an array. IS_USER_TYPE is true if the original type needs to be completed.
1276 DEFINITION is true if this type is being defined. SET_RM_SIZE is true if
1277 the RM size of the resulting type is to be set to SIZE too; in this case,
1278 the padded type is canonicalized before being returned. */
1280 tree
1284 {
1289 /* If TYPE is a padded type, see if it agrees with any size and alignment
1290 we were given. If so, return the original type. Otherwise, strip
1291 off the padding, since we will either be returning the inner type
1292 or repadding it. If no size or alignment is specified, use that of
1293 the original padded type. */
1295 {
1309 }
1311 /* If the size is either not being changed or is being made smaller (which
1312 is not done here and is only valid for bitfields anyway), show the size
1313 isn't changing. Likewise, clear the alignment if it isn't being
1314 changed. Then return if we aren't doing anything. */
1327 /* If requested, complete the original type and give it a name. */
1334 gnat_entity);
1336 /* We used to modify the record in place in some cases, but that could
1337 generate incorrect debugging information. So make a new record
1338 type and name. */
1342 /* ??? Padding types around packed array implementation types will be
1343 considered as root types in the array descriptor language hook (see
1344 gnat_get_array_descr_info). Give them the original packed array type
1345 name so that the one coming from sources appears in the debugging
1346 information. */
1359 bitsize_unit_node));
1361 /* If we are changing the alignment and the input type is a record with
1362 BLKmode and a small constant size, try to make a form that has an
1363 integral mode. This might allow the padding record to also have an
1364 integral mode, which will be much more efficient. There is no point
1365 in doing so if a size is specified unless it is also a small constant
1366 size and it is incorrect to do so if we cannot guarantee that the mode
1367 will be naturally aligned since the field must always be addressable.
1369 ??? This might not always be a win when done for a stand-alone object:
1370 since the nominal and the effective type of the object will now have
1371 different modes, a VIEW_CONVERT_EXPR will be required for converting
1372 between them and it might be hard to overcome afterwards, including
1373 at the RTL level when the stand-alone object is accessed as a whole. */
1381 && (!size
1384 {
1389 }
1391 /* Now create the field with the original size. */
1396 /* We will output additional debug info manually below. */
1399 /* Set the RM size if requested. */
1401 {
1404 /* If the padded type is complete and has constant size, we canonicalize
1405 it by means of the hash table. This is consistent with the language
1406 semantics and ensures that gigi and the middle-end have a common view
1407 of these padded types. */
1409 {
1412 {
1415 }
1416 }
1417 }
1422 /* Unless debugging information isn't being written for the input type,
1423 write a record that shows what we are a subtype of and also make a
1424 variable that indicates our size, if still variable. */
1430 {
1434 /* A variable that holds the size is required even with no encoding since
1435 it will be referenced by debugging information attributes. At global
1436 level, we need a single variable across all translation units. */
1440 {
1441 /* Whether or not gnat_entity comes from source, this XVZ variable is
1442 is a compilation artifact. */
1443 size_unit
1449 }
1451 /* There is no need to show what we are a subtype of when outputting as
1452 few encodings as possible: regular debugging infomation makes this
1453 redundant. */
1455 {
1469 }
1470 }
1472 built:
1473 /* If a simple size was explicitly given, maybe issue a warning. */
1480 /* But don't do it if we are just annotating types and the type is tagged or
1481 concurrent, since these types aren't fully laid out in this mode. */
1483 {
1484 Entity_Id gnat_type
1485 = is_component_type
1490 }
1492 /* Take the original size as the maximum size of the input if there was an
1493 unconstrained record involved and round it up to the specified alignment,
1494 if one was specified, but only for aggregate types. */
1507 {
1508 Node_Id gnat_error_node;
1510 /* For a packed array, post the message on the original array type. */
1522 else
1525 /* Generate message only for entities that come from source, since
1526 if we have an entity created by expansion, the message will be
1527 generated for some other corresponding source entity. */
1529 {
1538 }
1539 }
1542 }
1544 /* Return true if padded TYPE was built with an RM size. */
1546 bool
1548 {
1549 /* This is required for the lookup. */
1560 /* The types built with an RM size are the canonicalized ones. */
1562 }
1564 /* Return a copy of the padded TYPE but with reverse storage order. */
1566 tree
1568 {
1570 {
1571 /* If the inner type is not scalar then the function does nothing. */
1575 }
1577 /* This is required for the canonicalization. */
1586 }
1587 \f
1588 /* Relate the alias sets of GNU_NEW_TYPE and GNU_OLD_TYPE according to OP.
1589 If this is a multi-dimensional array type, do this recursively.
1591 OP may be
1592 - ALIAS_SET_COPY: the new set is made a copy of the old one.
1593 - ALIAS_SET_SUPERSET: the new set is made a superset of the old one.
1594 - ALIAS_SET_SUBSET: the new set is made a subset of the old one. */
1596 void
1598 {
1599 /* Remove any padding from GNU_OLD_TYPE. It doesn't matter in the case
1600 of a one-dimensional array, since the padding has the same alias set
1601 as the field type, but if it's a multi-dimensional array, we need to
1602 see the inner types. */
1608 /* Unconstrained array types are deemed incomplete and would thus be given
1609 alias set 0. Retrieve the underlying array type. */
1611 gnu_old_type
1614 gnu_new_type
1623 {
1625 /* The alias set shouldn't be copied between array types with different
1626 aliasing settings because this can break the aliasing relationship
1627 between the array type and its element type. */
1639 {
1643 /* Do nothing if the alias sets conflict. This ensures that we
1644 never call record_alias_subset several times for the same pair
1645 or at all for alias set 0. */
1647 {
1650 else
1652 }
1653 }
1658 }
1661 }
1662 \f
1663 /* Record TYPE as a builtin type for Ada. NAME is the name of the type.
1664 ARTIFICIAL_P is true if the type was generated by the compiler. */
1666 void
1668 {
1677 }
1678 \f
1679 /* Finish constructing the character type CHAR_TYPE.
1681 In Ada character types are enumeration types and, as a consequence, are
1682 represented in the front-end by integral types holding the positions of
1683 the enumeration values as defined by the language, which means that the
1684 integral types are unsigned.
1686 Unfortunately the signedness of 'char' in C is implementation-defined
1687 and GCC even has the option -f[un]signed-char to toggle it at run time.
1688 Since GNAT's philosophy is to be compatible with C by default, to wit
1689 Interfaces.C.char is defined as a mere copy of Character, we may need
1690 to declare character types as signed types in GENERIC and generate the
1691 necessary adjustments to make them behave as unsigned types.
1693 The overall strategy is as follows: if 'char' is unsigned, do nothing;
1694 if 'char' is signed, translate character types of CHAR_TYPE_SIZE and
1695 character subtypes with RM_Size = Esize = CHAR_TYPE_SIZE into signed
1696 types. The idea is to ensure that the bit pattern contained in the
1697 Esize'd objects is not changed, even though the numerical value will
1698 be interpreted differently depending on the signedness. */
1700 void
1702 {
1706 /* Make a copy of a generic unsigned version since we'll modify it. */
1707 tree unsigned_char_type
1709 ? unsigned_char_type_node
1712 /* Create an unsigned version of the type and set it as debug type. */
1718 /* If this is a subtype, make the debug type a subtype of the debug type
1719 of the base type and convert literal RM bounds to unsigned. */
1721 {
1734 }
1736 /* Adjust the RM bounds of the original type to unsigned; that's especially
1737 important for types since they are implicit in this case. */
1740 }
1742 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1743 finish constructing the record type as a fat pointer type. */
1745 void
1747 {
1748 /* Make sure we can put it into a register. */
1752 /* Show what it really is. */
1755 /* Do not emit debug info for it since the types of its fields may still be
1756 incomplete at this point. */
1759 /* Force type_contains_placeholder_p to return true on it. Although the
1760 PLACEHOLDER_EXPRs are referenced only indirectly, this isn't a pointer
1761 type but the representation of the unconstrained array. */
1763 }
1765 /* Given a record type RECORD_TYPE and a list of FIELD_DECL nodes FIELD_LIST,
1766 finish constructing the record or union type. If REP_LEVEL is zero, this
1767 record has no representation clause and so will be entirely laid out here.
1768 If REP_LEVEL is one, this record has a representation clause and has been
1769 laid out already; only set the sizes and alignment. If REP_LEVEL is two,
1770 this record is derived from a parent record and thus inherits its layout;
1771 only make a pass on the fields to finalize them. DEBUG_INFO_P is true if
1772 additional debug info needs to be output for this type. */
1774 void
1777 {
1785 tree field;
1789 /* Always attach the TYPE_STUB_DECL for a record type. It is required to
1790 generate debug info and have a parallel type. */
1793 /* Globally initialize the record first. If this is a rep'ed record,
1794 that just means some initializations; otherwise, layout the record. */
1796 {
1806 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
1807 out just like a UNION_TYPE, since the size will be fixed. */
1810 }
1811 else
1812 {
1813 /* Ensure there isn't a size already set. There can be in an error
1814 case where there is a rep clause but all fields have errors and
1815 no longer have a position. */
1818 /* Ensure we use the traditional GCC layout for bitfields when we need
1819 to pack the record type or have a representation clause. The other
1820 possible layout (Microsoft C compiler), if available, would prevent
1821 efficient packing in almost all cases. */
1822 #ifdef TARGET_MS_BITFIELD_LAYOUT
1827 ATTR_FLAG_TYPE_IN_PLACE);
1828 #endif
1831 }
1833 /* At this point, the position and size of each field is known. It was
1834 either set before entry by a rep clause, or by laying out the type above.
1836 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
1837 to compute the Ada size; the GCC size and alignment (for rep'ed records
1838 that are not padding types); and the mode (for rep'ed records). We also
1839 clear the DECL_BIT_FIELD indication for the cases we know have not been
1840 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
1846 {
1850 tree this_ada_size;
1857 else
1860 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
1863 {
1866 /* In the general case, type alignment is required. */
1868 {
1869 /* The enclosing record type must be sufficiently aligned.
1870 Otherwise, if no alignment was specified for it and it
1871 has been laid out already, bump its alignment to the
1872 desired one if this is compatible with its size and
1873 maximum alignment, if any. */
1875 {
1878 }
1884 {
1888 }
1889 }
1891 /* In the non-strict alignment case, only byte alignment is. */
1896 }
1898 /* If we still have DECL_BIT_FIELD set at this point, we know that the
1899 field is technically not addressable. Except that it can actually
1900 be addressed if it is BLKmode and happens to be properly aligned. */
1906 /* A type must be as aligned as its most aligned field that is not
1907 a bit-field. But this is already enforced by layout_type. */
1913 {
1920 ada_size
1928 /* Since we know here that all fields are sorted in order of
1929 increasing bit position, the size of the record is one
1930 higher than the ending bit of the last field processed
1931 unless we have a rep clause, since in that case we might
1932 have a field outside a QUAL_UNION_TYPE that has a higher ending
1933 position. So use a MAX in that case. Also, if this field is a
1934 QUAL_UNION_TYPE, we need to take into account the previous size in
1935 the case of empty variants. */
1936 ada_size
1939 size
1946 }
1947 }
1952 /* We need to set the regular sizes if REP_LEVEL is one. */
1954 {
1955 /* If this is a padding record, we never want to make the size smaller
1956 than what was specified in it, if any. */
1960 tree size_unit = had_size_unit
1964 bitsize_unit_node));
1970 }
1972 /* We need to set the Ada size if REP_LEVEL is zero or one. */
1974 {
1975 /* Now set any of the values we've just computed that apply. */
1979 }
1981 /* We need to set the mode if REP_LEVEL is one or two. */
1983 {
1986 }
1988 /* Reset the TYPE_MAX_ALIGN field since it's private to gigi. */
1993 }
1995 /* Append PARALLEL_TYPE on the chain of parallel types of TYPE. If
1996 PARRALEL_TYPE has no context and its computation is not deferred yet, also
1997 propagate TYPE's context to PARALLEL_TYPE's or defer its propagation to the
1998 moment TYPE will get a context. */
2000 void
2002 {
2010 /* If PARALLEL_TYPE already has a context, we are done. */
2014 /* Otherwise, try to get one from TYPE's context. If so, simply propagate
2015 it to PARALLEL_TYPE. */
2019 /* Otherwise TYPE has not context yet. We know it will have one thanks to
2020 gnat_pushdecl and then its context will be propagated to PARALLEL_TYPE,
2021 so we have nothing to do in this case. */
2022 }
2024 /* Return true if TYPE has a parallel type. */
2026 static bool
2028 {
2032 }
2034 /* Wrap up compilation of RECORD_TYPE, i.e. output additional debug info
2035 associated with it. It need not be invoked directly in most cases as
2036 finish_record_type takes care of doing so. */
2038 void
2040 {
2042 tree field;
2044 /* If this is a padded type, the bulk of the debug info has already been
2045 generated for the field's type. */
2049 /* If the type already has a parallel type (XVS type), then we're done. */
2054 {
2055 /* We need to make an XVE/XVU record if any field has variable size,
2056 whether or not the record does. For example, if we have a union,
2057 it may be that all fields, rounded up to the alignment, have the
2058 same size, in which case we'll use that size. But the debug
2059 output routines (except Dwarf2) won't be able to output the fields,
2060 so we need to make the special record. */
2062 /* If a field has a non-constant qualifier, the record will have
2063 variable size too. */
2066 {
2069 }
2070 }
2072 /* If this record type is of variable size, make a parallel record type that
2073 will tell the debugger how the former is laid out (see exp_dbug.ads). */
2075 {
2076 tree new_record_type
2083 new_name
2097 /* Now scan all the fields, replacing each field with a new field
2098 corresponding to the new encoding. */
2101 {
2109 /* See how the position was modified from the last position.
2111 There are two basic cases we support: a value was added
2112 to the last position or the last position was rounded to
2113 a boundary and they something was added. Check for the
2114 first case first. If not, see if there is any evidence
2115 of rounding. If so, round the last position and retry.
2117 If this is a union, the position can be taken as zero. */
2120 else
2126 {
2132 }
2137 && tree_fits_uhwi_p
2139 {
2141 unsigned HOST_WIDE_INT addend
2143 align
2149 }
2151 {
2155 }
2157 /* If we can't compute a position, set it to zero.
2159 ??? We really should abort here, but it's too much work
2160 to get this correct for all cases. */
2164 /* See if this type is variable-sized and make a pointer type
2165 and indicate the indirection if so. Beware that the debug
2166 back-end may adjust the position computed above according
2167 to the alignment of the field type, i.e. the pointer type
2168 in this case, if we don't preventively counter that. */
2170 {
2173 {
2176 }
2178 }
2180 /* Make a new field name, if necessary. */
2182 {
2188 else
2192 }
2194 new_field
2200 /* If old_field is a QUAL_UNION_TYPE, take its size as being
2201 zero. The only time it's not the last field of the record
2202 is when there are other components at fixed positions after
2203 it (meaning there was a rep clause for every field) and we
2204 want to be able to encode them. */
2208 ? bitsize_zero_node
2211 }
2216 }
2217 }
2219 /* Utility function of above to merge LAST_SIZE, the previous size of a record
2220 with FIRST_BIT and SIZE that describe a field. SPECIAL is true if this
2221 represents a QUAL_UNION_TYPE in which case we must look for COND_EXPRs and
2222 replace a value of zero with the old size. If HAS_REP is true, we take the
2223 MAX of the end position of this field with LAST_SIZE. In all other cases,
2224 we use FIRST_BIT plus SIZE. Return an expression for the size. */
2226 static tree
2229 {
2231 tree new_size;
2234 {
2238 }
2240 else
2251 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
2252 when fed through substitute_in_expr) into thinking that a constant
2253 size is not constant. */
2258 }
2260 /* Return the bit position of FIELD, in bits from the start of the record,
2261 and fold it as much as possible. This is a tree of type bitsizetype. */
2263 static tree
2265 {
2271 else
2275 }
2277 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
2278 related by the addition of a constant. Return that constant if so. */
2280 static tree
2282 {
2289 {
2293 }
2294 else
2305 }
2307 /* Utility function of above to split a tree OP which may be a sum, into a
2308 constant part, which is returned, and a variable part, which is stored
2309 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
2310 bitsizetype. */
2312 static tree
2314 {
2315 /* Strip conversions in order to ease the tree traversal and maximize the
2316 potential for constant or plus/minus discovery. We need to be careful
2317 to always return and set *pvar to bitsizetype trees, but it's worth
2318 the effort. */
2324 {
2327 }
2329 {
2340 }
2341 else
2343 }
2344 \f
2345 /* Return a copy of TYPE but safe to modify in any way. */
2347 tree
2349 {
2352 /* Unshare the language-specific data. */
2354 {
2357 }
2359 /* And the contents of the language-specific slot if needed. */
2362 {
2367 }
2369 /* copy_node clears this field instead of copying it, because it is
2370 aliased with TREE_CHAIN. */
2380 }
2381 \f
2382 /* Return a subtype of sizetype with range MIN to MAX and whose
2383 TYPE_INDEX_TYPE is INDEX. GNAT_NODE is used for the position
2384 of the associated TYPE_DECL. */
2386 tree
2388 {
2389 /* First build a type for the desired range. */
2392 /* Then set the index type. */
2397 }
2399 /* Return a subtype of TYPE with range MIN to MAX. If TYPE is NULL,
2400 sizetype is used. */
2402 tree
2404 {
2405 tree range_type;
2410 /* First build a type with the base range. */
2414 /* Then set the actual range. */
2419 }
2420 \f
2421 /* Return a TYPE_DECL node suitable for the TYPE_STUB_DECL field of TYPE.
2422 NAME gives the name of the type to be used in the declaration. */
2424 tree
2426 {
2431 }
2433 /* Return a TYPE_DECL node for TYPE. NAME gives the name of the type to be
2434 used in the declaration. ARTIFICIAL_P is true if the declaration was
2435 generated by the compiler. DEBUG_INFO_P is true if we need to write
2436 debug information about this type. GNAT_NODE is used for the position
2437 of the decl. */
2439 tree
2441 Node_Id gnat_node)
2442 {
2444 bool is_named
2446 tree type_decl;
2448 /* Only the builtin TYPE_STUB_DECL should be used for dummy types. */
2451 /* If the type hasn't been named yet, we're naming it; preserve an existing
2452 TYPE_STUB_DECL that has been attached to it for some purpose. */
2454 {
2457 }
2458 else
2464 /* Add this decl to the current binding level. */
2467 /* If we're naming the type, equate the TYPE_STUB_DECL to the name. This
2468 causes the name to be also viewed as a "tag" by the debug back-end, with
2469 the advantage that no DW_TAG_typedef is emitted for artificial "tagged"
2470 types in DWARF.
2472 Note that if "type" is used as a DECL_ORIGINAL_TYPE, it may be referenced
2473 from multiple contexts, and "type_decl" references a copy of it: in such a
2474 case, do not mess TYPE_STUB_DECL: we do not want to re-use the TYPE_DECL
2475 with the mechanism above. */
2479 /* Do not generate debug info for UNCONSTRAINED_ARRAY_TYPE that the
2480 back-end doesn't support, and for others if we don't need to. */
2485 }
2486 \f
2487 /* Return a VAR_DECL or CONST_DECL node.
2489 NAME gives the name of the variable. ASM_NAME is its assembler name
2490 (if provided). TYPE is its data type (a GCC ..._TYPE node). INIT is
2491 the GCC tree for an optional initial expression; NULL_TREE if none.
2493 CONST_FLAG is true if this variable is constant, in which case we might
2494 return a CONST_DECL node unless CONST_DECL_ALLOWED_P is false.
2496 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
2497 definition to be made visible outside of the current compilation unit, for
2498 instance variable definitions in a package specification.
2500 EXTERN_FLAG is true when processing an external variable declaration (as
2501 opposed to a definition: no storage is to be allocated for the variable).
2503 STATIC_FLAG is only relevant when not at top level and indicates whether
2504 to always allocate storage to the variable.
2506 VOLATILE_FLAG is true if this variable is declared as volatile.
2508 ARTIFICIAL_P is true if the variable was generated by the compiler.
2510 DEBUG_INFO_P is true if we need to write debug information for it.
2512 ATTR_LIST is the list of attributes to be attached to the variable.
2514 GNAT_NODE is used for the position of the decl. */
2516 tree
2522 {
2523 /* Whether the object has static storage duration, either explicitly or by
2524 virtue of being declared at the global level. */
2527 /* Whether the initializer is constant: for an external object or an object
2528 with static storage duration, we check that the initializer is a valid
2529 constant expression for initializing a static variable; otherwise, we
2530 only check that it is constant. */
2531 const bool init_const
2532 = (init
2536 != NULL_TREE
2539 /* Whether we will make TREE_CONSTANT the DECL we produce here, in which
2540 case the initializer may be used in lieu of the DECL node (as done in
2541 Identifier_to_gnu). This is useful to prevent the need of elaboration
2542 code when an identifier for which such a DECL is made is in turn used
2543 as an initializer. We used to rely on CONST_DECL vs VAR_DECL for this,
2544 but extra constraints apply to this choice (see below) and they are not
2545 relevant to the distinction we wish to make. */
2548 /* The actual DECL node. CONST_DECL was initially intended for enumerals
2549 and may be used for scalars in general but not for aggregates. */
2550 tree var_decl
2552 (constant_p
2553 && const_decl_allowed_p
2557 /* Detect constants created by the front-end to hold 'reference to function
2558 calls for stabilization purposes. This is needed for renaming. */
2560 {
2571 }
2573 /* If this is external, throw away any initializations (they will be done
2574 elsewhere) unless this is a constant for which we would like to remain
2575 able to get the initializer. If we are defining a global here, leave a
2576 constant initialization and save any variable elaborations for the
2577 elaboration routine. If we are just annotating types, throw away the
2578 initialization if it isn't a constant. */
2583 /* At the global level, a non-constant initializer generates elaboration
2584 statements. Check that such statements are allowed, that is to say,
2585 not violating a No_Elaboration_Code restriction. */
2589 /* Attach the initializer, if any. */
2592 /* Directly set some flags. */
2599 /* The object is public if it is external or if it is declared public
2600 and has static storage duration. */
2603 /* We need to allocate static storage for an object with static storage
2604 duration if it isn't external. */
2614 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
2615 try to fiddle with DECL_COMMON. However, on platforms that don't
2616 support global BSS sections, uninitialized global variables would
2617 go in DATA instead, thus increasing the size of the executable. */
2624 /* Do not emit debug info for a CONST_DECL if optimization isn't enabled,
2625 since we will create an associated variable. Likewise for an external
2626 constant whose initializer is not absolute, because this would mean a
2627 global relocation in a read-only section which runs afoul of the PE-COFF
2628 run-time relocation mechanism. */
2631 || (extern_flag
2632 && constant_p
2633 && init
2638 /* ??? Some attributes cannot be applied to CONST_DECLs. */
2642 /* Add this decl to the current binding level. */
2646 {
2647 /* Let the target mangle the name if this isn't a verbatim asm. */
2652 }
2655 }
2656 \f
2657 /* Return true if TYPE, an aggregate type, contains (or is) an array. */
2659 static bool
2661 {
2663 {
2667 {
2668 tree field;
2674 }
2681 }
2682 }
2684 /* Return a FIELD_DECL node. NAME is the field's name, TYPE is its type and
2685 RECORD_TYPE is the type of the enclosing record. If SIZE is nonzero, it
2686 is the specified size of the field. If POS is nonzero, it is the bit
2687 position. PACKED is 1 if the enclosing record is packed, -1 if it has
2688 Component_Alignment of Storage_Unit. If ADDRESSABLE is nonzero, it
2689 means we are allowed to take the address of the field; if it is negative,
2690 we should not make a bitfield, which is used by make_aligning_type. */
2692 tree
2695 {
2701 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
2702 byte boundary since GCC cannot handle less-aligned BLKmode bitfields.
2703 Likewise for an aggregate without specified position that contains an
2704 array, because in this case slices of variable length of this array
2705 must be handled by GCC and variable-sized objects need to be aligned
2706 to at least a byte boundary. */
2708 || (!pos
2713 /* If a size is specified, use it. Otherwise, if the record type is packed
2714 compute a size to use, which may differ from the object's natural size.
2715 We always set a size in this case to trigger the checks for bitfield
2716 creation below, which is typically required when no position has been
2717 specified. */
2721 {
2725 }
2727 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
2728 specified for two reasons: first if the size differs from the natural
2729 size. Second, if the alignment is insufficient. There are a number of
2730 ways the latter can be true.
2732 We never make a bitfield if the type of the field has a nonconstant size,
2733 because no such entity requiring bitfield operations should reach here.
2735 We do *preventively* make a bitfield when there might be the need for it
2736 but we don't have all the necessary information to decide, as is the case
2737 of a field with no specified position in a packed record.
2739 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
2740 in layout_decl or finish_record_type to clear the bit_field indication if
2741 it is in fact not needed. */
2743 && size
2748 || packed
2751 {
2755 {
2759 else
2761 }
2762 }
2766 /* Bump the alignment if need be, either for bitfield/packing purposes or
2767 to satisfy the type requirements if no such consideration applies. When
2768 we get the alignment from the type, indicate if this is from an explicit
2769 user request, which prevents stor-layout from lowering it later on. */
2770 {
2771 unsigned int bit_align
2778 {
2781 }
2782 }
2785 {
2786 /* We need to pass in the alignment the DECL is known to have.
2787 This is the lowest-order bit set in POS, but no more than
2788 the alignment of the record, if one is specified. Note
2789 that an alignment of 0 is taken as infinite. */
2794 else
2808 }
2810 /* In addition to what our caller says, claim the field is addressable if we
2811 know that its type is not suitable.
2813 The field may also be "technically" nonaddressable, meaning that even if
2814 we attempt to take the field's address we will actually get the address
2815 of a copy. This is the case for true bitfields, but the DECL_BIT_FIELD
2816 value we have at this point is not accurate enough, so we don't account
2817 for this here and let finish_record_type decide. */
2824 }
2825 \f
2826 /* Return a PARM_DECL node with NAME and TYPE. */
2828 tree
2830 {
2833 /* Honor TARGET_PROMOTE_PROTOTYPES like the C compiler, as not doing so
2834 can lead to various ABI violations. */
2838 {
2839 /* We have to be careful about biased types here. Make a subtype
2840 of integer_type_node with the proper biasing. */
2843 {
2844 tree subtype
2851 }
2852 else
2854 }
2858 }
2859 \f
2860 /* Process the attributes in ATTR_LIST for NODE, which is either a DECL or
2861 a TYPE. If IN_PLACE is true, the tree pointed to by NODE should not be
2862 changed. GNAT_NODE is used for the position of error messages. */
2864 void
2866 Node_Id gnat_node)
2867 {
2872 {
2881 {
2884 }
2890 else
2897 {
2900 }
2901 else
2920 }
2923 }
2925 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
2926 a power of 2. */
2928 bool
2930 {
2939 }
2941 /* Defer the initialization of DECL's DECL_CONTEXT attribute, scheduling to
2942 feed it with the elaboration of GNAT_SCOPE. */
2946 {
2949 new_node
2958 }
2960 /* Defer the initialization of TYPE's TYPE_CONTEXT attribute, scheduling to
2961 feed it with the DECL_CONTEXT computed as part of N as soon as it is
2962 computed. */
2964 static void
2966 {
2968 }
2970 /* Get the GENERIC node corresponding to GNAT_SCOPE, if available. Return
2971 NULL_TREE if it is not available. */
2973 static tree
2975 {
2976 tree context;
2980 else
2984 {
2987 /* Skip dummy types: only the final ones can appear in the context
2988 chain. */
2992 /* ..._TYPE nodes are more useful than TYPE_DECL nodes in the context
2993 chain. */
2994 else
2996 }
2999 }
3001 /* Try to process all deferred nodes in the queue. Keep in the queue the ones
3002 that cannot be processed yet, remove the other ones. If FORCE is true,
3003 force the processing for all nodes, use the global context when nodes don't
3004 have a GNU translation. */
3006 void
3008 {
3013 {
3016 Entity_Id gnat_scope;
3020 /* If FORCE, get the innermost elaborated scope. Otherwise, just try to
3021 get the first scope. */
3024 {
3029 }
3031 /* Imported declarations must not be in a local context (i.e. not inside
3032 a function). */
3034 {
3038 {
3041 }
3042 }
3044 /* If FORCE, we want to get rid of all nodes in the queue: in case there
3045 was no elaborated scope, use the global context. */
3050 {
3051 tree t;
3056 /* Propagate it to the TYPE_CONTEXT attributes of the requested
3057 ..._TYPE nodes. */
3059 {
3061 }
3063 }
3065 /* If this node has been successfuly processed, remove it from the
3066 queue. Then move to the next node. */
3068 {
3072 }
3073 else
3075 }
3076 }
3078 /* Return VALUE scaled by the biggest power-of-2 factor of EXPR. */
3080 static unsigned int
3082 {
3086 /* Peel conversions around EXPR and try to extract bodies from function
3087 calls: it is possible to get the scale factor from size functions. */
3092 /* Sometimes we get PLUS_EXPR (BIT_AND_EXPR (..., X), Y), where Y is a
3093 multiple of the scale factor we are looking for. */
3097 {
3100 }
3102 /* An expression which is a bitwise AND with a mask has a power-of-2 factor
3103 corresponding to the number of trailing zeros of the mask. */
3106 {
3111 {
3114 i++;
3115 }
3116 }
3118 /* If the addend is not a multiple of the factor we found, give up. In
3119 theory we could find a smaller common factor but it's useless for our
3120 needs. This situation arises when dealing with a field F1 with no
3121 alignment requirement but that is following a field F2 with such
3122 requirements. As long as we have F2's offset, we don't need alignment
3123 information to compute F1's. */
3128 }
3130 /* Given two consecutive field decls PREV_FIELD and CURR_FIELD, return true
3131 unless we can prove these 2 fields are laid out in such a way that no gap
3132 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
3133 is the distance in bits between the end of PREV_FIELD and the starting
3134 position of CURR_FIELD. It is ignored if null. */
3136 static bool
3138 {
3139 /* If this is the first field of the record, there cannot be any gap */
3143 /* If the previous field is a union type, then return false: The only
3144 time when such a field is not the last field of the record is when
3145 there are other components at fixed positions after it (meaning there
3146 was a rep clause for every field), in which case we don't want the
3147 alignment constraint to override them. */
3151 /* If the distance between the end of prev_field and the beginning of
3152 curr_field is constant, then there is a gap if the value of this
3153 constant is not null. */
3157 /* If the size and position of the previous field are constant,
3158 then check the sum of this size and position. There will be a gap
3159 iff it is not multiple of the current field alignment. */
3166 /* If both the position and size of the previous field are multiples
3167 of the current field alignment, there cannot be any gap. */
3172 /* Fallback, return that there may be a potential gap */
3174 }
3176 /* Return a LABEL_DECL with NAME. GNAT_NODE is used for the position of
3177 the decl. */
3179 tree
3181 {
3182 tree label_decl
3187 /* Add this decl to the current binding level. */
3191 }
3192 \f
3193 /* Return a FUNCTION_DECL node. NAME is the name of the subprogram, ASM_NAME
3194 its assembler name, TYPE its type (a FUNCTION_TYPE node), PARAM_DECL_LIST
3195 the list of its parameters (a list of PARM_DECL nodes chained through the
3196 DECL_CHAIN field).
3198 INLINE_STATUS describes the inline flags to be set on the FUNCTION_DECL.
3200 PUBLIC_FLAG is true if this is for a reference to a public entity or for a
3201 definition to be made visible outside of the current compilation unit.
3203 EXTERN_FLAG is true when processing an external subprogram declaration.
3205 ARTIFICIAL_P is true if the subprogram was generated by the compiler.
3207 DEBUG_INFO_P is true if we need to write debug information for it.
3209 DEFINITION is true if the subprogram is to be considered as a definition.
3211 ATTR_LIST is the list of attributes to be attached to the subprogram.
3213 GNAT_NODE is used for the position of the decl. */
3215 tree
3220 Node_Id gnat_node)
3221 {
3235 {
3245 {
3249 ATTR_FLAG_TYPE_IN_PLACE);
3251 /* Inline_Always guarantees that every direct call is inlined and
3252 that there is no indirect reference to the subprogram, so the
3253 instance in the original package (as well as its clones in the
3254 client packages created for inter-unit inlining) can be made
3255 private, which causes the out-of-line body to be eliminated. */
3257 }
3259 /* ... fall through ... */
3268 }
3272 /* Once everything is processed, finish the subprogram declaration. */
3275 /* Add this decl to the current binding level. */
3278 /* Output the assembler code and/or RTL for the declaration. */
3282 }
3284 /* Given a subprogram declaration DECL, its assembler name and its type,
3285 finish constructing the subprogram declaration from ASM_NAME and TYPE. */
3287 void
3289 {
3290 tree result_decl
3299 /* Propagate the "const" property. */
3302 /* Propagate the "pure" property. */
3305 /* Propagate the "noreturn" property. */
3309 {
3310 /* Let the target mangle the name if this isn't a verbatim asm. */
3316 /* The expand_main_function circuitry expects "main_identifier_node" to
3317 designate the DECL_NAME of the 'main' entry point, in turn expected
3318 to be declared as the "main" function literally by default. Ada
3319 program entry points are typically declared with a different name
3320 within the binder generated file, exported as 'main' to satisfy the
3321 system expectations. Force main_identifier_node in this case. */
3324 }
3325 }
3326 \f
3327 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
3328 body. This routine needs to be invoked before processing the declarations
3329 appearing in the subprogram. */
3331 void
3333 {
3334 tree param_decl;
3338 /* This function is being defined. */
3341 /* The failure of this assertion will likely come from a wrong context for
3342 the subprogram body, e.g. another procedure for a procedure declared at
3343 library level. */
3348 /* Enter a new binding level and show that all the parameters belong to
3349 this function. */
3357 }
3359 /* Finish translating the current subprogram and set its BODY. */
3361 void
3363 {
3366 /* Attach the BLOCK for this level to the function and pop the level. */
3371 /* Mark the RESULT_DECL as being in this subprogram. */
3374 /* The body should be a BIND_EXPR whose BLOCK is the top-level one. */
3376 {
3379 }
3384 }
3386 /* Wrap up compilation of SUBPROG_DECL, a subprogram body. */
3388 void
3390 {
3391 /* We cannot track the location of errors past this point. */
3394 /* If we're only annotating types, don't actually compile this function. */
3398 /* Dump functions before gimplification. */
3403 else
3404 /* Register this function with cgraph just far enough to get it
3405 added to our parent's nested function list. */
3407 }
3409 tree
3411 {
3414 }
3416 /* Return an integer type with the number of bits of precision given by
3417 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
3418 it is a signed type. */
3420 tree
3422 {
3423 tree t;
3432 else
3440 {
3443 }
3446 }
3448 /* Likewise for floating-point types. */
3450 static tree
3452 {
3453 tree t;
3465 {
3468 }
3471 }
3473 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
3474 an unsigned type; otherwise a signed type is returned. */
3476 tree
3478 {
3488 scalar_float_mode float_mode;
3491 float_mode);
3493 scalar_int_mode int_mode;
3498 {
3503 }
3506 }
3508 /* Return the signed or unsigned version of TYPE_NODE, a scalar type, the
3509 signedness being specified by UNSIGNEDP. */
3511 tree
3513 {
3520 {
3523 }
3527 {
3530 }
3533 }
3535 /* Return 1 if the types T1 and T2 are compatible, i.e. if they can be
3536 transparently converted to each other. */
3538 int
3540 {
3543 /* This is the default criterion. */
3547 /* We only check structural equivalence here. */
3551 /* Vector types are also compatible if they have the same number of subparts
3552 and the same form of (scalar) element type. */
3559 /* Array types are also compatible if they are constrained and have the same
3560 domain(s), the same component type and the same scalar storage order. */
3576 }
3578 /* Return true if EXPR is a useless type conversion. */
3580 bool
3582 {
3590 }
3592 /* Return true if T, a FUNCTION_TYPE, has the specified list of flags. */
3594 bool
3597 {
3602 }
3603 \f
3604 /* EXP is an expression for the size of an object. If this size contains
3605 discriminant references, replace them with the maximum (if MAX_P) or
3606 minimum (if !MAX_P) possible value of the discriminant. */
3608 tree
3610 {
3616 {
3627 {
3641 }
3645 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
3646 modify. Otherwise, we treat it like a variable. */
3648 {
3651 return
3654 }
3674 {
3679 /* Special-case wanting the maximum value of a MIN_EXPR.
3680 In that case, if one side overflows, return the other. */
3682 {
3688 }
3690 /* Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
3691 overflowing and the RHS a variable. */
3698 /* If we are going to subtract a "negative" value in an unsigned type,
3699 do the operation as an addition of the negated value, in order to
3700 avoid creating a spurious overflow below. */
3706 {
3709 }
3714 /* We need to detect overflows so we call size_binop here. */
3716 }
3720 {
3747 {
3754 return
3757 }
3762 }
3764 /* Other tree classes cannot happen. */
3767 }
3770 }
3771 \f
3772 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
3773 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
3774 Return a constructor for the template. */
3776 tree
3778 {
3781 tree field;
3793 /* First make the list for a CONSTRUCTOR for the template. Go down the
3794 field list of the template instead of the type chain because this
3795 array might be an Ada array of arrays and we can't tell where the
3796 nested arrays stop being the underlying object. */
3799 (bound_list
3803 {
3806 /* If we have a bound list, get the bounds from there. Likewise
3807 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
3808 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
3809 This will give us a maximum range. */
3817 else
3823 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
3824 substitute it from OBJECT. */
3830 }
3833 }
3834 \f
3835 /* Return true if TYPE is suitable for the element type of a vector. */
3837 static bool
3839 {
3840 machine_mode mode;
3854 }
3856 /* Return a vector type given the SIZE and the INNER_TYPE, or NULL_TREE if
3857 this is not possible. If ATTRIBUTE is non-zero, we are processing the
3858 attribute declaration and want to issue error messages on failure. */
3860 static tree
3862 {
3866 /* Silently punt on variable sizes. We can't make vector types for them,
3867 need to ignore them on front-end generated subtypes of unconstrained
3868 base types, and this attribute is for binding implementors, not end
3869 users, so we should never get there from legitimate explicit uses. */
3875 {
3880 }
3884 {
3888 }
3891 {
3895 }
3899 {
3903 }
3906 }
3908 /* Return a vector type whose representative array type is ARRAY_TYPE, or
3909 NULL_TREE if this is not possible. If ATTRIBUTE is non-zero, we are
3910 processing the attribute and want to issue error messages on failure. */
3912 static tree
3914 {
3917 attribute);
3923 }
3924 \f
3925 /* Build a type to be used to represent an aliased object whose nominal type
3926 is an unconstrained array. This consists of a RECORD_TYPE containing a
3927 field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an ARRAY_TYPE.
3928 If ARRAY_TYPE is that of an unconstrained array, this is used to represent
3929 an arbitrary unconstrained object. Use NAME as the name of the record.
3930 DEBUG_INFO_P is true if we need to write debug information for the type. */
3932 tree
3935 {
3936 tree decl;
3938 tree template_field
3941 tree array_field
3950 /* Declare it now since it will never be declared otherwise. This is
3951 necessary to ensure that its subtrees are properly marked. */
3954 /* template_type will not be used elsewhere than here, so to keep the debug
3955 info clean and in order to avoid scoping issues, make decl its
3956 context. */
3960 }
3962 /* Same, taking a thin or fat pointer type instead of a template type. */
3964 tree
3967 {
3968 tree template_type;
3972 template_type
3977 return
3979 }
3980 \f
3981 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE.
3982 In the normal case this is just two adjustments, but we have more to
3983 do if NEW_TYPE is an UNCONSTRAINED_ARRAY_TYPE. */
3985 void
3987 {
3990 tree t;
3992 /* If this is the main variant, process all the other variants first. */
3997 /* If no pointers and no references, we are done. */
4001 /* Merge the old type qualifiers in the new type.
4003 Each old variant has qualifiers for specific reasons, and the new
4004 designated type as well. Each set of qualifiers represents useful
4005 information grabbed at some point, and merging the two simply unifies
4006 these inputs into the final type description.
4008 Consider for instance a volatile type frozen after an access to constant
4009 type designating it; after the designated type's freeze, we get here with
4010 a volatile NEW_TYPE and a dummy OLD_TYPE with a readonly variant, created
4011 when the access type was processed. We will make a volatile and readonly
4012 designated type, because that's what it really is.
4014 We might also get here for a non-dummy OLD_TYPE variant with different
4015 qualifiers than those of NEW_TYPE, for instance in some cases of pointers
4016 to private record type elaboration (see the comments around the call to
4017 this routine in gnat_to_gnu_entity <E_Access_Type>). We have to merge
4018 the qualifiers in those cases too, to avoid accidentally discarding the
4019 initial set, and will often end up with OLD_TYPE == NEW_TYPE then. */
4020 new_type
4024 /* If old type and new type are identical, there is nothing to do. */
4028 /* Otherwise, first handle the simple case. */
4030 {
4033 /* If pointer or reference already points to new type, nothing to do.
4034 This can happen as update_pointer_to can be invoked multiple times
4035 on the same couple of types because of the type variants. */
4040 /* Chain PTR and its variants at the end. */
4043 {
4047 }
4048 else
4051 /* Now adjust them. */
4054 {
4058 }
4060 /* Chain REF and its variants at the end. */
4063 {
4067 }
4068 else
4071 /* Now adjust them. */
4078 }
4080 /* Now deal with the unconstrained array case. In this case the pointer
4081 is actually a record where both fields are pointers to dummy nodes.
4082 Turn them into pointers to the correct types using update_pointer_to.
4083 Likewise for the pointer to the object record (thin pointer). */
4084 else
4085 {
4090 /* If PTR already points to NEW_TYPE, nothing to do. This can happen
4091 since update_pointer_to can be invoked multiple times on the same
4092 couple of types because of the type variants. */
4096 update_pointer_to
4100 update_pointer_to
4109 }
4110 }
4111 \f
4112 /* Convert EXPR, a pointer to a constrained array, into a pointer to an
4113 unconstrained one. This involves making or finding a template. */
4115 static tree
4117 {
4121 tree template_addr;
4125 /* If EXPR is null, make a fat pointer that contains a null pointer to the
4126 array (compare_fat_pointers ensures that this is the full discriminant)
4127 and a valid pointer to the bounds. This latter property is necessary
4128 since the compiler can hoist the load of the bounds done through it. */
4130 {
4136 else
4137 {
4138 /* The template type can still be dummy at this point so we build an
4139 empty constructor. The middle-end will fill it in with zeros. */
4144 }
4150 /* Do not set TREE_CONSTANT so as to force T to static memory. */
4155 }
4157 /* If EXPR is a thin pointer, make template and data from the record. */
4159 {
4164 /* If we have a TYPE_UNCONSTRAINED_ARRAY attached to the RECORD_TYPE,
4165 the thin pointer value has been shifted so we shift it back to get
4166 the template address. */
4168 {
4169 template_addr
4172 byte_position
4174 template_addr
4176 template_addr);
4177 }
4179 /* Otherwise we explicitly take the address of the fields. */
4180 else
4181 {
4183 template_addr
4189 }
4190 }
4192 /* Otherwise, build the constructor for the template. */
4193 else
4194 template_addr
4197 expr));
4199 /* The final result is a constructor for the fat pointer.
4201 If EXPR is an argument of a foreign convention subprogram, the type it
4202 points to is directly the component type. In this case, the expression
4203 type may not match the corresponding FIELD_DECL type at this point, so we
4204 call "convert" here to fix that up if necessary. This type consistency is
4205 required, for instance because it ensures that possible later folding of
4206 COMPONENT_REFs against this constructor always yields something of the
4207 same type as the initial reference.
4209 Note that the call to "build_template" above is still fine because it
4210 will only refer to the provided TEMPLATE_TYPE in this case. */
4214 }
4215 \f
4216 /* Create an expression whose value is that of EXPR,
4217 converted to type TYPE. The TREE_TYPE of the value
4218 is always TYPE. This function implements all reasonable
4219 conversions; callers should filter out those that are
4220 not permitted by the language being compiled. */
4222 tree
4224 {
4229 /* If the expression is already of the right type, we are done. */
4233 /* If both input and output have padding and are of variable size, do this
4234 as an unchecked conversion. Likewise if one is a mere variant of the
4235 other, so we avoid a pointless unpad/repad sequence. */
4243 ;
4245 /* If the output type has padding, convert to the inner type and make a
4246 constructor to build the record, unless a variable size is involved. */
4248 {
4249 /* If we previously converted from another type and our type is
4250 of variable size, remove the conversion to avoid the need for
4251 variable-sized temporaries. Likewise for a conversion between
4252 original and packable version. */
4260 /* If we are just removing the padding from expr, convert the original
4261 object if we have variable size in order to avoid the need for some
4262 variable-sized temporaries. Likewise if the padding is a variant
4263 of the other, so we avoid a pointless unpad/repad sequence. */
4274 /* If the inner type is of self-referential size and the expression type
4275 is a record, do this as an unchecked conversion unless both types are
4276 essentially the same. But first pad the expression if possible to
4277 have the same size on both sides. */
4282 {
4286 expr);
4288 }
4290 /* If we are converting between array types with variable size, do the
4291 final conversion as an unchecked conversion, again to avoid the need
4292 for some variable-sized temporaries. If valid, this conversion is
4293 very likely purely technical and without real effects. */
4300 expr),
4305 /* If converting to the inner type has already created a CONSTRUCTOR with
4306 the right size, then reuse it instead of creating another one. This
4307 can happen for the padding type built to overalign local variables. */
4319 }
4321 /* If the input type has padding, remove it and convert to the output type.
4322 The conditions ordering is arranged to ensure that the output type is not
4323 a padding type here, as it is not clear whether the conversion would
4324 always be correct if this was to happen. */
4326 {
4327 tree unpadded;
4329 /* If we have just converted to this padded type, just get the
4330 inner expression. */
4334 /* Otherwise, build an explicit component reference. */
4335 else
4339 }
4341 /* If the input is a biased type, convert first to the base type and add
4342 the bias. Note that the bias must go through a full conversion to the
4343 base type, lest it is itself a biased value; this happens for subtypes
4344 of biased types. */
4351 /* If the input is a justified modular type, we need to extract the actual
4352 object before converting it to any other type with the exceptions of an
4353 unconstrained array or of a mere type variant. It is useful to avoid the
4354 extraction and conversion in the type variant case because it could end
4355 up replacing a VAR_DECL expr by a constructor and we might be about the
4356 take the address of the result. */
4360 return
4363 /* If converting to a type that contains a template, convert to the data
4364 type and then build the template. */
4366 {
4371 /* If the source already has a template, get a reference to the
4372 associated array only, as we are going to rebuild a template
4373 for the target type anyway. */
4383 }
4385 /* There are some cases of expressions that we process specially. */
4387 {
4392 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
4393 conversion in gnat_expand_expr. NULL_EXPR does not represent
4394 and actual value, so no conversion is needed. */
4400 /* If we are converting a STRING_CST to another constrained array type,
4401 just make a new one in the proper type. */
4405 {
4409 }
4413 /* If we are converting a VECTOR_CST to a mere type variant, just make
4414 a new one in the proper type. */
4416 {
4420 }
4424 /* If we are converting a CONSTRUCTOR to a mere type variant, or to
4425 another padding type around the same type, just make a new one in
4426 the proper type. */
4433 {
4438 }
4440 /* Likewise for a conversion between original and packable version, or
4441 conversion between types of the same size and with the same list of
4442 fields, but we have to work harder to preserve type consistency. */
4448 {
4457 /* Whether we need to clear TREE_CONSTANT et al. on the output
4458 constructor when we convert in place. */
4462 {
4463 /* Skip the missing fields in the CONSTRUCTOR. */
4465 {
4468 }
4469 /* The field must be the same. */
4472 constructor_elt elt
4476 /* If packing has made this field a bitfield and the input
4477 value couldn't be emitted statically any more, we need to
4478 clear TREE_CONSTANT on our output. */
4488 }
4490 /* If we have been able to match and convert all the input fields
4491 to their output type, convert in place now. We'll fallback to a
4492 view conversion downstream otherwise. */
4494 {
4501 }
4502 }
4504 /* Likewise for a conversion between array type and vector type with a
4505 compatible representative array. */
4509 etype))
4510 {
4515 tree value;
4517 /* Build a VECTOR_CST from a *constant* array constructor. */
4519 {
4522 /* Iterate through elements and check if all constructor
4523 elements are *_CSTs. */
4526 {
4529 }
4534 }
4536 /* Otherwise, build a regular vector constructor. */
4539 {
4542 }
4547 }
4551 /* First retrieve the underlying array. */
4558 {
4559 /* GCC 4.x is very sensitive to type consistency overall, and view
4560 conversions thus are very frequent. Even though just "convert"ing
4561 the inner operand to the output type is fine in most cases, it
4562 might expose unexpected input/output type mismatches in special
4563 circumstances so we avoid such recursive calls when we can. */
4566 /* If we are converting back to the original type, we can just
4567 lift the input conversion. This is a common occurrence with
4568 switches back-and-forth amongst type variants. */
4572 /* Otherwise, if we're converting between two aggregate or vector
4573 types, we might be allowed to substitute the VIEW_CONVERT_EXPR
4574 target type in place or to just convert the inner expression. */
4577 {
4578 /* If we are converting between mere variants, we can just
4579 substitute the VIEW_CONVERT_EXPR in place. */
4583 /* Otherwise, we may just bypass the input view conversion unless
4584 one of the types is a fat pointer, which is handled by
4585 specialized code below which relies on exact type matching. */
4589 }
4592 }
4596 }
4598 /* Check for converting to a pointer to an unconstrained array. */
4602 /* If we are converting between two aggregate or vector types that are mere
4603 variants, just make a VIEW_CONVERT_EXPR. Likewise when we are converting
4604 to a vector type from its representative array type. */
4611 etype)))
4614 /* If we are converting between tagged types, try to upcast properly.
4615 But don't do it if we are just annotating types since tagged types
4616 aren't fully laid out in this mode. */
4620 {
4628 }
4630 /* If we are converting from a smaller form of record type back to it, just
4631 make a VIEW_CONVERT_EXPR. But first pad the expression to have the same
4632 size on both sides. */
4635 {
4638 expr);
4640 }
4642 /* In all other cases of related types, make a NOP_EXPR. */
4647 {
4657 /* If the output is a biased type, convert first to the base type and
4658 subtract the bias. Note that the bias itself must go through a full
4659 conversion to the base type, lest it is a biased value; this happens
4660 for subtypes of biased types. */
4668 /* ... fall through ... */
4672 /* If we are converting an additive expression to an integer type
4673 with lower precision, be wary of the optimization that can be
4674 applied by convert_to_integer. There are 2 problematic cases:
4675 - if the first operand was originally of a biased type,
4676 because we could be recursively called to convert it
4677 to an intermediate type and thus rematerialize the
4678 additive operator endlessly,
4679 - if the expression contains a placeholder, because an
4680 intermediate conversion that changes the sign could
4681 be inserted and thus introduce an artificial overflow
4682 at compile time when the placeholder is substituted. */
4687 {
4694 }
4700 /* If converting between two thin pointers, adjust if needed to account
4701 for differing offsets from the base pointer, depending on whether
4702 there is a TYPE_UNCONSTRAINED_ARRAY attached to the record type. */
4704 {
4705 tree etype_pos
4709 tree type_pos
4721 }
4723 /* If converting fat pointer to normal or thin pointer, get the pointer
4724 to the array and then convert it. */
4734 /* Do a normal conversion between scalar and justified modular type. */
4736 {
4742 expr));
4744 }
4746 /* In these cases, assume the front-end has validated the conversion.
4747 If the conversion is valid, it will be a bit-wise conversion, so
4748 it can be viewed as an unchecked conversion. */
4752 /* Do a normal conversion between unconstrained and constrained array
4753 type, assuming the latter is a constrained version of the former. */
4757 {
4765 }
4767 /* In these cases, assume the front-end has validated the conversion.
4768 If the conversion is valid, it will be a bit-wise conversion, so
4769 it can be viewed as an unchecked conversion. */
4773 /* This is a either a conversion between a tagged type and some
4774 subtype, which we have to mark as a UNION_TYPE because of
4775 overlapping fields or a conversion of an Unchecked_Union. */
4779 /* If the input is a VECTOR_TYPE, convert to the representative
4780 array type first. */
4782 {
4786 }
4788 /* If EXPR is a constrained array, take its address, convert it to a
4789 fat pointer, and then dereference it. Likewise if EXPR is a
4790 record containing both a template and a constrained array.
4791 Note that a record representing a justified modular type
4792 always represents a packed constrained array. */
4797 return
4798 build_unary_op
4804 /* Do something very similar for converting one unconstrained
4805 array to another. */
4807 return
4812 else
4820 }
4821 }
4823 /* Create an expression whose value is that of EXPR converted to the common
4824 index type, which is sizetype. EXPR is supposed to be in the base type
4825 of the GNAT index type. Calling it is equivalent to doing
4827 convert (sizetype, expr)
4829 but we try to distribute the type conversion with the knowledge that EXPR
4830 cannot overflow in its type. This is a best-effort approach and we fall
4831 back to the above expression as soon as difficulties are encountered.
4833 This is necessary to overcome issues that arise when the GNAT base index
4834 type and the GCC common index type (sizetype) don't have the same size,
4835 which is quite frequent on 64-bit architectures. In this case, and if
4836 the GNAT base index type is signed but the iteration type of the loop has
4837 been forced to unsigned, the loop scalar evolution engine cannot compute
4838 a simple evolution for the general induction variables associated with the
4839 array indices, because it will preserve the wrap-around semantics in the
4840 unsigned type of their "inner" part. As a result, many loop optimizations
4841 are blocked.
4843 The solution is to use a special (basic) induction variable that is at
4844 least as large as sizetype, and to express the aforementioned general
4845 induction variables in terms of this induction variable, eliminating
4846 the problematic intermediate truncation to the GNAT base index type.
4847 This is possible as long as the original expression doesn't overflow
4848 and if the middle-end hasn't introduced artificial overflows in the
4849 course of the various simplification it can make to the expression. */
4851 tree
4853 {
4857 /* If the type is unsigned, overflow is allowed so we cannot be sure that
4858 EXPR doesn't overflow. Keep it simple if optimization is disabled. */
4863 {
4865 /* The main effect of the function: replace a loop parameter with its
4866 associated special induction variable. */
4871 CASE_CONVERT:
4872 {
4874 /* Bail out as soon as we suspect some sort of type frobbing. */
4878 }
4880 /* ... fall through ... */
4904 }
4907 }
4908 \f
4909 /* Remove all conversions that are done in EXP. This includes converting
4910 from a padded type or to a justified modular type. If TRUE_ADDRESS
4911 is true, always return the address of the containing object even if
4912 the address is not bit-aligned. */
4914 tree
4916 {
4918 {
4923 return
4932 CASE_CONVERT:
4939 }
4942 }
4943 \f
4944 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
4945 refers to the underlying array. If it has TYPE_CONTAINS_TEMPLATE_P,
4946 likewise return an expression pointing to the underlying array. */
4948 tree
4950 {
4955 {
4958 {
4966 {
4967 tree op1
4972 tree op2
4981 }
4982 else
4983 {
4990 }
4991 }
5000 /* If this is a padded type and it contains a template, convert to the
5001 unpadded type first. */
5005 {
5009 }
5012 {
5013 /* If the array initializer is a box, return NULL_TREE. */
5021 /* If the array type is padded, convert to the unpadded type. */
5024 }
5029 }
5032 }
5033 \f
5034 /* Return true if EXPR is an expression that can be folded as an operand
5035 of a VIEW_CONVERT_EXPR. See ada-tree.h for a complete rationale. */
5037 static bool
5039 {
5042 /* The folder will fold NOP_EXPRs between integral types with the same
5043 precision (in the middle-end's sense). We cannot allow it if the
5044 types don't have the same precision in the Ada sense as well. */
5051 /* Defer to the folder for non-integral conversions. */
5055 /* Only fold conversions that preserve both precisions. */
5061 }
5063 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
5064 If NOTRUNC_P is true, truncation operations should be suppressed.
5066 Special care is required with (source or target) integral types whose
5067 precision is not equal to their size, to make sure we fetch or assign
5068 the value bits whose location might depend on the endianness, e.g.
5070 Rmsize : constant := 8;
5071 subtype Int is Integer range 0 .. 2 ** Rmsize - 1;
5073 type Bit_Array is array (1 .. Rmsize) of Boolean;
5074 pragma Pack (Bit_Array);
5076 function To_Bit_Array is new Unchecked_Conversion (Int, Bit_Array);
5078 Value : Int := 2#1000_0001#;
5079 Vbits : Bit_Array := To_Bit_Array (Value);
5081 we expect the 8 bits at Vbits'Address to always contain Value, while
5082 their original location depends on the endianness, at Value'Address
5083 on a little-endian architecture but not on a big-endian one.
5085 One pitfall is that we cannot use TYPE_UNSIGNED directly to decide how
5086 the bits between the precision and the size are filled, because of the
5087 trick used in the E_Signed_Integer_Subtype case of gnat_to_gnu_entity.
5088 So we use the special predicate type_unsigned_for_rm above. */
5090 tree
5092 {
5096 tree tem;
5099 /* If the expression is already of the right type, we are done. */
5103 /* If both types are integral just do a normal conversion.
5104 Likewise for a conversion to an unconstrained array. */
5112 {
5114 {
5119 }
5122 {
5128 }
5129 else
5131 }
5133 /* If we are converting to an integral type whose precision is not equal
5134 to its size, first unchecked convert to a record type that contains a
5135 field of the given precision. Then extract the result from the field.
5137 There is a subtlety if the source type is an aggregate type with reverse
5138 storage order because its representation is not contiguous in the native
5139 storage order, i.e. a direct unchecked conversion to an integral type
5140 with N bits of precision cannot read the first N bits of the aggregate
5141 type. To overcome it, we do an unchecked conversion to an integral type
5142 with reverse storage order and return the resulting value. This also
5143 ensures that the result of the unchecked conversion doesn't depend on
5144 the endianness of the target machine, but only on the storage order of
5145 the aggregate type.
5147 Finally, for the sake of consistency, we do the unchecked conversion
5148 to an integral type with reverse storage order as soon as the source
5149 type is an aggregate type with reverse storage order, even if there
5150 are no considerations of precision or size involved. */
5157 {
5168 else
5180 }
5182 /* Similarly if we are converting from an integral type whose precision is
5183 not equal to its size, first copy into a field of the given precision
5184 and unchecked convert the record type.
5186 The same considerations as above apply if the target type is an aggregate
5187 type with reverse storage order and we also proceed similarly. */
5194 {
5207 else
5220 }
5222 /* If we are converting from a scalar type to a type with a different size,
5223 we need to pad to have the same size on both sides.
5225 ??? We cannot do it unconditionally because unchecked conversions are
5226 used liberally by the front-end to implement polymorphism, e.g. in:
5228 S191s : constant ada__tags__addr_ptr := ada__tags__addr_ptr!(S190s);
5229 return p___size__4 (p__object!(S191s.all));
5231 so we skip all expressions that are references. */
5236 {
5238 {
5241 expr);
5243 }
5244 else
5245 {
5250 }
5251 }
5253 /* We have a special case when we are converting between two unconstrained
5254 array types. In that case, take the address, convert the fat pointer
5255 types, and dereference. */
5260 expr)));
5262 /* Another special case is when we are converting to a vector type from its
5263 representative array type; this a regular conversion. */
5267 etype))
5270 /* And, if the array type is not the representative, we try to build an
5271 intermediate vector type of which the array type is the representative
5272 and to do the unchecked conversion between the vector types, in order
5273 to enable further simplifications in the middle-end. */
5277 {
5280 }
5282 /* If we are converting a CONSTRUCTOR to a more aligned RECORD_TYPE, bump
5283 the alignment of the CONSTRUCTOR to speed up the copy operation. */
5287 {
5290 expr);
5292 }
5294 /* Otherwise, just build a VIEW_CONVERT_EXPR of the expression. */
5295 else
5296 {
5302 else
5304 }
5306 /* If the result is a non-biased integral type whose precision is not equal
5307 to its size, sign- or zero-extend the result. But we need not do this
5308 if the input is also an integral type and both are unsigned or both are
5309 signed and have the same precision. */
5322 {
5325 else
5326 {
5327 tree base_type
5330 tree shift_expr
5334 expr
5339 expr),
5340 shift_expr),
5341 shift_expr));
5342 }
5343 }
5345 /* An unchecked conversion should never raise Constraint_Error. The code
5346 below assumes that GCC's conversion routines overflow the same way that
5347 the underlying hardware does. This is probably true. In the rare case
5348 when it is false, we can rely on the fact that such conversions are
5349 erroneous anyway. */
5353 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
5354 show no longer constant. */
5357 OEP_ONLY_CONST))
5361 }
5362 \f
5363 /* Return the appropriate GCC tree code for the specified GNAT_TYPE,
5364 the latter being a record type as predicated by Is_Record_Type. */
5366 enum tree_code
5368 {
5371 /* Return UNION_TYPE if it's an Unchecked_Union whose non-discriminant
5372 fields are all in the variant part. Otherwise, return RECORD_TYPE. */
5377 component_list
5387 }
5389 /* Return true if GNAT_TYPE is a "double" floating-point type, i.e. whose
5390 size is equal to 64 bits, or an array of such a type. Set ALIGN_CLAUSE
5391 according to the presence of an alignment clause on the type or, if it
5392 is an array, on the component type. */
5394 bool
5396 {
5402 {
5406 }
5415 }
5417 /* Return true if GNAT_TYPE is a "double" or larger scalar type, i.e. whose
5418 size is greater or equal to 64 bits, or an array of such a type. Set
5419 ALIGN_CLAUSE according to the presence of an alignment clause on the
5420 type or, if it is an array, on the component type. */
5422 bool
5424 {
5430 {
5434 }
5443 }
5445 /* Return true if GNU_TYPE is suitable as the type of a non-aliased
5446 component of an aggregate type. */
5448 bool
5450 {
5451 /* If the type is passed by reference, we may have pointers to the
5452 component so it cannot be made non-aliased. */
5456 /* We used to say that any component of aggregate type is aliased
5457 because the front-end may take 'Reference of it. The front-end
5458 has been enhanced in the meantime so as to use a renaming instead
5459 in most cases, but the back-end can probably take the address of
5460 such a component too so we go for the conservative stance.
5462 For instance, we might need the address of any array type, even
5463 if normally passed by copy, to construct a fat pointer if the
5464 component is used as an actual for an unconstrained formal.
5466 Likewise for record types: even if a specific record subtype is
5467 passed by copy, the parent type might be passed by ref (e.g. if
5468 it's of variable size) and we might take the address of a child
5469 component to pass to a parent formal. We have no way to check
5470 for such conditions here. */
5475 }
5477 /* Return true if TYPE is a smaller form of ORIG_TYPE. */
5479 bool
5481 {
5484 /* We're not interested in variants here. */
5488 /* Like a variant, a packable version keeps the original TYPE_NAME. */
5499 }
5501 /* Return whether EXPR, which is the renamed object in an object renaming
5502 declaration, can be materialized as a reference (with a REFERENCE_TYPE).
5503 This should be synchronized with Exp_Dbug.Debug_Renaming_Declaration. */
5505 bool
5507 {
5509 {
5513 {
5522 {
5526 const Uint bitpos
5534 }
5538 {
5546 }
5554 };
5555 }
5556 }
5558 /* Perform final processing on global declarations. */
5562 void
5564 {
5566 tree iter;
5568 /* If we have declared types as used at the global level, insert them in
5569 the global hash table. We use a dummy variable for this purpose, but
5570 we need to build it unconditionally to avoid -fcompare-debug issues. */
5572 {
5577 dummy_global
5579 void_type_node);
5588 {
5591 }
5592 }
5594 /* Output debug information for all global type declarations first. This
5595 ensures that global types whose compilation hasn't been finalized yet,
5596 for example pointers to Taft amendment types, have their compilation
5597 finalized in the right context. */
5602 /* Output imported functions. */
5611 /* Then output the global variables. We need to do that after the debug
5612 information for global types is emitted so that they are finalized. Skip
5613 external global variables, unless we need to emit debug info for them:
5614 this is useful for imported variables, for instance. */
5620 /* Output the imported modules/declarations. In GNAT, these are only
5621 materializing subprogram. */
5626 }
5628 /* ************************************************************************
5629 * * GCC builtins support *
5630 * ************************************************************************ */
5632 /* The general scheme is fairly simple:
5634 For each builtin function/type to be declared, gnat_install_builtins calls
5635 internal facilities which eventually get to gnat_pushdecl, which in turn
5636 tracks the so declared builtin function decls in the 'builtin_decls' global
5637 datastructure. When an Intrinsic subprogram declaration is processed, we
5638 search this global datastructure to retrieve the associated BUILT_IN DECL
5639 node. */
5641 /* Search the chain of currently available builtin declarations for a node
5642 corresponding to function NAME (an IDENTIFIER_NODE). Return the first node
5643 found, if any, or NULL_TREE otherwise. */
5644 tree
5646 {
5648 tree decl;
5655 }
5657 /* The code below eventually exposes gnat_install_builtins, which declares
5658 the builtin types and functions we might need, either internally or as
5659 user accessible facilities.
5661 ??? This is a first implementation shot, still in rough shape. It is
5662 heavily inspired from the "C" family implementation, with chunks copied
5663 verbatim from there.
5665 Two obvious improvement candidates are:
5666 o Use a more efficient name/decl mapping scheme
5667 o Devise a middle-end infrastructure to avoid having to copy
5668 pieces between front-ends. */
5670 /* ----------------------------------------------------------------------- *
5671 * BUILTIN ELEMENTARY TYPES *
5672 * ----------------------------------------------------------------------- */
5674 /* Standard data types to be used in builtin argument declarations. */
5676 enum c_tree_index
5677 {
5679 CTI_STRING_TYPE,
5680 CTI_CONST_STRING_TYPE,
5682 CTI_MAX
5683 };
5687 #define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
5688 #define string_type_node c_global_trees[CTI_STRING_TYPE]
5689 #define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
5691 /* ??? In addition some attribute handlers, we currently don't support a
5692 (small) number of builtin-types, which in turns inhibits support for a
5693 number of builtin functions. */
5694 #define wint_type_node void_type_node
5695 #define intmax_type_node void_type_node
5696 #define uintmax_type_node void_type_node
5698 /* Used to help initialize the builtin-types.def table. When a type of
5699 the correct size doesn't exist, use error_mark_node instead of NULL.
5700 The later results in segfaults even when a decl using the type doesn't
5701 get invoked. */
5703 static tree
5705 {
5708 }
5710 /* Build/push the elementary type decls that builtin functions/types
5711 will need. */
5713 static void
5715 {
5720 const_string_type_node
5723 }
5725 /* ----------------------------------------------------------------------- *
5726 * BUILTIN FUNCTION TYPES *
5727 * ----------------------------------------------------------------------- */
5729 /* Now, builtin function types per se. */
5731 enum c_builtin_type
5732 {
5733 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5734 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5735 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5736 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5737 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5738 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5739 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5740 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5741 ARG6) NAME,
5742 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5743 ARG6, ARG7) NAME,
5744 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5745 ARG6, ARG7, ARG8) NAME,
5746 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5747 ARG6, ARG7, ARG8, ARG9) NAME,
5748 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5749 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
5750 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5751 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
5752 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5753 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5754 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5755 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5756 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5757 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5758 NAME,
5759 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5760 ARG6) NAME,
5761 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5762 ARG6, ARG7) NAME,
5763 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5765 #undef DEF_PRIMITIVE_TYPE
5766 #undef DEF_FUNCTION_TYPE_0
5767 #undef DEF_FUNCTION_TYPE_1
5768 #undef DEF_FUNCTION_TYPE_2
5769 #undef DEF_FUNCTION_TYPE_3
5770 #undef DEF_FUNCTION_TYPE_4
5771 #undef DEF_FUNCTION_TYPE_5
5772 #undef DEF_FUNCTION_TYPE_6
5773 #undef DEF_FUNCTION_TYPE_7
5774 #undef DEF_FUNCTION_TYPE_8
5775 #undef DEF_FUNCTION_TYPE_9
5776 #undef DEF_FUNCTION_TYPE_10
5777 #undef DEF_FUNCTION_TYPE_11
5778 #undef DEF_FUNCTION_TYPE_VAR_0
5779 #undef DEF_FUNCTION_TYPE_VAR_1
5780 #undef DEF_FUNCTION_TYPE_VAR_2
5781 #undef DEF_FUNCTION_TYPE_VAR_3
5782 #undef DEF_FUNCTION_TYPE_VAR_4
5783 #undef DEF_FUNCTION_TYPE_VAR_5
5784 #undef DEF_FUNCTION_TYPE_VAR_6
5785 #undef DEF_FUNCTION_TYPE_VAR_7
5786 #undef DEF_POINTER_TYPE
5787 BT_LAST
5788 };
5792 /* A temporary array used in communication with def_fn_type. */
5795 /* A helper function for install_builtin_types. Build function type
5796 for DEF with return type RET and N arguments. If VAR is true, then the
5797 function should be variadic after those N arguments.
5799 Takes special care not to ICE if any of the types involved are
5800 error_mark_node, which indicates that said type is not in fact available
5801 (see builtin_type_for_size). In which case the function type as a whole
5802 should be error_mark_node. */
5804 static void
5806 {
5807 tree t;
5814 {
5820 }
5827 else
5830 egress:
5833 }
5835 /* Build the builtin function types and install them in the builtin_types
5836 array for later use in builtin function decls. */
5838 static void
5840 {
5841 tree va_list_ref_type_node;
5842 tree va_list_arg_type_node;
5845 {
5848 }
5849 else
5850 {
5853 }
5855 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5856 builtin_types[ENUM] = VALUE;
5857 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5858 def_fn_type (ENUM, RETURN, 0, 0);
5859 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5860 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5861 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5862 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5863 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5864 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5865 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5866 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5867 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5868 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5869 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5870 ARG6) \
5871 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5872 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5873 ARG6, ARG7) \
5874 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5875 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5876 ARG6, ARG7, ARG8) \
5877 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5878 ARG7, ARG8);
5879 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5880 ARG6, ARG7, ARG8, ARG9) \
5881 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5882 ARG7, ARG8, ARG9);
5883 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5,\
5884 ARG6, ARG7, ARG8, ARG9, ARG10) \
5885 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5886 ARG7, ARG8, ARG9, ARG10);
5887 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5,\
5888 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
5889 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5890 ARG7, ARG8, ARG9, ARG10, ARG11);
5891 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5892 def_fn_type (ENUM, RETURN, 1, 0);
5893 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5894 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5895 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5896 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5897 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5898 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5899 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5900 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5901 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5902 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5903 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5904 ARG6) \
5905 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5906 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5907 ARG6, ARG7) \
5908 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5909 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5910 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5914 #undef DEF_PRIMITIVE_TYPE
5915 #undef DEF_FUNCTION_TYPE_0
5916 #undef DEF_FUNCTION_TYPE_1
5917 #undef DEF_FUNCTION_TYPE_2
5918 #undef DEF_FUNCTION_TYPE_3
5919 #undef DEF_FUNCTION_TYPE_4
5920 #undef DEF_FUNCTION_TYPE_5
5921 #undef DEF_FUNCTION_TYPE_6
5922 #undef DEF_FUNCTION_TYPE_7
5923 #undef DEF_FUNCTION_TYPE_8
5924 #undef DEF_FUNCTION_TYPE_9
5925 #undef DEF_FUNCTION_TYPE_10
5926 #undef DEF_FUNCTION_TYPE_11
5927 #undef DEF_FUNCTION_TYPE_VAR_0
5928 #undef DEF_FUNCTION_TYPE_VAR_1
5929 #undef DEF_FUNCTION_TYPE_VAR_2
5930 #undef DEF_FUNCTION_TYPE_VAR_3
5931 #undef DEF_FUNCTION_TYPE_VAR_4
5932 #undef DEF_FUNCTION_TYPE_VAR_5
5933 #undef DEF_FUNCTION_TYPE_VAR_6
5934 #undef DEF_FUNCTION_TYPE_VAR_7
5935 #undef DEF_POINTER_TYPE
5937 }
5939 /* ----------------------------------------------------------------------- *
5940 * BUILTIN ATTRIBUTES *
5941 * ----------------------------------------------------------------------- */
5943 enum built_in_attribute
5944 {
5945 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5946 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5947 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5948 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5949 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5951 #undef DEF_ATTR_NULL_TREE
5952 #undef DEF_ATTR_INT
5953 #undef DEF_ATTR_STRING
5954 #undef DEF_ATTR_IDENT
5955 #undef DEF_ATTR_TREE_LIST
5956 ATTR_LAST
5957 };
5961 static void
5963 {
5964 /* Fill in the built_in_attributes array. */
5965 #define DEF_ATTR_NULL_TREE(ENUM) \
5966 built_in_attributes[(int) ENUM] = NULL_TREE;
5967 #define DEF_ATTR_INT(ENUM, VALUE) \
5968 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5969 #define DEF_ATTR_STRING(ENUM, VALUE) \
5970 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5971 #define DEF_ATTR_IDENT(ENUM, STRING) \
5972 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5973 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5974 built_in_attributes[(int) ENUM] \
5975 = tree_cons (built_in_attributes[(int) PURPOSE], \
5976 built_in_attributes[(int) VALUE], \
5977 built_in_attributes[(int) CHAIN]);
5979 #undef DEF_ATTR_NULL_TREE
5980 #undef DEF_ATTR_INT
5981 #undef DEF_ATTR_STRING
5982 #undef DEF_ATTR_IDENT
5983 #undef DEF_ATTR_TREE_LIST
5984 }
5986 /* Handle a "const" attribute; arguments as in
5987 struct attribute_spec.handler. */
5989 static tree
5993 {
5996 else
6000 }
6002 /* Handle a "nothrow" attribute; arguments as in
6003 struct attribute_spec.handler. */
6005 static tree
6009 {
6012 else
6016 }
6018 /* Handle a "pure" attribute; arguments as in
6019 struct attribute_spec.handler. */
6021 static tree
6024 {
6027 /* TODO: support types. */
6028 else
6029 {
6033 }
6036 }
6038 /* Handle a "no vops" attribute; arguments as in
6039 struct attribute_spec.handler. */
6041 static tree
6045 {
6049 }
6051 /* Helper for nonnull attribute handling; fetch the operand number
6052 from the attribute argument list. */
6054 static bool
6056 {
6057 /* Verify the arg number is a constant. */
6063 }
6065 /* Handle the "nonnull" attribute. */
6066 static tree
6070 {
6074 /* If no arguments are specified, all pointer arguments should be
6075 non-null. Verify a full prototype is given so that the arguments
6076 will have the correct types when we actually check them later.
6077 Avoid diagnosing type-generic built-ins since those have no
6078 prototype. */
6080 {
6084 {
6087 }
6089 }
6091 /* Argument list specified. Verify that each argument number references
6092 a pointer argument. */
6094 {
6098 {
6103 }
6106 {
6107 function_args_iterator iter;
6108 tree argument;
6112 {
6116 }
6120 {
6126 }
6129 {
6135 }
6136 }
6137 }
6140 }
6142 /* Handle a "sentinel" attribute. */
6144 static tree
6147 {
6149 {
6154 }
6155 else
6156 {
6158 {
6163 }
6164 }
6167 {
6171 {
6174 }
6175 else
6176 {
6178 {
6181 }
6182 }
6183 }
6186 }
6188 /* Handle a "noreturn" attribute; arguments as in
6189 struct attribute_spec.handler. */
6191 static tree
6194 {
6197 /* See FIXME comment in c_common_attribute_table. */
6203 = build_pointer_type
6205 else
6206 {
6210 }
6213 }
6215 /* Handle a "noinline" attribute; arguments as in
6216 struct attribute_spec.handler. */
6218 static tree
6222 {
6224 {
6226 {
6230 }
6231 else
6233 }
6234 else
6235 {
6238 }
6241 }
6243 /* Handle a "noclone" attribute; arguments as in
6244 struct attribute_spec.handler. */
6246 static tree
6250 {
6252 {
6255 }
6258 }
6260 /* Handle a "leaf" attribute; arguments as in
6261 struct attribute_spec.handler. */
6263 static tree
6266 {
6268 {
6271 }
6273 {
6276 }
6279 }
6281 /* Handle a "always_inline" attribute; arguments as in
6282 struct attribute_spec.handler. */
6284 static tree
6287 {
6289 {
6290 /* Set the attribute and mark it for disregarding inline limits. */
6292 }
6293 else
6294 {
6297 }
6300 }
6302 /* Handle a "malloc" attribute; arguments as in
6303 struct attribute_spec.handler. */
6305 static tree
6308 {
6312 else
6313 {
6317 }
6320 }
6322 /* Fake handler for attributes we don't properly support. */
6324 tree
6330 {
6332 }
6334 /* Handle a "type_generic" attribute. */
6336 static tree
6340 {
6341 /* Ensure we have a function type. */
6344 /* Ensure we have a variadic function. */
6348 }
6350 /* Handle a "vector_size" attribute; arguments as in
6351 struct attribute_spec.handler. */
6353 static tree
6356 {
6358 tree vector_type;
6362 /* We need to provide for vector pointers, vector arrays, and
6363 functions returning vectors. For example:
6365 __attribute__((vector_size(16))) short *foo;
6367 In this case, the mode is SI, but the type being modified is
6368 HI, so we need to look further. */
6378 /* Build back pointers if needed. */
6382 }
6384 /* Handle a "vector_type" attribute; arguments as in
6385 struct attribute_spec.handler. */
6387 static tree
6390 {
6392 tree vector_type;
6397 {
6401 }
6411 }
6413 /* ----------------------------------------------------------------------- *
6414 * BUILTIN FUNCTIONS *
6415 * ----------------------------------------------------------------------- */
6417 /* Worker for DEF_BUILTIN. Possibly define a builtin function with one or two
6418 names. Does not declare a non-__builtin_ function if flag_no_builtin, or
6419 if nonansi_p and flag_no_nonansi_builtin. */
6421 static void
6429 {
6430 tree decl;
6433 /* Preserve an already installed decl. It most likely was setup in advance
6434 (e.g. as part of the internal builtins) for specific reasons. */
6448 fnattrs);
6450 /* ??? This is normally further controlled by command-line options
6451 like -fno-builtin, but we don't have them for Ada. */
6456 }
6462 /* Install what the common builtins.def offers. */
6464 static void
6466 {
6467 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
6468 NONANSI_P, ATTRS, IMPLICIT, COND) \
6469 if (NAME && COND) \
6470 def_builtin_1 (ENUM, NAME, CLASS, \
6471 builtin_types[(int) TYPE], \
6472 builtin_types[(int) LIBTYPE], \
6473 BOTH_P, FALLBACK_P, NONANSI_P, \
6474 built_in_attributes[(int) ATTRS], IMPLICIT);
6476 }
6478 /* ----------------------------------------------------------------------- *
6479 * BUILTIN FUNCTIONS *
6480 * ----------------------------------------------------------------------- */
6482 /* Install the builtin functions we might need. */
6484 void
6486 {
6491 /* Install builtins used by generic middle-end pieces first. Some of these
6492 know about internal specificities and control attributes accordingly, for
6493 instance __builtin_alloca vs no-throw and -fstack-check. We will ignore
6494 the generic definition from builtins.def. */
6497 /* Now, install the target specific builtins, such as the AltiVec family on
6498 ppc, and the common set as exposed by builtins.def. */
6501 }