| blob | 0b499af270c823f32b504ffe906907df0c6f2ac7 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2005, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 2, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License distributed with GNAT; see file COPYING. If not, write *
19 * to the Free Software Foundation, 51 Franklin Street, Fifth Floor, *
20 * Boston, MA 02110-1301, USA. *
21 * *
22 * GNAT was originally developed by the GNAT team at New York University. *
23 * Extensive contributions were provided by Ada Core Technologies Inc. *
24 * *
25 ****************************************************************************/
60 #ifndef MAX_FIXED_MODE_SIZE
61 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
62 #endif
64 #ifndef MAX_BITS_PER_WORD
65 #define MAX_BITS_PER_WORD BITS_PER_WORD
66 #endif
68 /* If nonzero, pretend we are allocating at global level. */
71 /* Tree nodes for the various types and decls we create. */
74 /* Functions to call for each of the possible raise reasons. */
77 /* List of functions called automatically at the beginning and
78 end of execution, on targets without .ctors/.dtors sections. */
79 tree static_ctors;
80 tree static_dtors;
82 /* Associates a GNAT tree node to a GCC tree node. It is used in
83 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
84 of `save_gnu_tree' for more info. */
87 /* This variable keeps a table for types for each precision so that we only
88 allocate each of them once. Signed and unsigned types are kept separate.
90 Note that these types are only used when fold-const requests something
91 special. Perhaps we should NOT share these types; we'll see how it
92 goes later. */
95 /* Likewise for float types, but record these by mode. */
98 /* For each binding contour we allocate a binding_level structure to indicate
99 the binding depth. */
102 {
103 /* The binding level containing this one (the enclosing binding level). */
105 /* The BLOCK node for this level. */
106 tree block;
107 /* If nonzero, the setjmp buffer that needs to be updated for any
108 variable-sized definition within this context. */
109 tree jmpbuf_decl;
110 };
112 /* The binding level currently in effect. */
115 /* A chain of gnat_binding_level structures awaiting reuse. */
118 /* A chain of unused BLOCK nodes. */
122 {
124 };
138 \f
139 /* Initialize the association of GNAT nodes to GCC trees. */
141 void
143 {
144 associate_gnat_to_gnu
146 }
148 /* GNAT_ENTITY is a GNAT tree node for an entity. GNU_DECL is the GCC tree
149 which is to be associated with GNAT_ENTITY. Such GCC tree node is always
150 a ..._DECL node. If NO_CHECK is nonzero, the latter check is suppressed.
152 If GNU_DECL is zero, a previous association is to be reset. */
154 void
156 {
157 /* Check that GNAT_ENTITY is not already defined and that it is being set
158 to something which is a decl. Raise gigi 401 if not. Usually, this
159 means GNAT_ENTITY is defined twice, but occasionally is due to some
160 Gigi problem. */
165 }
167 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
168 Return the ..._DECL node that was associated with it. If there is no tree
169 node associated with GNAT_ENTITY, abort.
171 In some cases, such as delayed elaboration or expressions that need to
172 be elaborated only once, GNAT_ENTITY is really not an entity. */
174 tree
176 {
179 }
181 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
183 bool
185 {
187 }
189 \f
190 /* Return non-zero if we are currently in the global binding level. */
192 int
194 {
196 }
198 /* Enter a new binding level. */
200 void
202 {
205 /* Reuse a struct for this binding level, if there is one. */
207 {
210 }
211 else
212 newlevel
216 /* Use a free BLOCK, if any; otherwise, allocate one. */
218 {
222 }
223 else
226 /* Point the BLOCK we just made to its parent. */
233 /* Add this level to the front of the chain (stack) of levels that are
234 active. */
238 }
240 /* Set SUPERCONTEXT of the BLOCK for the current binding level to FNDECL
241 and point FNDECL to this BLOCK. */
243 void
245 {
248 }
250 /* Set the jmpbuf_decl for the current binding level to DECL. */
252 void
254 {
256 }
258 /* Get the jmpbuf_decl, if any, for the current binding level. */
260 tree
262 {
264 }
266 /* Exit a binding level. Set any BLOCK into the current code group. */
268 void
270 {
277 /* If this is a function-level BLOCK don't do anything. Otherwise, if there
278 are no variables free the block and merge its subblocks into those of its
279 parent block. Otherwise, add it to the list of its parent. */
281 ;
283 {
289 }
290 else
291 {
296 }
298 /* Free this binding structure. */
302 }
304 /* Insert BLOCK at the end of the list of subblocks of the
305 current binding level. This is used when a BIND_EXPR is expanded,
306 to handle the BLOCK node inside the BIND_EXPR. */
308 void
310 {
314 }
315 \f
316 /* Records a ..._DECL node DECL as belonging to the current lexical scope
317 and uses GNAT_NODE for location information and propagating flags. */
319 void
321 {
322 /* If at top level, there is no context. But PARM_DECLs always go in the
323 level of its function. */
326 else
327 {
330 /* Functions imported in another function are not really nested. */
333 }
337 /* Set the location of DECL and emit a declaration for it. */
342 /* Put the declaration on the list. The list of declarations is in reverse
343 order. The list will be reversed later. We don't do this for global
344 variables. Also, don't put TYPE_DECLs for UNCONSTRAINED_ARRAY_TYPE into
345 the list. They will cause trouble with the debugger and aren't needed
346 anyway. */
350 {
353 }
355 /* For the declaration of a type, set its name if it either is not already
356 set, was set to an IDENTIFIER_NODE, indicating an internal name,
357 or if the previous type name was not derived from a source name.
358 We'd rather have the type named with a real name and all the pointer
359 types to the same object have the same POINTER_TYPE node. Code in this
360 function in c-decl.c makes a copy of the type node here, but that may
361 cause us trouble with incomplete types, so let's not try it (at least
362 for now). */
373 /* if (TREE_CODE (decl) != CONST_DECL)
374 rest_of_decl_compilation (decl, global_bindings_p (), 0); */
375 }
376 \f
377 /* Do little here. Set up the standard declarations later after the
378 front end has been run. */
380 void
382 {
385 /* Make the binding_level structure for global names. */
393 /* In Ada, we use a signed type for SIZETYPE. Use the signed type
394 corresponding to the size of Pmode. In most cases when ptr_mode and
395 Pmode differ, C will use the width of ptr_mode as sizetype. But we get
396 far better code using the width of Pmode. Make this here since we need
397 this before we can expand the GNAT types. */
402 /* Give names and make TYPE_DECLs for common types. */
404 Empty);
406 integer_type_node),
407 Empty);
409 char_type_node),
410 Empty);
412 long_integer_type_node),
413 Empty);
418 }
420 /* Install the builtin functions the middle-end needs. */
422 static void
424 {
425 /* Builtins used by generic optimizers. */
428 /* Target specific builtins, such as the AltiVec family on ppc. */
430 }
432 /* Create the predefined scalar types such as `integer_type_node' needed
433 in the gcc back-end and initialize the global binding level. */
435 void
437 {
441 /* Set the types that GCC and Gigi use from the front end. We would like
442 to do this for char_type_node, but it needs to correspond to the C
443 char type. */
445 {
446 /* In this case, the builtin floating point types are VAX float,
447 so make up a type for use. */
453 }
454 else
465 Empty);
470 /* Now declare runtime functions. */
473 /* malloc is a function declaration tree for a function to allocate
474 memory. */
476 NULL_TREE,
479 sizetype,
480 endlink)),
482 Empty);
484 /* free is a function declaration tree for a function to free memory. */
485 free_decl
489 ptr_void_type_node,
490 endlink)),
493 /* Make the types and functions used for exception processing. */
494 jmpbuf_type
501 /* Functions to get and set the jumpbuf pointer for the current thread. */
502 get_jmpbuf_decl
503 = create_subprog_decl
508 set_jmpbuf_decl
509 = create_subprog_decl
511 NULL_TREE,
516 /* Function to get the current exception. */
517 get_excptr_decl
518 = create_subprog_decl
520 NULL_TREE,
524 /* Functions that raise exceptions. */
525 raise_nodefer_decl
526 = create_subprog_decl
531 endlink)),
534 /* Dummy objects to materialize "others" and "all others" in the exception
535 tables. These are exported by a-exexpr.adb, so see this unit for the
536 types to use. */
538 others_decl
543 all_others_decl
548 /* Hooks to call when entering/leaving an exception handler. */
549 begin_handler_decl
553 ptr_void_type_node,
554 endlink)),
557 end_handler_decl
561 ptr_void_type_node,
562 endlink)),
565 /* If in no exception handlers mode, all raise statements are redirected to
566 __gnat_last_chance_handler. No need to redefine raise_nodefer_decl, since
567 this procedure will never be called in this mode. */
569 {
570 decl
571 = create_subprog_decl
577 integer_type_node,
578 endlink))),
583 }
584 else
585 /* Otherwise, make one decl for each exception reason. */
587 {
592 = create_subprog_decl
596 build_pointer_type
599 integer_type_node,
600 endlink))),
602 }
604 /* Indicate that these never return. */
609 TYPE_QUAL_VOLATILE);
612 {
617 TYPE_QUAL_VOLATILE);
618 }
620 /* setjmp returns an integer and has one operand, which is a pointer to
621 a jmpbuf. */
622 setjmp_decl
623 = create_subprog_decl
632 /* update_setjmp_buf updates a setjmp buffer from the current stack pointer
633 address. */
634 update_setjmp_buf_decl
635 = create_subprog_decl
645 }
646 \f
647 /* Given a record type (RECORD_TYPE) and a chain of FIELD_DECL nodes
648 (FIELDLIST), finish constructing the record or union type. If HAS_REP is
649 true, this record has a rep clause; don't call layout_type but merely set
650 the size and alignment ourselves. If DEFER_DEBUG is true, do not call
651 the debugging routines on this type; it will be done later. */
653 void
656 {
663 tree field;
669 /* We don't need both the typedef name and the record name output in
670 the debugging information, since they are the same. */
673 /* Globally initialize the record first. If this is a rep'ed record,
674 that just means some initializations; otherwise, layout the record. */
677 {
686 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
687 out just like a UNION_TYPE, since the size will be fixed. */
690 }
691 else
692 {
693 /* Ensure there isn't a size already set. There can be in an error
694 case where there is a rep clause but all fields have errors and
695 no longer have a position. */
698 }
700 /* At this point, the position and size of each field is known. It was
701 either set before entry by a rep clause, or by laying out the type above.
703 We now run a pass over the fields (in reverse order for QUAL_UNION_TYPEs)
704 to compute the Ada size; the GCC size and alignment (for rep'ed records
705 that are not padding types); and the mode (for rep'ed records). We also
706 clear the DECL_BIT_FIELD indication for the cases we know have not been
707 handled yet, and adjust DECL_NONADDRESSABLE_P accordingly. */
713 {
720 /* We need to make an XVE/XVU record if any field has variable size,
721 whether or not the record does. For example, if we have a union,
722 it may be that all fields, rounded up to the alignment, have the
723 same size, in which case we'll use that size. But the debug
724 output routines (except Dwarf2) won't be able to output the fields,
725 so we need to make the special record. */
736 /* Clear DECL_BIT_FIELD for the cases layout_decl does not handle. */
742 /* If we still have DECL_BIT_FIELD set at this point, we know the field
743 is technically not addressable. Except that it can actually be
744 addressed if the field is BLKmode and happens to be properly
745 aligned. */
754 {
761 ada_size
769 /* Since we know here that all fields are sorted in order of
770 increasing bit position, the size of the record is one
771 higher than the ending bit of the last field processed
772 unless we have a rep clause, since in that case we might
773 have a field outside a QUAL_UNION_TYPE that has a higher ending
774 position. So use a MAX in that case. Also, if this field is a
775 QUAL_UNION_TYPE, we need to take into account the previous size in
776 the case of empty variants. */
777 ada_size
786 }
787 }
792 /* If this is a padding record, we never want to make the size smaller than
793 what was specified in it, if any. */
798 /* Now set any of the values we've just computed that apply. */
804 {
805 tree size_unit
808 bitsize_unit_node)));
817 }
821 }
823 /* Output the debug information associated to a record type. */
825 void
827 {
829 tree field;
833 {
834 /* We need to make an XVE/XVU record if any field has variable size,
835 whether or not the record does. For example, if we have a union,
836 it may be that all fields, rounded up to the alignment, have the
837 same size, in which case we'll use that size. But the debug
838 output routines (except Dwarf2) won't be able to output the fields,
839 so we need to make the special record. */
841 {
844 }
845 }
847 /* If this record is of variable size, rename it so that the
848 debugger knows it is and make a new, parallel, record
849 that tells the debugger how the record is laid out. See
850 exp_dbug.ads. But don't do this for records that are padding
851 since they confuse GDB. */
855 {
856 tree new_record_type
860 tree orig_id
863 tree new_id
868 tree old_field;
882 /* Now scan all the fields, replacing each field with a new
883 field corresponding to the new encoding. */
886 {
889 tree new_field;
893 tree pos;
895 /* See how the position was modified from the last position.
897 There are two basic cases we support: a value was added
898 to the last position or the last position was rounded to
899 a boundary and they something was added. Check for the
900 first case first. If not, see if there is any evidence
901 of rounding. If so, round the last position and try
902 again.
904 If this is a union, the position can be taken as zero. */
908 else
913 {
917 }
924 {
925 align
926 = tree_low_cst
930 }
932 pos))
933 {
937 }
939 /* If we can't compute a position, set it to zero.
941 ??? We really should abort here, but it's too much work
942 to get this correct for all cases. */
947 /* See if this type is variable-size and make a new type
948 and indicate the indirection if so. */
950 {
953 }
955 /* Make a new field name, if necessary. */
957 {
963 else
967 }
975 /* If old_field is a QUAL_UNION_TYPE, take its size as being
976 zero. The only time it's not the last field of the record
977 is when there are other components at fixed positions after
978 it (meaning there was a rep clause for every field) and we
979 want to be able to encode them. */
983 ? bitsize_zero_node
986 }
992 }
995 }
997 /* Utility function of above to merge LAST_SIZE, the previous size of a record
998 with FIRST_BIT and SIZE that describe a field. SPECIAL is nonzero
999 if this represents a QUAL_UNION_TYPE in which case we must look for
1000 COND_EXPRs and replace a value of zero with the old size. If HAS_REP
1001 is nonzero, we must take the MAX of the end position of this field
1002 with LAST_SIZE. In all other cases, we use FIRST_BIT plus SIZE.
1004 We return an expression for the size. */
1006 static tree
1009 {
1014 {
1018 }
1020 else
1031 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
1032 when fed through substitute_in_expr) into thinking that a constant
1033 size is not constant. */
1038 }
1040 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
1041 related by the addition of a constant. Return that constant if so. */
1043 static tree
1045 {
1055 else
1057 }
1059 /* Utility function of above to split a tree OP which may be a sum, into a
1060 constant part, which is returned, and a variable part, which is stored
1061 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
1062 bitsizetype. */
1064 static tree
1066 {
1067 /* Strip NOPS in order to ease the tree traversal and maximize the
1068 potential for constant or plus/minus discovery. We need to be careful
1069 to always return and set *pvar to bitsizetype trees, but it's worth
1070 the effort. */
1076 {
1079 }
1081 {
1092 }
1093 else
1095 }
1096 \f
1097 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
1098 subprogram. If it is void_type_node, then we are dealing with a procedure,
1099 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
1100 PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the
1101 copy-in/copy-out list to be stored into TYPE_CICO_LIST.
1102 RETURNS_UNCONSTRAINED is nonzero if the function returns an unconstrained
1103 object. RETURNS_BY_REF is nonzero if the function returns by reference.
1104 RETURNS_WITH_DSP is nonzero if the function is to return with a
1105 depressed stack pointer. RETURNS_BY_TARGET_PTR is true if the function
1106 is to be passed (as its first parameter) the address of the place to copy
1107 its result. */
1109 tree
1113 {
1114 /* A chain of TREE_LIST nodes whose TREE_VALUEs are the data type nodes of
1115 the subprogram formal parameters. This list is generated by traversing the
1116 input list of PARM_DECL nodes. */
1118 tree param_decl;
1119 tree type;
1124 param_type_list);
1126 /* The list of the function parameter types has to be terminated by the void
1127 type to signal to the back-end that we are not dealing with a variable
1128 parameter subprogram, but that the subprogram has a fixed number of
1129 parameters. */
1132 /* The list of argument types has been created in reverse
1133 so nreverse it. */
1138 /* TYPE may have been shared since GCC hashes types. If it has a CICO_LIST
1139 or the new type should, make a copy of TYPE. Likewise for
1140 RETURNS_UNCONSTRAINED and RETURNS_BY_REF. */
1153 }
1154 \f
1155 /* Return a copy of TYPE but safe to modify in any way. */
1157 tree
1159 {
1162 /* copy_node clears this field instead of copying it, because it is
1163 aliased with TREE_CHAIN. */
1172 }
1173 \f
1174 /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
1175 TYPE_INDEX_TYPE is INDEX. */
1177 tree
1179 {
1180 /* First build a type for the desired range. */
1183 /* If this type has the TYPE_INDEX_TYPE we want, return it. Otherwise, if it
1184 doesn't have TYPE_INDEX_TYPE set, set it to INDEX. If TYPE_INDEX_TYPE
1185 is set, but not to INDEX, make a copy of this type with the requested
1186 index type. Note that we have no way of sharing these types, but that's
1187 only a small hole. */
1196 }
1197 \f
1198 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type (a character
1199 string) and TYPE is a ..._TYPE node giving its data type.
1200 ARTIFICIAL_P is true if this is a declaration that was generated
1201 by the compiler. DEBUG_INFO_P is true if we need to write debugging
1202 information about this type. GNAT_NODE is used for the position of
1203 the decl. */
1205 tree
1208 {
1216 /* Pass type declaration information to the debugger unless this is an
1217 UNCONSTRAINED_ARRAY_TYPE, which the debugger does not support,
1218 and ENUMERAL_TYPE or RECORD_TYPE which is handled separately,
1219 a dummy type, which will be completed later, or a type for which
1220 debugging information was not requested. */
1233 }
1235 /* Returns a GCC VAR_DECL node. VAR_NAME gives the name of the variable.
1236 ASM_NAME is its assembler name (if provided). TYPE is its data type
1237 (a GCC ..._TYPE node). VAR_INIT is the GCC tree for an optional initial
1238 expression; NULL_TREE if none.
1240 CONST_FLAG is true if this variable is constant.
1242 PUBLIC_FLAG is true if this definition is to be made visible outside of
1243 the current compilation unit. This flag should be set when processing the
1244 variable definitions in a package specification. EXTERN_FLAG is nonzero
1245 when processing an external variable declaration (as opposed to a
1246 definition: no storage is to be allocated for the variable here).
1248 STATIC_FLAG is only relevant when not at top level. In that case
1249 it indicates whether to always allocate storage to the variable.
1251 GNAT_NODE is used for the position of the decl. */
1253 tree
1257 {
1258 bool init_const
1259 = (!var_init
1266 tree var_decl
1268 /* Only make a CONST_DECL for sufficiently-small objects.
1269 We consider complex double "sufficiently-small" */
1276 /* If this is external, throw away any initializations unless this is a
1277 CONST_DECL (meaning we have a constant); they will be done elsewhere.
1278 If we are defining a global here, leave a constant initialization and
1279 save any variable elaborations for the elaboration routine. If we are
1280 just annotating types, throw away the initialization if it isn't a
1281 constant. */
1286 /* At the global level, an initializer requiring code to be generated
1287 produces elaboration statements. Check that such statements are allowed,
1288 that is, not violating a No_Elaboration_Code restriction. */
1292 /* Ada doesn't feature Fortran-like COMMON variables so we shouldn't
1293 try to fiddle with DECL_COMMON. However, on platforms that don't
1294 support global BSS sections, uninitialized global variables would
1295 go in DATA instead, thus increasing the size of the executable. */
1296 #if !defined(ASM_OUTPUT_BSS) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1299 #endif
1308 /* If it's public and not external, always allocate storage for it.
1309 At the global binding level we need to allocate static storage for the
1310 variable if and only if it's not external. If we are not at the top level
1311 we allocate automatic storage unless requested not to. */
1320 /* Add this decl to the current binding level. */
1328 else
1329 /* expand CONST_DECLs to set their MODE, ALIGN, SIZE and SIZE_UNIT,
1330 which we need for later back-annotations. */
1334 }
1335 \f
1336 /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
1337 type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
1338 this field is in a record type with a "pragma pack". If SIZE is nonzero
1339 it is the specified size for this field. If POS is nonzero, it is the bit
1340 position. If ADDRESSABLE is nonzero, it means we are allowed to take
1341 the address of this field for aliasing purposes. If it is negative, we
1342 should not make a bitfield, which is used by make_aligning_type. */
1344 tree
1347 {
1353 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
1354 byte boundary since GCC cannot handle less-aligned BLKmode bitfields. */
1358 /* If a size is specified, use it. Otherwise, if the record type is packed
1359 compute a size to use, which may differ from the object's natural size.
1360 We always set a size in this case to trigger the checks for bitfield
1361 creation below, which is typically required when no position has been
1362 specified. */
1366 {
1369 /* For a constant size larger than MAX_FIXED_MODE_SIZE, round up to
1370 byte. */
1374 }
1376 /* If we may, according to ADDRESSABLE, make a bitfield if a size is
1377 specified for two reasons: first if the size differs from the natural
1378 size. Second, if the alignment is insufficient. There are a number of
1379 ways the latter can be true.
1381 We never make a bitfield if the type of the field has a nonconstant size,
1382 because no such entity requiring bitfield operations should reach here.
1384 We do *preventively* make a bitfield when there might be the need for it
1385 but we don't have all the necessary information to decide, as is the case
1386 of a field with no specified position in a packed record.
1388 We also don't look at STRICT_ALIGNMENT here, and rely on later processing
1389 in layout_decl or finish_record_type to clear the bit_field indication if
1390 it is in fact not needed. */
1392 && size
1397 || packed
1400 {
1408 }
1418 {
1419 /* We need to pass in the alignment the DECL is known to have.
1420 This is the lowest-order bit set in POS, but no more than
1421 the alignment of the record, if one is specified. Note
1422 that an alignment of 0 is taken as infinite. */
1427 else
1443 }
1445 /* If the field type is passed by reference, we will have pointers to the
1446 field, so it is addressable. */
1450 /* ??? For now, we say that any field of aggregate type is addressable
1451 because the front end may take 'Reference of it. */
1455 /* Mark the decl as nonaddressable if it is indicated so semantically,
1456 meaning we won't ever attempt to take the address of the field.
1458 It may also be "technically" nonaddressable, meaning that even if we
1459 attempt to take the field's address we will actually get the address of a
1460 copy. This is the case for true bitfields, but the DECL_BIT_FIELD value
1461 we have at this point is not accurate enough, so we don't account for
1462 this here and let finish_record_type decide. */
1466 }
1468 /* Subroutine of previous function: return nonzero if EXP, ignoring any side
1469 effects, has the value of zero. */
1471 static bool
1473 {
1478 }
1479 \f
1480 /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
1481 PARAM_TYPE is its type. READONLY is true if the parameter is
1482 readonly (either an IN parameter or an address of a pass-by-ref
1483 parameter). */
1485 tree
1487 {
1490 /* Honor targetm.calls.promote_prototypes(), as not doing so can
1491 lead to various ABI violations. */
1496 {
1497 /* We have to be careful about biased types here. Make a subtype
1498 of integer_type_node with the proper biasing. */
1501 {
1502 param_type
1508 }
1509 else
1511 }
1516 }
1517 \f
1518 /* Given a DECL and ATTR_LIST, process the listed attributes. */
1520 void
1522 {
1525 {
1528 NULL_TREE),
1529 ATTR_FLAG_TYPE_IN_PLACE);
1534 {
1537 }
1543 else
1550 {
1555 }
1556 else
1570 }
1571 }
1572 \f
1573 /* Return true if VALUE is a known to be a multiple of FACTOR, which must be
1574 a power of 2. */
1576 static bool
1578 {
1587 }
1589 /* Given 2 consecutive field decls PREV_FIELD and CURR_FIELD, return true
1590 unless we can prove these 2 fields are laid out in such a way that no gap
1591 exist between the end of PREV_FIELD and the beginning of CURR_FIELD. OFFSET
1592 is the distance in bits between the end of PREV_FIELD and the starting
1593 position of CURR_FIELD. It is ignored if null. */
1595 static bool
1597 {
1598 /* If this is the first field of the record, there cannot be any gap */
1602 /* If the previous field is a union type, then return False: The only
1603 time when such a field is not the last field of the record is when
1604 there are other components at fixed positions after it (meaning there
1605 was a rep clause for every field), in which case we don't want the
1606 alignment constraint to override them. */
1610 /* If the distance between the end of prev_field and the beginning of
1611 curr_field is constant, then there is a gap if the value of this
1612 constant is not null. */
1616 /* If the size and position of the previous field are constant,
1617 then check the sum of this size and position. There will be a gap
1618 iff it is not multiple of the current field alignment. */
1625 /* If both the position and size of the previous field are multiples
1626 of the current field alignment, there cannot be any gap. */
1631 /* Fallback, return that there may be a potential gap */
1633 }
1635 /* Returns a LABEL_DECL node for LABEL_NAME. */
1637 tree
1639 {
1647 }
1648 \f
1649 /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
1650 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
1651 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
1652 PARM_DECL nodes chained through the TREE_CHAIN field).
1654 INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the
1655 appropriate fields in the FUNCTION_DECL. GNAT_NODE gives the location. */
1657 tree
1662 {
1666 /* If this is a function nested inside an inlined external function, it
1667 means we aren't going to compile the outer function unless it is
1668 actually inlined, so do the same for us. */
1692 /* Add this decl to the current binding level. */
1695 /* Output the assembler code and/or RTL for the declaration. */
1699 }
1700 \f
1701 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
1702 body. This routine needs to be invoked before processing the declarations
1703 appearing in the subprogram. */
1705 void
1707 {
1708 tree param_decl;
1713 /* Enter a new binding level and show that all the parameters belong to
1714 this function. */
1722 /* We handle pending sizes via the elaboration of types, so we don't need to
1723 save them. This causes them to be marked as part of the outer function
1724 and then discarded. */
1726 }
1728 /* Finish the definition of the current subprogram and compile it all the way
1729 to assembler language output. BODY is the tree corresponding to
1730 the subprogram. */
1732 void
1734 {
1737 /* Mark the BLOCK for this level as being for this function and pop the
1738 level. Since the vars in it are the parameters, clear them. */
1744 /* Deal with inline. If declared inline or we should default to inline,
1745 set the flag in the decl. */
1749 /* We handle pending sizes via the elaboration of types, so we don't
1750 need to save them. */
1753 /* Mark the RESULT_DECL as being in this subprogram. */
1761 /* If we're only annotating types, don't actually compile this function. */
1765 /* If we don't have .ctors/.dtors sections, and this is a static
1766 constructor or destructor, it must be recorded now. */
1773 /* We do different things for nested and non-nested functions.
1774 ??? This should be in cgraph. */
1776 {
1779 }
1780 else
1781 /* Register this function with cgraph just far enough to get it
1782 added to our parent's nested function list. */
1784 }
1786 /* Convert FNDECL's code to GIMPLE and handle any nested functions. */
1788 static void
1790 {
1797 /* Convert all nested functions to GIMPLE now. We do things in this order
1798 so that items like VLA sizes are expanded properly in the context of the
1799 correct function. */
1803 }
1804 \f
1805 /* Return a definition for a builtin function named NAME and whose data type
1806 is TYPE. TYPE should be a function type with argument types.
1807 FUNCTION_CODE tells later passes how to compile calls to this function.
1808 See tree.h for its possible values.
1810 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
1811 the name to be called if we can't opencode the function. If
1812 ATTRS is nonzero, use that for the function attribute list. */
1814 tree
1817 tree attrs)
1818 {
1832 }
1834 /* Return an integer type with the number of bits of precision given by
1835 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
1836 it is a signed type. */
1838 tree
1840 {
1841 tree t;
1850 else
1857 {
1860 }
1863 }
1865 /* Likewise for floating-point types. */
1867 static tree
1869 {
1870 tree t;
1882 {
1885 }
1888 }
1890 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
1891 an unsigned type; otherwise a signed type is returned. */
1893 tree
1895 {
1906 else
1908 }
1910 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
1912 tree
1914 {
1918 {
1921 }
1925 {
1928 }
1931 }
1933 /* Return the signed version of a TYPE_NODE, a scalar type. */
1935 tree
1937 {
1941 {
1944 }
1948 {
1951 }
1954 }
1956 /* Return a type the same as TYPE except unsigned or signed according to
1957 UNSIGNEDP. */
1959 tree
1961 {
1964 else
1966 }
1967 \f
1968 /* EXP is an expression for the size of an object. If this size contains
1969 discriminant references, replace them with the maximum (if MAX_P) or
1970 minimum (if !MAX_P) possible value of the discriminant. */
1972 tree
1974 {
1979 {
1993 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
1994 modify. Otherwise, we treat it like a variable. */
1999 return
2009 {
2013 else
2014 return
2023 {
2028 /* Special-case wanting the maximum value of a MIN_EXPR.
2029 In that case, if one side overflows, return the other.
2030 sizetype is signed, but we know sizes are non-negative.
2031 Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
2032 overflowing or the maximum possible value and the RHS
2033 a variable. */
2050 else
2052 }
2064 }
2066 /* Other tree classes cannot happen. */
2069 }
2072 }
2073 \f
2074 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
2075 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
2076 Return a constructor for the template. */
2078 tree
2080 {
2083 tree field;
2095 /* First make the list for a CONSTRUCTOR for the template. Go down the
2096 field list of the template instead of the type chain because this
2097 array might be an Ada array of arrays and we can't tell where the
2098 nested arrays stop being the underlying object. */
2101 (bound_list
2105 {
2108 /* If we have a bound list, get the bounds from there. Likewise
2109 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
2110 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
2111 This will give us a maximum range. */
2119 else
2125 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
2126 substitute it from OBJECT. */
2132 }
2135 }
2136 \f
2137 /* Build a VMS descriptor from a Mechanism_Type, which must specify
2138 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2139 in the type contains in its DECL_INITIAL the expression to use when
2140 a constructor is made for the type. GNAT_ENTITY is an entity used
2141 to print out an error message if the mechanism cannot be applied to
2142 an object of that type and also for the name. */
2144 tree
2146 {
2151 tree inner_type;
2155 tree tem;
2157 /* If TYPE is an unconstrained array, use the underlying array type. */
2161 /* If this is an array, compute the number of dimensions in the array,
2162 get the index types, and point to the inner type. */
2165 else
2170 ;
2180 else
2186 /* Now get the DTYPE value. */
2188 {
2193 {
2203 }
2204 else
2206 {
2222 }
2233 {
2242 }
2243 else
2253 }
2255 /* Get the CLASS value. */
2257 {
2269 }
2271 /* Make the type for a descriptor for VMS. The first four fields
2272 are the same for all types. */
2274 field_list
2276 make_descriptor_field
2289 field_list
2291 make_descriptor_field
2299 {
2305 field_list
2307 make_descriptor_field
2311 field_list
2313 make_descriptor_field
2324 record_type,
2325 size_zero_node));
2330 record_type,
2331 size_zero_node));
2333 field_list
2335 make_descriptor_field
2339 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
2347 record_type,
2353 record_type,
2356 /* Now build a pointer to the 0,0,0... element. */
2364 field_list
2366 make_descriptor_field
2369 record_type,
2373 tem)));
2375 /* Next come the addressing coefficients. */
2378 {
2380 tree idx_length
2390 field_list
2398 }
2400 /* Finally here are the bounds. */
2402 {
2406 field_list
2408 make_descriptor_field
2413 field_list
2415 make_descriptor_field
2418 }
2423 }
2430 }
2432 /* Utility routine for above code to make a field. */
2434 static tree
2437 {
2438 tree field
2443 }
2444 \f
2445 /* Build a type to be used to represent an aliased object whose nominal
2446 type is an unconstrained array. This consists of a RECORD_TYPE containing
2447 a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an
2448 ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this
2449 is used to represent an arbitrary unconstrained object. Use NAME
2450 as the name of the record. */
2452 tree
2454 {
2465 array_field),
2469 }
2471 /* Same, taking a thin or fat pointer type instead of a template type. */
2473 tree
2475 {
2476 tree template_type;
2480 template_type
2485 }
2486 \f
2487 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In
2488 the normal case this is just two adjustments, but we have more to do
2489 if NEW is an UNCONSTRAINED_ARRAY_TYPE. */
2491 void
2493 {
2497 tree type;
2499 /* If this is the main variant, process all the other variants first. */
2505 /* If no pointer or reference, we are done. */
2509 /* Merge the old type qualifiers in the new type.
2511 Each old variant has qualifiers for specific reasons, and the new
2512 designated type as well. Each set of qualifiers represents useful
2513 information grabbed at some point, and merging the two simply unifies
2514 these inputs into the final type description.
2516 Consider for instance a volatile type frozen after an access to constant
2517 type designating it. After the designated type freeze, we get here with a
2518 volatile new_type and a dummy old_type with a readonly variant, created
2519 when the access type was processed. We shall make a volatile and readonly
2520 designated type, because that's what it really is.
2522 We might also get here for a non-dummy old_type variant with different
2523 qualifiers than the new_type ones, for instance in some cases of pointers
2524 to private record type elaboration (see the comments around the call to
2525 this routine from gnat_to_gnu_entity/E_Access_Type). We have to merge the
2526 qualifiers in thoses cases too, to avoid accidentally discarding the
2527 initial set, and will often end up with old_type == new_type then. */
2532 /* If the new type and the old one are identical, there is nothing to
2533 update. */
2537 /* Otherwise, first handle the simple case. */
2539 {
2552 }
2554 /* Now deal with the unconstrained array case. In this case the "pointer"
2555 is actually a RECORD_TYPE where the types of both fields are
2556 pointers to void. In that case, copy the field list from the
2557 old type to the new one and update the fields' context. */
2561 else
2562 {
2564 tree ptr_temp_type;
2565 tree new_ref;
2566 tree var;
2578 /* Rework the PLACEHOLDER_EXPR inside the reference to the
2579 template bounds.
2581 ??? This is now the only use of gnat_substitute_in_type, which
2582 is now a very "heavy" routine to do this, so it should be replaced
2583 at some point. */
2589 update_pointer_to
2600 /* Now handle updating the allocation record, what the thin pointer
2601 points to. Update all pointers from the old record into the new
2602 one, update the types of the fields, and recompute the size. */
2623 }
2624 }
2625 \f
2626 /* Convert a pointer to a constrained array into a pointer to a fat
2627 pointer. This involves making or finding a template. */
2629 static tree
2631 {
2636 /* If EXPR is a constant of zero, we make a fat pointer that has a null
2637 pointer to the template and array. */
2639 return
2640 gnat_build_constructor
2646 expr),
2647 NULL_TREE)));
2649 /* If EXPR is a thin pointer, make the template and data from the record. */
2652 {
2658 else
2665 }
2666 else
2667 /* Otherwise, build the constructor for the template. */
2672 /* The result is a CONSTRUCTOR for the fat pointer.
2674 If expr is an argument of a foreign convention subprogram, the type it
2675 points to is directly the component type. In this case, the expression
2676 type may not match the corresponding FIELD_DECL type at this point, so we
2677 call "convert" here to fix that up if necessary. This type consistency is
2678 required, for instance because it ensures that possible later folding of
2679 component_refs against this constructor always yields something of the
2680 same type as the initial reference.
2682 Note that the call to "build_template" above is still fine, because it
2683 will only refer to the provided template_type in this case. */
2684 return
2685 gnat_build_constructor
2690 }
2691 \f
2692 /* Convert to a thin pointer type, TYPE. The only thing we know how to convert
2693 is something that is a fat pointer, so convert to it first if it EXPR
2694 is not already a fat pointer. */
2696 static tree
2698 {
2700 expr
2701 = convert_to_fat_pointer
2704 /* We get the pointer to the data and use a NOP_EXPR to make it the
2705 proper GCC type. */
2711 }
2712 \f
2713 /* Create an expression whose value is that of EXPR,
2714 converted to type TYPE. The TREE_TYPE of the value
2715 is always TYPE. This function implements all reasonable
2716 conversions; callers should filter out those that are
2717 not permitted by the language being compiled. */
2719 tree
2721 {
2725 tree tem;
2727 /* If EXPR is already the right type, we are done. */
2731 /* If the input type has padding, remove it by doing a component reference
2732 to the field. If the output type has padding, make a constructor
2733 to build the record. If both input and output have padding and are
2734 of variable size, do this as an unchecked conversion. */
2739 ;
2741 {
2742 /* If we have just converted to this padded type, just get
2743 the inner expression. */
2749 else
2753 }
2755 {
2756 /* If we previously converted from another type and our type is
2757 of variable size, remove the conversion to avoid the need for
2758 variable-size temporaries. */
2763 /* If we are just removing the padding from expr, convert the original
2764 object if we have variable size. That will avoid the need
2765 for some variable-size temporaries. */
2772 /* If the result type is a padded type with a self-referentially-sized
2773 field and the expression type is a record, do this as an
2774 unchecked conversion. */
2779 else
2780 return
2785 expr),
2786 NULL_TREE));
2787 }
2789 /* If the input is a biased type, adjust first. */
2793 expr),
2796 /* If the input is a justified modular type, we need to extract the actual
2797 object before converting it to any other type with the exceptions of an
2798 unconstrained array or of a mere type variant. It is useful to avoid the
2799 extraction and conversion in the type variant case because it could end
2800 up replacing a VAR_DECL expr by a constructor and we might be about the
2801 take the address of the result. */
2808 /* If converting to a type that contains a template, convert to the data
2809 type and then build the template. */
2811 {
2814 /* If the source already has a template, get a reference to the
2815 associated array only, as we are going to rebuild a template
2816 for the target type anyway. */
2819 return
2820 gnat_build_constructor
2827 }
2829 /* There are some special cases of expressions that we process
2830 specially. */
2832 {
2837 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
2838 conversion in gnat_expand_expr. NULL_EXPR does not represent
2839 and actual value, so no conversion is needed. */
2845 /* If we are converting a STRING_CST to another constrained array type,
2846 just make a new one in the proper type. */
2850 {
2854 }
2858 /* Convert this to the type of the inner array by getting the address of
2859 the array from the template. */
2869 {
2870 /* GCC 4.x is very sensitive to type consistency overall, and view
2871 conversions thus are very frequent. Eventhough just "convert"ing
2872 the inner operand to the output type is fine in most cases, it
2873 might expose unexpected input/output type mismatches in special
2874 circumstances so we avoid such recursive calls when we can. */
2878 /* If we are converting back to the original type, we can just
2879 lift the input conversion. This is a common occurence with
2880 switches back-and-forth amongst type variants. */
2884 /* Otherwise, if we're converting between two aggregate types, we
2885 might be allowed to substitute the VIEW_CONVERT target type in
2886 place or to just convert the inner expression. */
2888 {
2889 /* If we are converting between type variants, we can just
2890 substitute the VIEW_CONVERT in place. */
2894 /* Otherwise, we may just bypass the input view conversion unless
2895 one of the types is a fat pointer, or we're converting to an
2896 unchecked union type. Both are handled by specialized code
2897 below and the latter relies on exact type matching. */
2901 }
2902 }
2906 /* If both types are record types, just convert the pointer and
2907 make a new INDIRECT_REF.
2909 ??? Disable this for now since it causes problems with the
2910 code in build_binary_op for MODIFY_EXPR which wants to
2911 strip off conversions. But that code really is a mess and
2912 we need to do this a much better way some time. */
2926 }
2928 /* Check for converting to a pointer to an unconstrained array. */
2932 /* If we're converting between two aggregate types that have the same main
2933 variant, just make a VIEW_CONVER_EXPR. */
2938 /* In all other cases of related types, make a NOP_EXPR. */
2945 {
2963 /* ... fall through ... */
2970 /* If converting between two pointers to records denoting
2971 both a template and type, adjust if needed to account
2972 for any differing offsets, since one might be negative. */
2974 {
2975 tree bit_diff
2988 }
2990 /* If converting to a thin pointer, handle specially. */
2995 /* If converting fat pointer to normal pointer, get the pointer to the
2996 array and then convert it. */
3008 return
3009 gnat_build_constructor
3012 NULL_TREE));
3014 /* ... fall through ... */
3017 /* In these cases, assume the front-end has validated the conversion.
3018 If the conversion is valid, it will be a bit-wise conversion, so
3019 it can be viewed as an unchecked conversion. */
3023 /* For unchecked unions, just validate that the type is indeed that of
3024 a field of the type. Then make the simple conversion. */
3026 {
3028 {
3037 }
3040 }
3041 else
3042 /* Otherwise, this is a conversion between a tagged type and some
3043 subtype, which we have to mark as a UNION_TYPE because of
3044 overlapping fields. */
3048 /* If EXPR is a constrained array, take its address, convert it to a
3049 fat pointer, and then dereference it. Likewise if EXPR is a
3050 record containing both a template and a constrained array.
3051 Note that a record representing a justified modular type
3052 always represents a packed constrained array. */
3057 return
3058 build_unary_op
3064 /* Do something very similar for converting one unconstrained
3065 array to another. */
3067 return
3072 else
3080 }
3081 }
3082 \f
3083 /* Remove all conversions that are done in EXP. This includes converting
3084 from a padded type or to a justified modular type. If TRUE_ADDRESS
3085 is true, always return the address of the containing object even if
3086 the address is not bit-aligned. */
3088 tree
3090 {
3092 {
3097 return
3115 }
3118 }
3119 \f
3120 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
3121 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
3122 likewise return an expression pointing to the underlying array. */
3124 tree
3126 {
3131 {
3134 {
3135 new
3142 }
3151 /* If this is a padded type, convert to the unpadded type and see if
3152 it contains a template. */
3154 {
3158 return
3162 }
3164 return
3171 }
3174 }
3175 \f
3176 /* Return an expression that does an unchecked conversion of EXPR to TYPE.
3177 If NOTRUNC_P is true, truncation operations should be suppressed. */
3179 tree
3181 {
3184 /* If the expression is already the right type, we are done. */
3188 /* If both types types are integral just do a normal conversion.
3189 Likewise for a conversion to an unconstrained array. */
3203 {
3208 {
3214 }
3218 {
3222 }
3227 }
3229 /* If we are converting TO an integral type whose precision is not the
3230 same as its size, first unchecked convert to a record that contains
3231 an object of the output type. Then extract the field. */
3235 {
3245 }
3247 /* Similarly for integral input type whose precision is not equal to its
3248 size. */
3252 {
3254 tree field
3263 }
3265 /* We have a special case when we are converting between two
3266 unconstrained array types. In that case, take the address,
3267 convert the fat pointer types, and dereference. */
3273 expr)));
3274 else
3275 {
3278 /* There's no point in doing two unchecked conversions in a row. */
3284 }
3286 /* If the result is an integral type whose size is not equal to
3287 the size of the underlying machine type, sign- or zero-extend
3288 the result. We need not do this in the case where the input is
3289 an integral type of the same precision and signedness or if the output
3290 is a biased type or if both the input and output are unsigned. */
3304 {
3307 tree shift_expr
3310 bitsize_int
3313 expr
3318 shift_expr),
3319 shift_expr));
3320 }
3322 /* An unchecked conversion should never raise Constraint_Error. The code
3323 below assumes that GCC's conversion routines overflow the same way that
3324 the underlying hardware does. This is probably true. In the rare case
3325 when it is false, we can rely on the fact that such conversions are
3326 erroneous anyway. */
3330 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
3331 show no longer constant. */
3334 OEP_ONLY_CONST))
3338 }
3339 \f
3340 /* Search the chain of currently reachable declarations for a builtin
3341 FUNCTION_DECL node corresponding to function NAME (an IDENTIFIER_NODE).
3342 Return the first node found, if any, or NULL_TREE otherwise. */
3344 tree
3346 {
3347 /* ??? not clear yet how to implement this function in tree-ssa, so
3348 return NULL_TREE for now */
3350 }