| blob | 423634ea64d05c92d2fcd1ff283d1019ddba47da |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2003, 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, 59 Temple Place - Suite 330, Boston, *
20 * MA 02111-1307, 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 ****************************************************************************/
54 #ifndef MAX_FIXED_MODE_SIZE
55 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
56 #endif
58 #ifndef MAX_BITS_PER_WORD
59 #define MAX_BITS_PER_WORD BITS_PER_WORD
60 #endif
62 /* If nonzero, pretend we are allocating at global level. */
65 /* Tree nodes for the various types and decls we create. */
68 /* Functions to call for each of the possible raise reasons. */
71 /* Associates a GNAT tree node to a GCC tree node. It is used in
72 `save_gnu_tree', `get_gnu_tree' and `present_gnu_tree'. See documentation
73 of `save_gnu_tree' for more info. */
76 /* This listhead is used to record any global objects that need elaboration.
77 TREE_PURPOSE is the variable to be elaborated and TREE_VALUE is the
78 initial value to assign. */
82 /* This stack allows us to momentarily switch to generating elaboration
83 lists for an inner context. */
87 tree elab_list;
88 };
91 /* This variable keeps a table for types for each precision so that we only
92 allocate each of them once. Signed and unsigned types are kept separate.
94 Note that these types are only used when fold-const requests something
95 special. Perhaps we should NOT share these types; we'll see how it
96 goes later. */
99 /* Likewise for float types, but record these by mode. */
102 /* For each binding contour we allocate a binding_level structure which records
103 the entities defined or declared in that contour. Contours include:
105 the global one
106 one for each subprogram definition
107 one for each compound statement (declare block)
109 Binding contours are used to create GCC tree BLOCK nodes. */
112 {
113 /* A chain of ..._DECL nodes for all variables, constants, functions,
114 parameters and type declarations. These ..._DECL nodes are chained
115 through the TREE_CHAIN field. Note that these ..._DECL nodes are stored
116 in the reverse of the order supplied to be compatible with the
117 back-end. */
118 tree names;
119 /* For each level (except the global one), a chain of BLOCK nodes for all
120 the levels that were entered and exited one level down from this one. */
121 tree blocks;
122 /* The BLOCK node for this level, if one has been preallocated.
123 If 0, the BLOCK is allocated (if needed) when the level is popped. */
124 tree this_block;
125 /* The binding level containing this one (the enclosing binding level). */
127 };
129 /* The binding level currently in effect. */
132 /* A chain of binding_level structures awaiting reuse. */
135 /* The outermost binding level. This binding level is created when the
136 compiler is started and it will exist through the entire compilation. */
139 /* Binding level structures are initialized by copying this one. */
143 {
145 };
157 \f
158 /* Initialize the association of GNAT nodes to GCC trees. */
160 void
162 {
163 associate_gnat_to_gnu
167 }
169 /* GNAT_ENTITY is a GNAT tree node for an entity. GNU_DECL is the GCC tree
170 which is to be associated with GNAT_ENTITY. Such GCC tree node is always
171 a ..._DECL node. If NO_CHECK is nonzero, the latter check is suppressed.
173 If GNU_DECL is zero, a previous association is to be reset. */
175 void
177 {
178 /* Check that GNAT_ENTITY is not already defined and that it is being set
179 to something which is a decl. Raise gigi 401 if not. Usually, this
180 means GNAT_ENTITY is defined twice, but occasionally is due to some
181 Gigi problem. */
188 }
190 /* GNAT_ENTITY is a GNAT tree node for a defining identifier.
191 Return the ..._DECL node that was associated with it. If there is no tree
192 node associated with GNAT_ENTITY, abort.
194 In some cases, such as delayed elaboration or expressions that need to
195 be elaborated only once, GNAT_ENTITY is really not an entity. */
197 tree
199 {
204 }
206 /* Return nonzero if a GCC tree has been associated with GNAT_ENTITY. */
208 int
210 {
212 }
214 \f
215 /* Return non-zero if we are currently in the global binding level. */
217 int
219 {
222 }
224 /* Return the list of declarations in the current level. Note that this list
225 is in reverse order (it has to be so for back-end compatibility). */
227 tree
229 {
231 }
233 /* Nonzero if the current level needs to have a BLOCK made. */
235 int
237 {
239 }
241 /* Enter a new binding level. The input parameter is ignored, but has to be
242 specified for back-end compatibility. */
244 void
246 {
249 /* Reuse a struct for this binding level, if there is one. */
251 {
254 }
255 else
256 newlevel
261 /* Add this level to the front of the chain (stack) of levels that are
262 active. */
265 }
267 /* Exit a binding level.
268 Pop the level off, and restore the state of the identifier-decl mappings
269 that were in effect when this level was entered.
271 If KEEP is nonzero, this level had explicit declarations, so
272 and create a "block" (a BLOCK node) for the level
273 to record its declarations and subblocks for symbol table output.
275 If FUNCTIONBODY is nonzero, this level is the body of a function,
276 so create a block as if KEEP were set and also clear out all
277 label names.
279 If REVERSE is nonzero, reverse the order of decls before putting
280 them into the BLOCK. */
282 tree
284 {
285 /* Points to a GCC BLOCK tree node. This is the BLOCK node construted for the
286 binding level that we are about to exit and which is returned by this
287 routine. */
289 tree decl_chain;
290 tree decl_node;
292 tree subblock_node;
295 /* Reverse the list of XXXX_DECL nodes if desired. Note that the ..._DECL
296 nodes chained through the `names' field of current_binding_level are in
297 reverse order except for PARM_DECL node, which are explicitly stored in
298 the right order. */
299 current_binding_level->names
303 /* Output any nested inline functions within this block which must be
304 compiled because their address is needed. */
309 {
313 }
322 {
325 }
327 /* Record the BLOCK node just built as the subblock its enclosing scope. */
332 /* Clear out the meanings of the local variables of this level. */
337 /* If the identifier was used or addressed via a local extern decl,
338 don't forget that fact. */
340 {
345 }
347 {
348 /* Pop the current level, and free the structure for reuse. */
353 }
356 {
357 /* This is the top level block of a function. The ..._DECL chain stored
358 in BLOCK_VARS are the function's parameters (PARM_DECL nodes). Don't
359 leave them in the BLOCK because they are found in the FUNCTION_DECL
360 instead. */
363 }
365 {
367 current_binding_level->blocks
369 }
371 /* If we did not make a block for the level just exited, any blocks made for
372 inner levels (since they cannot be recorded as subblocks in that level)
373 must be carried forward so they will later become subblocks of something
374 else. */
376 current_binding_level->blocks
382 }
383 \f
384 /* Insert BLOCK at the end of the list of subblocks of the
385 current binding level. This is used when a BIND_EXPR is expanded,
386 to handle the BLOCK node inside the BIND_EXPR. */
388 void
390 {
392 current_binding_level->blocks
394 }
396 /* Set the BLOCK node for the innermost scope
397 (the one we are currently in). */
399 void
401 {
407 }
409 /* Records a ..._DECL node DECL as belonging to the current lexical scope.
410 Returns the ..._DECL node. */
412 tree
414 {
417 /* If at top level, there is no context. But PARM_DECLs always go in the
418 level of its function. */
420 {
423 }
424 else
425 {
428 }
430 /* Put the declaration on the list. The list of declarations is in reverse
431 order. The list will be reversed later if necessary. This needs to be
432 this way for compatibility with the back-end.
434 Don't put TYPE_DECLs for UNCONSTRAINED_ARRAY_TYPE into the list. They
435 will cause trouble with the debugger and aren't needed anyway. */
438 {
441 }
443 /* For the declaration of a type, set its name if it either is not already
444 set, was set to an IDENTIFIER_NODE, indicating an internal name,
445 or if the previous type name was not derived from a source name.
446 We'd rather have the type named with a real name and all the pointer
447 types to the same object have the same POINTER_TYPE node. Code in this
448 function in c-decl.c makes a copy of the type node here, but that may
449 cause us trouble with incomplete types, so let's not try it (at least
450 for now). */
462 }
463 \f
464 /* Do little here. Set up the standard declarations later after the
465 front end has been run. */
467 void
469 {
472 /* Make the binding_level structure for global names. */
481 /* In Ada, we use a signed type for SIZETYPE. Use the signed type
482 corresponding to the size of Pmode. In most cases when ptr_mode and
483 Pmode differ, C will use the width of ptr_mode as sizetype. But we get
484 far better code using the width of Pmode. Make this here since we need
485 this before we can expand the GNAT types. */
491 /* We need to make the integer type before doing anything else.
492 We stitch this in to the appropriate GNAT type later. */
494 integer_type_node));
496 char_type_node));
500 }
502 /* Create the predefined scalar types such as `integer_type_node' needed
503 in the gcc back-end and initialize the global binding level. */
505 void
507 {
511 /* Set the types that GCC and Gigi use from the front end. We would like
512 to do this for char_type_node, but it needs to correspond to the C
513 char type. */
515 {
516 /* In this case, the builtin floating point types are VAX float,
517 so make up a type for use. */
522 longest_float_type_node));
523 }
524 else
531 unsigned_type_node));
533 void_type_decl_node
535 void_type_node));
540 /* Now declare runtime functions. */
543 /* malloc is a function declaration tree for a function to allocate
544 memory. */
546 NULL_TREE,
549 sizetype,
550 endlink)),
553 /* free is a function declaration tree for a function to free memory. */
554 free_decl
558 ptr_void_type_node,
559 endlink)),
562 /* Make the types and functions used for exception processing. */
563 jmpbuf_type
569 /* Functions to get and set the jumpbuf pointer for the current thread. */
570 get_jmpbuf_decl
571 = create_subprog_decl
576 set_jmpbuf_decl
577 = create_subprog_decl
579 NULL_TREE,
584 /* Function to get the current exception. */
585 get_excptr_decl
586 = create_subprog_decl
588 NULL_TREE,
592 /* Functions that raise exceptions. */
593 raise_nodefer_decl
594 = create_subprog_decl
599 endlink)),
602 /* Hooks to call when entering/leaving an exception handler. */
603 begin_handler_decl
607 ptr_void_type_node,
608 endlink)),
611 end_handler_decl
615 ptr_void_type_node,
616 endlink)),
619 /* If in no exception handlers mode, all raise statements are redirected to
620 __gnat_last_chance_handler. No need to redefine raise_nodefer_decl, since
621 this procedure will never be called in this mode. */
623 {
624 decl
625 = create_subprog_decl
631 integer_type_node,
632 endlink))),
637 }
638 else
639 /* Otherwise, make one decl for each exception reason. */
641 {
646 = create_subprog_decl
650 build_pointer_type
653 integer_type_node,
654 endlink))),
656 }
658 /* Indicate that these never return. */
663 TYPE_QUAL_VOLATILE);
666 {
671 TYPE_QUAL_VOLATILE);
672 }
674 /* setjmp returns an integer and has one operand, which is a pointer to
675 a jmpbuf. */
676 setjmp_decl
677 = create_subprog_decl
687 }
688 \f
689 /* Given a record type (RECORD_TYPE) and a chain of FIELD_DECL
690 nodes (FIELDLIST), finish constructing the record or union type.
691 If HAS_REP is nonzero, this record has a rep clause; don't call
692 layout_type but merely set the size and alignment ourselves.
693 If DEFER_DEBUG is nonzero, do not call the debugging routines
694 on this type; it will be done later. */
696 void
698 tree fieldlist,
701 {
707 tree field;
714 else
717 record_type));
719 /* We don't need both the typedef name and the record name output in
720 the debugging information, since they are the same. */
723 /* Globally initialize the record first. If this is a rep'ed record,
724 that just means some initializations; otherwise, layout the record. */
727 {
731 {
734 }
735 /* For all-repped records with a size specified, lay the QUAL_UNION_TYPE
736 out just like a UNION_TYPE, since the size will be fixed. */
739 }
740 else
741 {
742 /* Ensure there isn't a size already set. There can be in an error
743 case where there is a rep clause but all fields have errors and
744 no longer have a position. */
747 }
749 /* At this point, the position and size of each field is known. It was
750 either set before entry by a rep clause, or by laying out the type
751 above. We now make a pass through the fields (in reverse order for
752 QUAL_UNION_TYPEs) to compute the Ada size; the GCC size and alignment
753 (for rep'ed records that are not padding types); and the mode (for
754 rep'ed records). */
760 {
766 /* We need to make an XVE/XVU record if any field has variable size,
767 whether or not the record does. For example, if we have an union,
768 it may be that all fields, rounded up to the alignment, have the
769 same size, in which case we'll use that size. But the debug
770 output routines (except Dwarf2) won't be able to output the fields,
771 so we need to make the special record. */
787 {
795 ada_size
805 /* Since we know here that all fields are sorted in order of
806 increasing bit position, the size of the record is one
807 higher than the ending bit of the last field processed
808 unless we have a rep clause, since in that case we might
809 have a field outside a QUAL_UNION_TYPE that has a higher ending
810 position. So use a MAX in that case. Also, if this field is a
811 QUAL_UNION_TYPE, we need to take into account the previous size in
812 the case of empty variants. */
813 ada_size
818 size_unit
825 }
826 }
831 /* If this is a padding record, we never want to make the size smaller than
832 what was specified in it, if any. */
835 {
838 }
840 /* Now set any of the values we've just computed that apply. */
846 {
850 {
855 }
858 }
861 {
862 /* If this record is of variable size, rename it so that the
863 debugger knows it is and make a new, parallel, record
864 that tells the debugger how the record is laid out. See
865 exp_dbug.ads. But don't do this for records that are padding
866 since they confuse GDB. */
870 {
871 tree new_record_type
875 tree new_id
880 tree old_field;
892 /* Now scan all the fields, replacing each field with a new
893 field corresponding to the new encoding. */
896 {
899 tree new_field;
903 tree pos;
905 /* See how the position was modified from the last position.
907 There are two basic cases we support: a value was added
908 to the last position or the last position was rounded to
909 a boundary and they something was added. Check for the
910 first case first. If not, see if there is any evidence
911 of rounding. If so, round the last position and try
912 again.
914 If this is a union, the position can be taken as zero. */
918 else
923 {
927 }
934 {
935 align
936 = tree_low_cst
940 }
942 pos))
943 {
947 }
949 /* If we can't compute a position, set it to zero.
951 ??? We really should abort here, but it's too much work
952 to get this correct for all cases. */
957 /* See if this type is variable-size and make a new type
958 and indicate the indirection if so. */
960 {
963 }
965 /* Make a new field name, if necessary. */
967 {
973 else
977 }
985 /* If old_field is a QUAL_UNION_TYPE, take its size as being
986 zero. The only time it's not the last field of the record
987 is when there are other components at fixed positions after
988 it (meaning there was a rep clause for every field) and we
989 want to be able to encode them. */
993 ? bitsize_zero_node
996 }
1002 }
1005 }
1006 }
1008 /* Utility function of above to merge LAST_SIZE, the previous size of a record
1009 with FIRST_BIT and SIZE that describe a field. SPECIAL is nonzero
1010 if this represents a QUAL_UNION_TYPE in which case we must look for
1011 COND_EXPRs and replace a value of zero with the old size. If HAS_REP
1012 is nonzero, we must take the MAX of the end position of this field
1013 with LAST_SIZE. In all other cases, we use FIRST_BIT plus SIZE.
1015 We return an expression for the size. */
1017 static tree
1019 tree first_bit,
1020 tree size,
1023 {
1028 {
1032 }
1034 else
1045 /* We don't need any NON_VALUE_EXPRs and they can confuse us (especially
1046 when fed through substitute_in_expr) into thinking that a constant
1047 size is not constant. */
1052 }
1054 /* Utility function of above to see if OP0 and OP1, both of SIZETYPE, are
1055 related by the addition of a constant. Return that constant if so. */
1057 static tree
1059 {
1069 else
1071 }
1073 /* Utility function of above to split a tree OP which may be a sum, into a
1074 constant part, which is returned, and a variable part, which is stored
1075 in *PVAR. *PVAR may be bitsize_zero_node. All operations must be of
1076 bitsizetype. */
1078 static tree
1080 {
1081 /* Strip NOPS in order to ease the tree traversal and maximize the
1082 potential for constant or plus/minus discovery. We need to be careful
1083 to always return and set *pvar to bitsizetype trees, but it's worth
1084 the effort. */
1090 {
1093 }
1095 {
1106 }
1107 else
1109 }
1110 \f
1111 /* Return a FUNCTION_TYPE node. RETURN_TYPE is the type returned by the
1112 subprogram. If it is void_type_node, then we are dealing with a procedure,
1113 otherwise we are dealing with a function. PARAM_DECL_LIST is a list of
1114 PARM_DECL nodes that are the subprogram arguments. CICO_LIST is the
1115 copy-in/copy-out list to be stored into TYPE_CICO_LIST.
1116 RETURNS_UNCONSTRAINED is nonzero if the function returns an unconstrained
1117 object. RETURNS_BY_REF is nonzero if the function returns by reference.
1118 RETURNS_WITH_DSP is nonzero if the function is to return with a
1119 depressed stack pointer. */
1121 tree
1123 tree param_decl_list,
1124 tree cico_list,
1128 {
1129 /* A chain of TREE_LIST nodes whose TREE_VALUEs are the data type nodes of
1130 the subprogram formal parameters. This list is generated by traversing the
1131 input list of PARM_DECL nodes. */
1133 tree param_decl;
1134 tree type;
1139 param_type_list);
1141 /* The list of the function parameter types has to be terminated by the void
1142 type to signal to the back-end that we are not dealing with a variable
1143 parameter subprogram, but that the subprogram has a fixed number of
1144 parameters. */
1147 /* The list of argument types has been created in reverse
1148 so nreverse it. */
1153 /* TYPE may have been shared since GCC hashes types. If it has a CICO_LIST
1154 or the new type should, make a copy of TYPE. Likewise for
1155 RETURNS_UNCONSTRAINED and RETURNS_BY_REF. */
1166 }
1167 \f
1168 /* Return a copy of TYPE but safe to modify in any way. */
1170 tree
1172 {
1175 /* copy_node clears this field instead of copying it, because it is
1176 aliased with TREE_CHAIN. */
1185 }
1186 \f
1187 /* Return an INTEGER_TYPE of SIZETYPE with range MIN to MAX and whose
1188 TYPE_INDEX_TYPE is INDEX. */
1190 tree
1192 {
1193 /* First build a type for the desired range. */
1196 /* If this type has the TYPE_INDEX_TYPE we want, return it. Otherwise, if it
1197 doesn't have TYPE_INDEX_TYPE set, set it to INDEX. If TYPE_INDEX_TYPE
1198 is set, but not to INDEX, make a copy of this type with the requested
1199 index type. Note that we have no way of sharing these types, but that's
1200 only a small hole. */
1208 }
1209 \f
1210 /* Return a TYPE_DECL node. TYPE_NAME gives the name of the type (a character
1211 string) and TYPE is a ..._TYPE node giving its data type.
1212 ARTIFICIAL_P is nonzero if this is a declaration that was generated
1213 by the compiler. DEBUG_INFO_P is nonzero if we need to write debugging
1214 information about this type. */
1216 tree
1218 tree type,
1222 {
1230 /* Pass type declaration information to the debugger unless this is an
1231 UNCONSTRAINED_ARRAY_TYPE, which the debugger does not support,
1232 and ENUMERAL_TYPE or RECORD_TYPE which is handled separately,
1233 a dummy type, which will be completed later, or a type for which
1234 debugging information was not requested. */
1244 }
1246 /* Returns a GCC VAR_DECL node. VAR_NAME gives the name of the variable.
1247 ASM_NAME is its assembler name (if provided). TYPE is its data type
1248 (a GCC ..._TYPE node). VAR_INIT is the GCC tree for an optional initial
1249 expression; NULL_TREE if none.
1251 CONST_FLAG is nonzero if this variable is constant.
1253 PUBLIC_FLAG is nonzero if this definition is to be made visible outside of
1254 the current compilation unit. This flag should be set when processing the
1255 variable definitions in a package specification. EXTERN_FLAG is nonzero
1256 when processing an external variable declaration (as opposed to a
1257 definition: no storage is to be allocated for the variable here).
1259 STATIC_FLAG is only relevant when not at top level. In that case
1260 it indicates whether to always allocate storage to the variable. */
1262 tree
1264 tree asm_name,
1265 tree type,
1266 tree var_init,
1272 {
1273 int init_const
1281 tree var_decl
1283 /* Only make a CONST_DECL for sufficiently-small objects.
1284 We consider complex double "sufficiently-small" */
1292 /* If this is external, throw away any initializations unless this is a
1293 CONST_DECL (meaning we have a constant); they will be done elsewhere. If
1294 we are defining a global here, leave a constant initialization and save
1295 any variable elaborations for the elaboration routine. Otherwise, if
1296 the initializing expression is not the same as TYPE, generate the
1297 initialization with an assignment statement, since it knows how
1298 to do the required adjustents. If we are just annotating types,
1299 throw away the initialization if it isn't a constant. */
1306 {
1309 }
1326 /* At the global binding level we need to allocate static storage for the
1327 variable if and only if its not external. If we are not at the top level
1328 we allocate automatic storage unless requested not to. */
1336 /* Add this decl to the current binding level and generate any
1337 needed code and RTL. */
1344 /* If this is volatile, force it into memory. */
1352 {
1353 /* If VAR_DECL has a padded type, convert it to the unpadded
1354 type so the assignment is done properly. */
1362 assign_init));
1363 }
1366 }
1367 \f
1368 /* Returns a FIELD_DECL node. FIELD_NAME the field name, FIELD_TYPE is its
1369 type, and RECORD_TYPE is the type of the parent. PACKED is nonzero if
1370 this field is in a record type with a "pragma pack". If SIZE is nonzero
1371 it is the specified size for this field. If POS is nonzero, it is the bit
1372 position. If ADDRESSABLE is nonzero, it means we are allowed to take
1373 the address of this field for aliasing purposes. */
1375 tree
1377 tree field_type,
1378 tree record_type,
1380 tree size,
1381 tree pos,
1383 {
1389 /* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
1390 byte boundary since GCC cannot handle less-aligned BLKmode bitfields. */
1394 /* If a size is specified, use it. Otherwise, see if we have a size
1395 to use that may differ from the natural size of the object. */
1399 {
1404 /* For a constant size larger than MAX_FIXED_MODE_SIZE, round up to
1405 byte. */
1409 }
1411 /* Make a bitfield if a size is specified for two reasons: first if the size
1412 differs from the natural size. Second, if the alignment is insufficient.
1413 There are a number of ways the latter can be true. But never make a
1414 bitfield if the type of the field has a nonconstant size. */
1423 || packed
1426 {
1434 }
1444 {
1445 /* We need to pass in the alignment the DECL is known to have.
1446 This is the lowest-order bit set in POS, but no more than
1447 the alignment of the record, if one is specified. Note
1448 that an alignment of 0 is taken as infinite. */
1453 else
1469 }
1471 /* If the field type is passed by reference, we will have pointers to the
1472 field, so it is addressable. */
1476 /* ??? For now, we say that any field of aggregate type is addressable
1477 because the front end may take 'Reference of it. */
1481 /* Mark the decl as nonaddressable if it either is indicated so semantically
1482 or if it is a bit field. */
1487 }
1489 /* Subroutine of previous function: return nonzero if EXP, ignoring any side
1490 effects, has the value of zero. */
1492 static int
1494 {
1499 }
1500 \f
1501 /* Returns a PARM_DECL node. PARAM_NAME is the name of the parameter,
1502 PARAM_TYPE is its type. READONLY is nonzero if the parameter is
1503 readonly (either an IN parameter or an address of a pass-by-ref
1504 parameter). */
1506 tree
1508 {
1511 /* Honor the PROMOTE_PROTOTYPES target macro, as not doing so can
1512 lead to various ABI violations. */
1513 #ifdef PROMOTE_PROTOTYPES
1517 {
1518 /* We have to be careful about biased types here. Make a subtype
1519 of integer_type_node with the proper biasing. */
1522 {
1523 param_type
1529 }
1530 else
1532 }
1533 #endif
1539 }
1540 \f
1541 /* Given a DECL and ATTR_LIST, process the listed attributes. */
1543 void
1545 {
1548 {
1551 NULL_TREE),
1552 ATTR_FLAG_TYPE_IN_PLACE);
1563 else
1569 #ifdef ASM_OUTPUT_SECTION_NAME
1574 #else
1577 #endif
1579 }
1580 }
1581 \f
1582 /* Add some pending elaborations on the list. */
1584 void
1586 {
1590 pending_elaborations
1592 }
1594 /* Obtain any pending elaborations and clear the old list. */
1596 tree
1598 {
1599 /* Each thing added to the list went on the end; we want it on the
1600 beginning. */
1605 }
1607 /* Return true if VALUE is a multiple of FACTOR. FACTOR must be a power
1608 of 2. */
1610 static int
1612 {
1621 }
1623 /* Given 2 consecutive field decls PREV_FIELD and CURR_FIELD, return true
1624 unless we can prove these 2 fields are laid out in such a way that no gap
1625 exist between the end of PREV_FIELD and the begining of CURR_FIELD. OFFSET
1626 is the distance in bits between the end of PREV_FIELD and the starting
1627 position of CURR_FIELD. It is ignored if null. */
1629 static int
1631 {
1632 /* If this is the first field of the record, there cannot be any gap */
1636 /* If the previous field is a union type, then return False: The only
1637 time when such a field is not the last field of the record is when
1638 there are other components at fixed positions after it (meaning there
1639 was a rep clause for every field), in which case we don't want the
1640 alignment constraint to override them. */
1644 /* If the distance between the end of prev_field and the begining of
1645 curr_field is constant, then there is a gap if the value of this
1646 constant is not null. */
1650 /* If the size and position of the previous field are constant,
1651 then check the sum of this size and position. There will be a gap
1652 iff it is not multiple of the current field alignment. */
1659 /* If both the position and size of the previous field are multiples
1660 of the current field alignment, there can not be any gap. */
1665 /* Fallback, return that there may be a potential gap */
1667 }
1669 /* Return nonzero if there are pending elaborations. */
1671 int
1673 {
1675 }
1677 /* Save a copy of the current pending elaboration list and make a new
1678 one. */
1680 void
1682 {
1689 }
1691 /* Pop the stack of pending elaborations. */
1693 void
1695 {
1700 }
1702 /* Return the current position in pending_elaborations so we can insert
1703 elaborations after that point. */
1705 tree
1707 {
1709 }
1711 /* Insert the current elaborations after ELAB, which is in some elaboration
1712 list. */
1714 void
1716 {
1720 {
1724 }
1725 }
1727 /* Returns a LABEL_DECL node for LABEL_NAME. */
1729 tree
1731 {
1739 }
1740 \f
1741 /* Returns a FUNCTION_DECL node. SUBPROG_NAME is the name of the subprogram,
1742 ASM_NAME is its assembler name, SUBPROG_TYPE is its type (a FUNCTION_TYPE
1743 node), PARAM_DECL_LIST is the list of the subprogram arguments (a list of
1744 PARM_DECL nodes chained through the TREE_CHAIN field).
1746 INLINE_FLAG, PUBLIC_FLAG, EXTERN_FLAG, and ATTR_LIST are used to set the
1747 appropriate fields in the FUNCTION_DECL. */
1749 tree
1751 tree asm_name,
1752 tree subprog_type,
1753 tree param_decl_list,
1758 {
1762 /* If this is a function nested inside an inlined external function, it
1763 means we aren't going to compile the outer function unless it is
1764 actually inlined, so do the same for us. */
1783 /* Add this decl to the current binding level. */
1786 /* Output the assembler code and/or RTL for the declaration. */
1790 }
1791 \f
1792 /* Count how deep we are into nested functions. This is because
1793 we shouldn't call the backend function context routines unless we
1794 are in a nested function. */
1798 /* Set up the framework for generating code for SUBPROG_DECL, a subprogram
1799 body. This routine needs to be invoked before processing the declarations
1800 appearing in the subprogram. */
1802 void
1804 {
1805 tree param_decl_list;
1806 tree param_decl;
1807 tree next_param;
1814 /* Make this field nonzero so further routines know that this is not
1815 tentative. error_mark_node is replaced below (in poplevel) with the
1816 adequate BLOCK. */
1819 /* This function exists in static storage. This does not mean `static' in
1820 the C sense! */
1823 /* Enter a new binding level. */
1827 /* Push all the PARM_DECL nodes onto the current scope (i.e. the scope of the
1828 subprogram body) so that they can be recognized as local variables in the
1829 subprogram.
1831 The list of PARM_DECL nodes is stored in the right order in
1832 DECL_ARGUMENTS. Since ..._DECL nodes get stored in the reverse order in
1833 which they are transmitted to `pushdecl' we need to reverse the list of
1834 PARM_DECLs if we want it to be stored in the right order. The reason why
1835 we want to make sure the PARM_DECLs are stored in the correct order is
1836 that this list will be retrieved in a few lines with a call to `getdecl'
1837 to store it back into the DECL_ARGUMENTS field. */
1841 {
1845 }
1847 /* Store back the PARM_DECL nodes. They appear in the right order. */
1853 /* If this function is `main', emit a call to `__main'
1854 to run global initializers, etc. */
1859 }
1861 /* Finish the definition of the current subprogram and compile it all the way
1862 to assembler language output. */
1864 void
1866 {
1867 tree decl;
1868 tree cico_list;
1874 /* Mark the RESULT_DECL as being in this subprogram. */
1879 /* If this is a nested function, push a new GC context. That will keep
1880 local variables on the stack from being collected while we're doing
1881 the compilation of this function. */
1890 /* Throw away any VAR_DECLs we made for OUT parameters; they must
1891 not be seen when we call this function and will be in
1892 unallocated memory anyway. */
1898 {
1899 /* Throw away DECL_RTL in any PARM_DECLs unless this function
1900 was saved for inline, in which case the DECL_RTLs are in
1901 preserved memory. */
1904 {
1907 }
1909 /* Similarly, discard DECL_RTL of the return value. */
1912 /* But DECL_INITIAL must remain nonzero so we know this
1913 was an actual function definition unless toplev.c decided not
1914 to inline it. */
1919 }
1921 /* If we are not at the bottom of the function nesting stack, pop up to
1922 the containing function. Otherwise show we aren't in any function. */
1925 else
1927 }
1928 \f
1929 /* Return a definition for a builtin function named NAME and whose data type
1930 is TYPE. TYPE should be a function type with argument types.
1931 FUNCTION_CODE tells later passes how to compile calls to this function.
1932 See tree.h for its possible values.
1934 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
1935 the name to be called if we can't opencode the function. If
1936 ATTRS is nonzero, use that for the function attribute list. */
1938 tree
1940 tree type,
1944 tree attrs)
1945 {
1959 }
1961 /* Return an integer type with the number of bits of precision given by
1962 PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise
1963 it is a signed type. */
1965 tree
1967 {
1968 tree t;
1977 else
1984 {
1987 }
1990 }
1992 /* Likewise for floating-point types. */
1994 static tree
1996 {
1997 tree t;
2011 {
2014 }
2017 }
2019 /* Return a data type that has machine mode MODE. UNSIGNEDP selects
2020 an unsigned type; otherwise a signed type is returned. */
2022 tree
2024 {
2027 else
2029 }
2031 /* Return the unsigned version of a TYPE_NODE, a scalar type. */
2033 tree
2035 {
2039 {
2042 }
2046 {
2049 }
2052 }
2054 /* Return the signed version of a TYPE_NODE, a scalar type. */
2056 tree
2058 {
2062 {
2065 }
2069 {
2072 }
2075 }
2077 /* Return a type the same as TYPE except unsigned or signed according to
2078 UNSIGNEDP. */
2080 tree
2082 {
2085 else
2087 }
2088 \f
2089 /* EXP is an expression for the size of an object. If this size contains
2090 discriminant references, replace them with the maximum (if MAX_P) or
2091 minimum (if ! MAX_P) possible value of the discriminant. */
2093 tree
2095 {
2100 {
2114 /* If this contains a PLACEHOLDER_EXPR, it is the thing we want to
2115 modify. Otherwise, we treat it like a variable. */
2120 return
2130 {
2134 else
2135 return
2148 {
2153 /* Special-case wanting the maximum value of a MIN_EXPR.
2154 In that case, if one side overflows, return the other.
2155 sizetype is signed, but we know sizes are non-negative.
2156 Likewise, handle a MINUS_EXPR or PLUS_EXPR with the LHS
2157 overflowing or the maximum possible value and the RHS
2158 a variable. */
2168 else
2170 }
2182 }
2183 }
2186 }
2187 \f
2188 /* Build a template of type TEMPLATE_TYPE from the array bounds of ARRAY_TYPE.
2189 EXPR is an expression that we can use to locate any PLACEHOLDER_EXPRs.
2190 Return a constructor for the template. */
2192 tree
2194 {
2197 tree field;
2209 /* First make the list for a CONSTRUCTOR for the template. Go down the
2210 field list of the template instead of the type chain because this
2211 array might be an Ada array of arrays and we can't tell where the
2212 nested arrays stop being the underlying object. */
2219 {
2222 /* If we have a bound list, get the bounds from there. Likewise
2223 for an ARRAY_TYPE. Otherwise, if expr is a PARM_DECL with
2224 DECL_BY_COMPONENT_PTR_P, use the bounds of the field in the template.
2225 This will give us a maximum range. */
2233 else
2239 /* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
2240 surround them with a WITH_RECORD_EXPR giving EXPR as the
2241 OBJECT. */
2249 }
2252 }
2253 \f
2254 /* Build a VMS descriptor from a Mechanism_Type, which must specify
2255 a descriptor type, and the GCC type of an object. Each FIELD_DECL
2256 in the type contains in its DECL_INITIAL the expression to use when
2257 a constructor is made for the type. GNAT_ENTITY is a gnat node used
2258 to print out an error message if the mechanism cannot be applied to
2259 an object of that type and also for the name. */
2261 tree
2263 {
2268 tree inner_type;
2272 tree tem;
2274 /* If TYPE is an unconstrained array, use the underlying array type. */
2278 /* If this is an array, compute the number of dimensions in the array,
2279 get the index types, and point to the inner type. */
2282 else
2287 ;
2297 else
2303 /* Now get the DTYPE value. */
2305 {
2310 {
2320 }
2321 else
2323 {
2339 }
2350 {
2359 }
2360 else
2370 }
2372 /* Get the CLASS value. */
2374 {
2386 }
2388 /* Make the type for a descriptor for VMS. The first four fields
2389 are the same for all types. */
2391 field_list
2393 make_descriptor_field
2406 field_list
2410 record_type,
2414 type))));
2417 {
2423 field_list
2425 make_descriptor_field
2429 field_list
2431 make_descriptor_field
2442 record_type,
2443 size_zero_node));
2448 record_type,
2449 size_zero_node));
2451 field_list
2453 make_descriptor_field
2457 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */
2465 record_type,
2471 record_type,
2474 /* Now build a pointer to the 0,0,0... element. */
2481 field_list
2483 make_descriptor_field
2487 /* Next come the addressing coefficients. */
2490 {
2492 tree idx_length
2502 field_list
2510 }
2512 /* Finally here are the bounds. */
2514 {
2518 field_list
2520 make_descriptor_field
2525 field_list
2527 make_descriptor_field
2530 }
2535 }
2539 record_type));
2542 }
2544 /* Utility routine for above code to make a field. */
2546 static tree
2549 {
2550 tree field
2555 }
2556 \f
2557 /* Build a type to be used to represent an aliased object whose nominal
2558 type is an unconstrained array. This consists of a RECORD_TYPE containing
2559 a field of TEMPLATE_TYPE and a field of OBJECT_TYPE, which is an
2560 ARRAY_TYPE. If ARRAY_TYPE is that of the unconstrained array, this
2561 is used to represent an arbitrary unconstrained object. Use NAME
2562 as the name of the record. */
2564 tree
2566 {
2577 array_field),
2581 }
2582 \f
2583 /* Update anything previously pointing to OLD_TYPE to point to NEW_TYPE. In
2584 the normal case this is just two adjustments, but we have more to do
2585 if NEW is an UNCONSTRAINED_ARRAY_TYPE. */
2587 void
2589 {
2592 tree type;
2594 /* If this is the main variant, process all the other variants first. */
2600 /* If no pointer or reference, we are done. */
2604 /* Merge the old type qualifiers in the new type.
2606 Each old variant has qualifiers for specific reasons, and the new
2607 designated type as well. Each set of qualifiers represents useful
2608 information grabbed at some point, and merging the two simply unifies
2609 these inputs into the final type description.
2611 Consider for instance a volatile type frozen after an access to constant
2612 type designating it. After the designated type freeze, we get here with a
2613 volatile new_type and a dummy old_type with a readonly variant, created
2614 when the access type was processed. We shall make a volatile and readonly
2615 designated type, because that's what it really is.
2617 We might also get here for a non-dummy old_type variant with different
2618 qualifiers than the new_type ones, for instance in some cases of pointers
2619 to private record type elaboration (see the comments around the call to
2620 this routine from gnat_to_gnu_entity/E_Access_Type). We have to merge the
2621 qualifiers in thoses cases too, to avoid accidentally discarding the
2622 initial set, and will often end up with old_type == new_type then. */
2627 /* If the new type and the old one are identical, there is nothing to
2628 update. */
2632 /* Otherwise, first handle the simple case. */
2634 {
2653 }
2655 /* Now deal with the unconstrained array case. In this case the "pointer"
2656 is actually a RECORD_TYPE where the types of both fields are
2657 pointers to void. In that case, copy the field list from the
2658 old type to the new one and update the fields' context. */
2662 else
2663 {
2665 tree ptr_temp_type;
2666 tree new_ref;
2667 tree var;
2673 /* Rework the PLACEHOLDER_EXPR inside the reference to the
2674 template bounds.
2676 ??? This is now the only use of gnat_substitute_in_type, which
2677 is now a very "heavy" routine to do this, so it should be replaced
2678 at some point. */
2684 update_pointer_to
2695 /* Now handle updating the allocation record, what the thin pointer
2696 points to. Update all pointers from the old record into the new
2697 one, update the types of the fields, and recompute the size. */
2718 }
2719 }
2720 \f
2721 /* Convert a pointer to a constrained array into a pointer to a fat
2722 pointer. This involves making or finding a template. */
2724 static tree
2726 {
2731 /* If EXPR is a constant of zero, we make a fat pointer that has a null
2732 pointer to the template and array. */
2734 return
2735 gnat_build_constructor
2741 expr),
2742 NULL_TREE)));
2744 /* If EXPR is a thin pointer, make the template and data from the record. */
2747 {
2753 else
2760 }
2761 else
2762 /* Otherwise, build the constructor for the template. */
2767 /* The result is a CONSTRUCTOR for the fat pointer.
2769 If expr is an argument of a foreign convention subprogram, the type it
2770 points to is directly the component type. In this case, the expression
2771 type may not match the corresponding FIELD_DECL type at this point, so we
2772 call "convert" here to fix that up if necessary. This type consistency is
2773 required, for instance because it ensures that possible later folding of
2774 component_refs against this constructor always yields something of the
2775 same type as the initial reference.
2777 Note that the call to "build_template" above is still fine, because it
2778 will only refer to the provided template_type in this case. */
2779 return
2780 gnat_build_constructor
2785 }
2786 \f
2787 /* Convert to a thin pointer type, TYPE. The only thing we know how to convert
2788 is something that is a fat pointer, so convert to it first if it EXPR
2789 is not already a fat pointer. */
2791 static tree
2793 {
2795 expr
2796 = convert_to_fat_pointer
2799 /* We get the pointer to the data and use a NOP_EXPR to make it the
2800 proper GCC type. */
2801 expr
2806 }
2807 \f
2808 /* Create an expression whose value is that of EXPR,
2809 converted to type TYPE. The TREE_TYPE of the value
2810 is always TYPE. This function implements all reasonable
2811 conversions; callers should filter out those that are
2812 not permitted by the language being compiled. */
2814 tree
2816 {
2820 tree tem;
2822 /* If EXPR is already the right type, we are done. */
2825 /* If we're converting between two aggregate types that have the same main
2826 variant, just make a NOP_EXPR. */
2830 /* If EXPR is a WITH_RECORD_EXPR, do the conversion inside and then make a
2831 new one. */
2837 /* If the input type has padding, remove it by doing a component reference
2838 to the field. If the output type has padding, make a constructor
2839 to build the record. If both input and output have padding and are
2840 of variable size, do this as an unchecked conversion. */
2845 ;
2847 {
2848 /* If we have just converted to this padded type, just get
2849 the inner expression. */
2854 else
2857 }
2859 {
2860 /* If we previously converted from another type and our type is
2861 of variable size, remove the conversion to avoid the need for
2862 variable-size temporaries. */
2867 /* If we are just removing the padding from expr, convert the original
2868 object if we have variable size. That will avoid the need
2869 for some variable-size temporaries. */
2876 /* If the result type is a padded type with a self-referentially-sized
2877 field and the expression type is a record, do this as an
2878 unchecked converstion. */
2883 else
2884 return
2889 expr),
2890 NULL_TREE));
2891 }
2893 /* If the input is a biased type, adjust first. */
2900 /* If the input is a left-justified modular type, we need to extract
2901 the actual object before converting it to any other type with the
2902 exception of an unconstrained array. */
2908 /* If converting to a type that contains a template, convert to the data
2909 type and then build the template. */
2911 {
2914 /* If the source already has a template, get a reference to the
2915 associated array only, as we are going to rebuild a template
2916 for the target type anyway. */
2919 return
2920 gnat_build_constructor
2927 }
2929 /* There are some special cases of expressions that we process
2930 specially. */
2932 {
2938 /* Just set its type here. For TRANSFORM_EXPR, we will do the actual
2939 conversion in gnat_expand_expr. NULL_EXPR does not represent
2940 and actual value, so no conversion is needed. */
2947 /* If we are converting a STRING_CST to another constrained array type,
2948 just make a new one in the proper type. Likewise for a
2949 CONSTRUCTOR. */
2953 {
2957 }
2961 /* If we are converting between two aggregate types of the same
2962 kind, size, mode, and alignment, just make a new COMPONENT_REF.
2963 This avoid unneeded conversions which makes reference computations
2964 more complex. */
2975 /* Convert this to the type of the inner array by getting the address of
2976 the array from the template. */
2992 /* If both types are record types, just convert the pointer and
2993 make a new INDIRECT_REF.
2995 ??? Disable this for now since it causes problems with the
2996 code in build_binary_op for MODIFY_EXPR which wants to
2997 strip off conversions. But that code really is a mess and
2998 we need to do this a much better way some time. */
3012 }
3014 /* Check for converting to a pointer to an unconstrained array. */
3024 {
3039 /* ... fall through ... */
3046 /* If converting between two pointers to records denoting
3047 both a template and type, adjust if needed to account
3048 for any differing offsets, since one might be negative. */
3050 {
3051 tree bit_diff
3064 }
3066 /* If converting to a thin pointer, handle specially. */
3071 /* If converting fat pointer to normal pointer, get the pointer to the
3072 array and then convert it. */
3084 return
3085 gnat_build_constructor
3088 NULL_TREE));
3090 /* ... fall through ... */
3093 /* In these cases, assume the front-end has validated the conversion.
3094 If the conversion is valid, it will be a bit-wise conversion, so
3095 it can be viewed as an unchecked conversion. */
3099 /* Just validate that the type is indeed that of a field
3100 of the type. Then make the simple conversion. */
3102 {
3111 }
3116 /* If EXPR is a constrained array, take its address, convert it to a
3117 fat pointer, and then dereference it. Likewise if EXPR is a
3118 record containing both a template and a constrained array.
3119 Note that a record representing a left justified modular type
3120 always represents a packed constrained array. */
3125 return
3126 build_unary_op
3132 /* Do something very similar for converting one unconstrained
3133 array to another. */
3135 return
3140 else
3148 }
3149 }
3150 \f
3151 /* Remove all conversions that are done in EXP. This includes converting
3152 from a padded type or to a left-justified modular type. If TRUE_ADDRESS
3153 is nonzero, always return the address of the containing object even if
3154 the address is not bit-aligned. */
3156 tree
3158 {
3160 {
3180 }
3183 }
3184 \f
3185 /* If EXP's type is an UNCONSTRAINED_ARRAY_TYPE, return an expression that
3186 refers to the underlying array. If its type has TYPE_CONTAINS_TEMPLATE_P,
3187 likewise return an expression pointing to the underlying array. */
3189 tree
3191 {
3196 {
3199 {
3200 new
3207 }
3223 /* If this is a padded type, convert to the unpadded type and see if
3224 it contains a template. */
3226 {
3230 return
3234 }
3236 return
3243 }
3246 }
3247 \f
3248 /* Return an expression that does an unchecked converstion of EXPR to TYPE.
3249 If NOTRUNC_P is set, truncation operations should be suppressed. */
3251 tree
3253 {
3256 /* If the expression is already the right type, we are done. */
3260 /* If EXPR is a WITH_RECORD_EXPR, do the conversion inside and then make a
3261 new one. */
3267 /* If both types types are integral just do a normal conversion.
3268 Likewise for a conversion to an unconstrained array. */
3282 {
3287 {
3293 }
3297 {
3301 }
3306 }
3308 /* If we are converting TO an integral type whose precision is not the
3309 same as its size, first unchecked convert to a record that contains
3310 an object of the output type. Then extract the field. */
3314 {
3324 }
3326 /* Similarly for integral input type whose precision is not equal to its
3327 size. */
3331 {
3333 tree field
3342 }
3344 /* We have a special case when we are converting between two
3345 unconstrained array types. In that case, take the address,
3346 convert the fat pointer types, and dereference. */
3352 expr)));
3353 else
3354 {
3358 }
3360 /* If the result is an integral type whose size is not equal to
3361 the size of the underlying machine type, sign- or zero-extend
3362 the result. We need not do this in the case where the input is
3363 an integral type of the same precision and signedness or if the output
3364 is a biased type or if both the input and output are unsigned. */
3378 {
3381 tree shift_expr
3384 bitsize_int
3387 expr
3392 shift_expr),
3393 shift_expr));
3394 }
3396 /* An unchecked conversion should never raise Constraint_Error. The code
3397 below assumes that GCC's conversion routines overflow the same way that
3398 the underlying hardware does. This is probably true. In the rare case
3399 when it is false, we can rely on the fact that such conversions are
3400 erroneous anyway. */
3404 /* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
3405 show no longer constant. */
3411 }