| blob | b32d4a63f874b85eb32f8ec7312ca264d31c6246 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * T R A N S *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2004, 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 ****************************************************************************/
68 /* Current filename without path. */
71 /* Flag indicating whether file names are discarded in exception messages */
74 /* If true, then gigi is being called on an analyzed but unexpanded
75 tree, and the only purpose of the call is to properly annotate
76 types with representation information. */
79 /* List of TREE_LIST nodes representing a block stack. TREE_VALUE
80 of each gives the variable used for the setjmp buffer in the current
81 block, if any. TREE_PURPOSE gives the bottom condition for a loop,
82 if this block is for a loop. The latter is only used to save the tree
83 over GC. */
84 tree gnu_block_stack;
86 /* The current BLOCK_STMT node. TREE_CHAIN points to the previous
87 BLOCK_STMT node. */
90 /* List of unused BLOCK_STMT nodes. */
93 /* List of TREE_LIST nodes representing a stack of exception pointer
94 variables. TREE_VALUE is the VAR_DECL that stores the address of
95 the raised exception. Nonzero means we are in an exception
96 handler. Not used in the zero-cost case. */
99 /* List of TREE_LIST nodes containing pending elaborations lists.
100 used to prevent the elaborations being reclaimed by GC. */
103 /* Map GNAT tree codes to GCC tree codes for simple expressions. */
106 /* Current node being treated, in case gigi_abort called. */
107 Node_Id error_gnat_node;
109 /* Variable that stores a list of labels to be used as a goto target instead of
110 a return in some functions. See processing for N_Subprogram_Body. */
135 /* Constants for +0.5 and -0.5 for float-to-integer rounding. */
138 \f
139 /* This is the main program of the back-end. It sets up all the table
140 structures and then generates code. */
142 void
154 Int number_units ATTRIBUTE_UNUSED,
156 Entity_Id standard_integer,
157 Entity_Id standard_long_long_float,
158 Entity_Id standard_exception_type,
159 Int gigi_operating_mode)
160 {
161 tree gnu_standard_long_long_float;
162 tree gnu_standard_exception_type;
177 /* If we are just annotating types, give VOID_TYPE zero sizes to avoid
178 errors. */
180 {
183 }
185 /* See if we should discard file names in exception messages. */
193 /* Initialize ourselves. */
200 /* Enable GNAT stack checking method if needed */
204 /* Save the type we made for integer as the type for Standard.Integer.
205 Then make the rest of the standard types. Note that some of these
206 may be subtypes. */
215 gnu_standard_long_long_float
217 gnu_standard_exception_type
222 /* Process any Pragma Ident for the main unit. */
223 #ifdef ASM_OUTPUT_IDENT
225 ASM_OUTPUT_IDENT
228 #endif
230 /* If we are using the GCC exception mechanism, let GCC know. */
235 }
237 \f
238 /* This function is the driver of the GNAT to GCC tree transformation process.
239 GNAT_NODE is the root of some gnat tree. It generates code for that
240 part of the tree. */
242 void
244 {
245 tree gnu_root;
247 /* Save node number in case error */
254 /* If we return a statement, generate code for it. */
256 {
259 }
260 /* This should just generate code, not return a value. If it returns
261 a value, something is wrong. */
264 }
266 /* GNAT_NODE is the root of some GNAT tree. Return the root of the GCC
267 tree corresponding to that GNAT tree. Normally, no code is generated.
268 We just return an equivalent tree which is used elsewhere to generate
269 code. */
271 tree
273 {
274 tree gnu_root;
277 /* We support the use of this on statements now as a transition
278 to full function-at-a-time processing. So we need to see if anything
279 we do generates RTL and returns error_mark_node. */
281 {
287 }
289 /* Save node number in case error */
297 {
299 {
302 else
304 }
309 gnat_node);
311 }
313 {
314 rtx insns;
322 {
323 /* If we have a statement, we need to first evaluate any RTL we
324 made in the process of building it and then the statement. */
326 {
333 }
334 else
336 }
337 }
340 }
341 \f
342 /* This function is the driver of the GNAT to GCC tree transformation process.
343 It is the entry point of the tree transformer. GNAT_NODE is the root of
344 some GNAT tree. Return the root of the corresponding GCC tree or
345 error_mark_node to signal that there is no GCC tree to return.
347 The latter is the case if only code generation actions have to be performed
348 like in the case of if statements, loops, etc. This routine is wrapped
349 in the above two routines for most purposes. */
351 static tree
353 {
356 tree gnu_expr;
358 Node_Id gnat_temp;
359 Entity_Id gnat_temp_type;
361 /* Set input_file_name and lineno from the Sloc in the GNAT tree. */
368 /* If this is a Statement and we are at top level, we add the statement
369 as an elaboration for a null tree. That will cause it to be placed
370 in the elaboration procedure. */
383 {
387 }
389 /* If this node is a non-static subexpression and we are only
390 annotating types, make this into a NULL_EXPR for non-VOID types
391 and error_mark_node for void return types. But allow
392 N_Identifier since we use it for lots of things, including
393 getting trees for discriminants. */
399 {
404 else
407 }
410 {
411 /********************************/
412 /* Chapter 2: Lexical Elements: */
413 /********************************/
420 /* If the Etype of this node does not equal the Etype of the
421 Entity, something is wrong with the entity map, probably in
422 generic instantiation. However, this does not apply to
423 types. Since we sometime have strange Ekind's, just do
424 this test for objects. Also, if the Etype of the Entity is
425 private, the Etype of the N_Identifier is allowed to be the full
426 type and also we consider a packed array type to be the same as
427 the original type. Similarly, a class-wide type is equivalent
428 to a subtype of itself. Finally, if the types are Itypes,
429 one may be a copy of the other, which is also legal. */
453 /* If this is a reference to a deferred constant whose partial view
454 is an unconstrained private type, the proper type is on the full
455 view of the constant, not on the full view of the type, which may
456 be unconstrained.
458 This may be a reference to a type, for example in the prefix of the
459 attribute Position, generated for dispatching code (see Make_DT in
460 exp_disp,adb). In that case we need the type itself, not is parent,
461 in particular if it is a derived type */
467 {
471 }
472 else
473 {
474 /* Expand the type of this identitier first, in case it is
475 an enumeral literal, which only get made when the type
476 is expanded. There is no order-of-elaboration issue here.
477 We want to use the Actual_Subtype if it has already been
478 elaborated, otherwise the Etype. Avoid using Actual_Subtype
479 for packed arrays to simplify things. */
487 else
491 }
495 /* If we are in an exception handler, force this variable into memory
496 to ensure optimization does not remove stores that appear
497 redundant but are actually needed in case an exception occurs.
499 ??? Note that we need not do this if the variable is declared within
500 the handler, only if it is referenced in the handler and declared
501 in an enclosing block, but we have no way of testing that
502 right now. */
504 {
507 }
509 /* Some objects (such as parameters passed by reference, globals of
510 variable size, and renamed objects) actually represent the address
511 of the object. In that case, we must do the dereference. Likewise,
512 deal with parameters to foreign convention subprograms. Call fold
513 here since GNU_RESULT may be a CONST_DECL. */
518 {
520 tree initial;
525 gnu_result);
527 /* If the object is constant, we try to do the dereference directly
528 through the DECL_INITIAL. This is actually required in order to
529 get correct aliasing information for renamed objects that are
530 components of non-aliased aggregates, because the type of
531 the renamed object and that of the aggregate don't alias. */
534 /* Strip possible conversion to reference type. */
542 else
547 }
549 /* The GNAT tree has the type of a function as the type of its result.
550 Also use the type of the result if the Etype is a subtype which
551 is nominally unconstrained. But remove any padding from the
552 resulting type. */
555 {
560 }
562 /* We always want to return the underlying INTEGER_CST for an
563 enumeration literal to avoid the need to call fold in lots
564 of places. But don't do this is the parent will be taking
565 the address of this object. */
567 {
581 }
585 {
586 tree gnu_type;
588 /* Get the type of the result, looking inside any padding and
589 left-justified modular types. Then get the value in that type. */
598 /* If the result overflows (meaning it doesn't fit in its base type),
599 abort. We would like to check that the value is within the range
600 of the subtype, but that causes problems with subtypes whose usage
601 will raise Constraint_Error and with biased representation, so
602 we don't. */
605 }
609 /* If a Entity is present, it means that this was one of the
610 literals in a user-defined character type. In that case,
611 just return the value in the CONST_DECL. Otherwise, use the
612 character code. In that case, the base type should be an
613 INTEGER_TYPE, but we won't bother checking for that. */
617 else
623 /* If this is of a fixed-point type, the value we want is the
624 value of the corresponding integer. */
626 {
629 gnu_result_type);
632 }
634 /* We should never see a Vax_Float type literal, since the front end
635 is supposed to transform these using appropriate conversions */
639 else
640 {
645 /* If the real value is zero, so is the result. Otherwise,
646 convert it to a machine number if it isn't already. That
647 forces BASE to 0 or 2 and simplifies the rest of our logic. */
650 else
651 {
653 ur_realval
657 gnu_result
660 /* If we have a base of zero, divide by the denominator.
661 Otherwise, the base must be 2 and we scale the value, which
662 we know can fit in the mantissa of the type (hence the use
663 of that type above). */
665 gnu_result
668 gnu_result,
670 gnu_result_type));
674 else
675 {
676 REAL_VALUE_TYPE tmp;
681 }
682 }
684 /* Now see if we need to negate the result. Do it this way to
685 properly handle -0. */
687 gnu_result
689 gnu_result);
690 }
697 {
698 /* We assume here that all strings are of type standard.string.
699 "Weird" types of string have been converted to an aggregate
700 by the expander. */
706 /* Build the string with the characters in the literal. Note
707 that Ada strings are 1-origin. */
711 /* Put a null at the end of the string in case it's in a context
712 where GCC will want to treat it as a C string. */
717 /* Strings in GCC don't normally have types, but we want
718 this to not be converted to the array type. */
720 }
721 else
722 {
723 /* Build a list consisting of each character, then make
724 the aggregate. */
731 gnu_list
737 gnu_list);
739 gnu_result
741 }
748 /* Check for (and ignore) unrecognized pragma */
753 {
755 /* Do nothing at top level: all such variables are already
756 viewable. */
764 {
772 }
778 {
792 }
799 }
802 /**************************************/
803 /* Chapter 3: Declarations and Types: */
804 /**************************************/
819 /* If we are just annotating types and this object has an unconstrained
820 or task type, don't elaborate it. */
831 && (! type_annotate_only
833 {
838 /* If this object has its elaboration delayed, we must force
839 evaluation of GNU_EXPR right now and save it for when the object
840 is frozen. */
842 {
845 {
846 gnu_expr
852 }
853 else
857 }
858 }
859 else
874 /* Don't do anything if this renaming is handled by the front end.
875 or if we are just annotating types and this object has a
876 composite or task type, don't elaborate it. */
878 && ! (type_annotate_only
894 /* These are fully handled in the front end. */
897 /*************************************/
898 /* Chapter 4: Names and Expressions: */
899 /*************************************/
908 {
910 tree gnu_type;
918 /* If we got a padded type, remove it too. */
921 gnu_array_object
923 gnu_array_object);
927 /* First compute the number of dimensions of the array, then
928 fill the expression array, the order depending on whether
929 this is a Convention_Fortran array or not. */
934 ;
943 else
951 {
959 gnu_expr
960 = emit_index_check
967 }
968 }
974 {
975 tree gnu_type;
981 /* Do any implicit dereferences of the prefix and do any needed
982 range check. */
987 {
988 /* Get the bounds of the slice. */
989 tree gnu_index_type
995 /* Check to see that the minimum slice value is in range */
996 gnu_expr_l
997 = emit_index_check
1002 /* Check to see that the maximum slice value is in range */
1003 gnu_expr_h
1004 = emit_index_check
1009 /* Derive a good type to convert everything too */
1012 /* Build a compound expression that does the range checks */
1013 gnu_expr
1018 /* Build a conditional expression that returns the range checks
1019 expression if the slice range is not null (max >= min) or
1020 returns the min if the slice range is null */
1021 gnu_expr
1025 gnu_max_expr),
1027 gnu_min_expr)),
1029 }
1030 else
1035 }
1039 {
1043 tree gnu_field;
1047 {
1052 }
1056 /* For discriminant references in tagged types always substitute the
1057 corresponding discriminant as the actual selected component. */
1063 /* For discriminant references of untagged types always substitute the
1064 corresponding stored discriminant. */
1069 /* Handle extracting the real or imaginary part of a complex.
1070 The real part is the first field and the imaginary the last. */
1076 else
1077 {
1080 /* If there are discriminants, the prefix might be
1081 evaluated more than once, which is a problem if it has
1082 side-effects. */
1089 gnu_result
1093 }
1099 }
1103 {
1104 /* The attribute designator (like an enumeration value). */
1107 tree gnu_prefix;
1108 tree gnu_type;
1110 /* The Elab_Spec and Elab_Body attributes are special in that
1111 Prefix is a unit, not an object with a GCC equivalent. Similarly
1112 for Elaborated, since that variable isn't otherwise known. */
1114 {
1115 gnu_prefix
1116 = create_subprog_decl
1118 attribute == Attr_Elab_Body
1122 }
1127 /* If the input is a NULL_EXPR, make a new one. */
1129 {
1134 }
1137 {
1140 /* These are just conversions until since representation
1141 clauses for enumerations are handled in the front end. */
1142 {
1149 }
1154 /* These just add or subject the constant 1. Representation
1155 clauses for enumerations are handled in the front-end. */
1160 {
1162 gnu_expr
1163 = emit_check
1165 gnu_expr,
1166 attribute == Attr_Pred
1170 }
1172 gnu_result
1182 /* Conversions don't change something's address but can cause
1183 us to miss the COMPONENT_REF case below, so strip them off. */
1184 gnu_prefix
1188 /* If we are taking 'Address of an unconstrained object,
1189 this is the pointer to the underlying array. */
1192 /* ... fall through ... */
1199 gnu_result
1206 /* For 'Code_Address, find an inner ADDR_EXPR and mark it
1207 so that we don't try to build a trampoline. */
1209 {
1215 ;
1219 }
1224 {
1225 tree gnu_obj_type;
1230 /* If this is an unconstrained array, we know the object must
1231 have been allocated with the template in front of the object.
1232 So compute the template address.*/
1235 gnu_ptr
1237 (TYPE_OBJECT_RECORD_TYPE
1239 gnu_ptr);
1244 {
1247 tree gnu_byte_offset
1254 }
1257 }
1267 /* Remove NOPS from gnu_expr and conversions from gnu_prefix.
1268 We only use GNU_EXPR to see if a COMPONENT_REF was involved. */
1276 /* Replace an unconstrained array type with the type of the
1277 underlying array. We can't do this with a call to
1278 maybe_unconstrained_array since we may have a TYPE_DECL.
1279 For 'Max_Size_In_Storage_Elements, use the record type
1280 that will be used to allocate the object and its template. */
1283 {
1287 }
1289 /* If we are looking for the size of a field, return the
1290 field size. Otherwise, if the prefix is an object,
1291 or if 'Object_Size or 'Max_Size_In_Storage_Elements has
1292 been specified, the result is the GCC size of the type.
1293 Otherwise, the result is the RM_Size of the type. */
1299 {
1300 /* If this is a padded type, the GCC size isn't relevant
1301 to the programmer. Normally, what we want is the RM_Size,
1302 which was set from the specified size, but if it was not
1303 set, we want the size of the relevant field. Using the MAX
1304 of those two produces the right result in all case. Don't
1305 use the size of the field if it's a self-referential type,
1306 since that's never what's wanted. */
1310 {
1314 gnu_result
1317 }
1318 else
1320 }
1321 else
1327 /* Deal with a self-referential size by returning the maximum
1328 size for a type and by qualifying the size with
1329 the object for 'Size of an object. */
1332 {
1335 gnu_expr);
1336 else
1338 }
1340 /* If the type contains a template, subtract the size of the
1341 template. */
1349 /* Always perform division using unsigned arithmetic as the
1350 size cannot be negative, but may be an overflowed positive
1351 value. This provides correct results for sizes up to 512 MB.
1352 ??? Size should be calculated in storage elements directly. */
1357 gnu_result,
1358 bitsize_unit_node)));
1365 && (TYPE_IS_PADDING_P
1374 gnu_result
1376 else
1387 {
1394 else
1395 gnu_result
1396 = build_binary_op
1398 build_binary_op
1410 }
1411 /* ... fall through ... */
1413 {
1414 int Dimension
1419 /* Make sure any implicit dereference gets done. */
1427 {
1429 tree gnu_type_temp;
1435 ;
1438 }
1447 gnu_result
1450 gnu_result
1452 else
1453 /* 'Length or 'Range_Length. */
1454 {
1455 tree gnu_compute_type
1456 = gnat_signed_or_unsigned_type
1459 gnu_result
1460 = build_binary_op
1462 build_binary_op
1464 build_binary_op
1467 TYPE_MAX_VALUE
1470 TYPE_MIN_VALUE
1474 }
1476 /* If this has a PLACEHOLDER_EXPR, qualify it by the object
1477 we are handling. Note that these attributes could not
1478 have been used on an unconstrained array type. */
1480 gnu_prefix);
1483 }
1490 {
1491 HOST_WIDE_INT bitsize;
1492 HOST_WIDE_INT bitpos;
1493 tree gnu_offset;
1494 tree gnu_field_bitpos;
1495 tree gnu_field_offset;
1496 tree gnu_inner;
1504 /* We can have 'Bit on any object, but if it isn't a
1505 COMPONENT_REF, the result is zero. Do not allow
1506 'Bit on a bare component, though. */
1510 {
1513 }
1524 {
1525 gnu_field_bitpos
1527 gnu_field_offset
1534 {
1535 gnu_field_bitpos
1539 gnu_field_offset
1543 }
1544 }
1546 {
1549 }
1550 else
1551 {
1554 }
1557 {
1569 gnu_result
1573 bitsize_one_node);
1579 }
1581 /* If this has a PLACEHOLDER_EXPR, qualify it by the object
1582 we are handling. */
1584 gnu_prefix);
1587 }
1610 && (TYPE_IS_PADDING_P
1618 gnu_type
1628 /* Note this size cannot be self-referential. */
1635 /* This is just a zero cast to the pointer type for
1636 our prefix and dereferenced. */
1638 gnu_result
1641 integer_zero_node));
1646 {
1653 {
1658 ;
1659 }
1667 && (DECL_BY_COMPONENT_PTR_P
1671 }
1675 /* Say we have an unimplemented attribute. Then set the
1676 value to be returned to be a zero and hope that's something
1677 we can convert to the type of this attribute. */
1683 }
1685 /* If this is an attribute where the prefix was unused,
1686 force a use of it if it has a side-effect. But don't do it if
1687 the prefix is just an entity name. However, if an access check
1688 is needed, we must do it. See second example in AARM 11.6(5.e). */
1693 }
1697 /* Like 'Access as far as we are concerned. */
1705 {
1706 tree gnu_aggr_type;
1708 /* ??? It is wrong to evaluate the type now, but there doesn't
1709 seem to be any other practical way of doing it. */
1711 gnu_aggr_type = gnu_result_type
1716 gnu_aggr_type
1723 gnu_result
1725 gnu_aggr_type);
1727 {
1728 /* The first element is the discrimant, which we ignore. The
1729 next is the field we're building. Convert the expression
1730 to the type of the field and then to the union type. */
1731 Node_Id gnat_assoc
1734 tree gnu_field_type
1739 }
1742 gnu_aggr_type,
1745 gnu_result
1746 = build_binary_op
1751 (Next
1753 else
1757 }
1767 /* Get the operand expression. */
1771 gnu_result
1783 /* If the result is a pointer type, see if we are improperly
1784 converting to a stricter alignment. */
1788 {
1794 post_error_ne_tree_2
1798 }
1806 {
1809 tree gnu_low;
1810 tree gnu_high;
1812 /* GNAT_RANGE is either an N_Range node or an identifier
1813 denoting a subtype. */
1815 {
1818 }
1821 {
1826 }
1827 else
1832 /* If LOW and HIGH are identical, perform an equality test.
1833 Otherwise, ensure that GNU_OBJECT is only evaluated once
1834 and perform a full range test. */
1838 else
1839 {
1841 gnu_result
1847 }
1851 }
1859 ? RDIV_EXPR
1866 {
1867 /* Some processing below (e.g. clear_last_expr) requires access to
1868 status fields now maintained in the current function context, so
1869 we'll setup a dummy one if needed. We cannot use global_binding_p,
1870 since it might be true due to force_global and making a dummy
1871 context would kill the current function context. */
1874 tree gnu_rhs_side;
1879 /* The elaboration of the RHS may generate code. If so,
1880 we need to make sure it gets executed after the LHS. */
1895 gnu_rhs);
1898 }
1902 /* These can either be operations on booleans or on modular types.
1903 Fall through for boolean types since that's the way GNU_CODES is
1904 set up. */
1906 Modular_Integer_Kind))
1907 {
1908 enum tree_code code
1919 }
1921 /* ... fall through ... */
1932 {
1934 tree gnu_type;
1940 /* If this is a comparison operator, convert any references to
1941 an unconstrained array value into a reference to the
1942 actual array. */
1944 {
1947 }
1949 /* If the result type is a private type, its full view may be a
1950 numeric subtype. The representation we need is that of its base
1951 type, given that it is the result of an arithmetic operation. */
1953 gnu_type = gnu_result_type
1956 /* If this is a shift whose count is not guaranteed to be correct,
1957 we need to adjust the shift count. */
1960 {
1962 tree gnu_max_shift
1970 gnu_rhs
1971 = build_binary_op
1974 gnu_count_type,
1975 gnu_max_shift,
1977 integer_one_node)),
1978 gnu_rhs);
1979 }
1981 /* For right shifts, the type says what kind of shift to do,
1982 so we may need to choose a different type. */
1991 {
1994 }
1998 /* If this is a logical shift with the shift count not verified,
1999 we must return zero if it is too large. We cannot compensate
2000 above in this case. */
2004 gnu_result
2005 = build_cond_expr
2008 gnu_rhs,
2012 gnu_result);
2013 }
2017 {
2020 tree gnu_false
2027 }
2036 /* This case can apply to a boolean or a modular type.
2037 Fall through for a boolean operand since GNU_CODES is set
2038 up to handle this. */
2040 {
2044 gnu_expr);
2046 }
2048 /* ... fall through ... */
2055 else
2064 {
2066 tree gnu_type;
2070 /* The Expression operand can either be an N_Identifier or
2071 Expanded_Name, which must represent a type, or a
2072 N_Qualified_Expression, which contains both the object type and an
2073 initial value for the object. */
2078 {
2079 Entity_Id gnat_desig_type
2090 {
2093 }
2094 else
2095 {
2101 }
2102 }
2103 else
2110 }
2113 /***************************/
2114 /* Chapter 5: Statements: */
2115 /***************************/
2126 /* Get the LHS and RHS of the statement and convert any reference to an
2127 unconstrained array into a reference to the underlying array. */
2129 gnu_rhs
2132 /* If range check is needed, emit code to generate it */
2136 /* If either side's type has a size that overflows, convert this
2137 into raise of Storage_Error: execution shouldn't have gotten
2138 here anyway. */
2144 else
2145 gnu_result
2154 /* Make an IF_STMT for each of the "else if" parts. Avoid
2155 non-determinism. */
2159 {
2170 }
2172 /* Now make the IF_STMT. Also avoid non-determinism. */
2182 {
2183 Node_Id gnat_when;
2184 Node_Id gnat_choice;
2185 tree gnu_label;
2186 Node_Id gnat_statement;
2191 /* The range of values in a case statement is determined by the
2192 rules in RM 5.4(7-9). In almost all cases, this range is
2193 represented by the Etype of the expression. One exception arises
2194 in the case of a simple name that is parenthesized. This still
2195 has the Etype of the name, but since it is not a name, para 7
2196 does not apply, and we need to go to the base type. This is the
2197 only case where parenthesization affects the dynamic semantics
2198 (i.e. the range of possible values at runtime that is covered by
2199 the others alternative.
2201 Another exception is if the subtype of the expression is
2202 non-static. In that case, we also have to use the base type. */
2214 {
2215 /* First compile all the different case choices for the current
2216 WHEN alternative. */
2220 {
2227 {
2229 /* Abort on all errors except range empty, which
2230 means we ignore this alternative. */
2231 error_code
2241 error_code
2242 = pushcase_range
2255 /* This represents either a subtype range or a static value
2256 of some kind; Ekind says which. If a static value,
2257 fall through to the next case. */
2259 {
2262 error_code
2270 }
2271 /* ... fall through ... */
2286 }
2287 }
2289 /* After compiling the choices attached to the WHEN compile the
2290 body of statements that have to be executed, should the
2291 "WHEN ... =>" be taken. Push a binding level here in case
2292 variables are declared since we want them to be local to this
2293 set of statements instead of the block containing the Case
2294 statement. */
2302 /* Communicate to GCC that we are done with the current WHEN,
2303 i.e. insert a "break" statement. */
2307 }
2310 }
2314 {
2315 /* The loop variable in GCC form, if any. */
2317 /* PREINCREMENT_EXPR or PREDECREMENT_EXPR. */
2319 /* Used if this is a named loop for so EXIT can work. */
2321 /* Condition to continue loop tested at top of loop. */
2323 /* Similar, but tested at bottom of loop. */
2325 Node_Id gnat_statement;
2330 /* Set the condition that under which the loop should continue.
2331 For "LOOP .... END LOOP;" the condition is always true. */
2333 ;
2334 /* The case "WHILE condition LOOP ..... END LOOP;" */
2337 else
2338 {
2339 /* We have an iteration scheme. */
2340 Node_Id gnat_loop_spec
2352 tree gnu_limit
2356 /* We know the loop variable will not overflow if GNU_LAST is
2357 a constant and is not equal to GNU_LIMIT. If it might
2358 overflow, we have to move the limit test to the end of
2359 the loop. In that case, we have to test for an
2360 empty loop outside the loop. */
2364 {
2370 }
2372 /* Open a new nesting level that will surround the loop to declare
2373 the loop index variable. */
2377 /* Declare the loop index and set it to its initial value. */
2383 gnu_loop_var);
2385 /* The loop variable might be a padded type, so use `convert' to
2386 get a reference to the inner variable if so. */
2389 /* Set either the top or bottom exit condition as
2390 appropriate depending on whether we know an overflow
2391 cannot occur or not. */
2393 gnu_bottom_condition
2396 else
2397 gnu_top_condition
2402 }
2407 else
2410 /* If the loop was named, have the name point to this loop. In this
2411 case, the association is not a ..._DECL node; in fact, it isn't
2412 a GCC tree node at all. Since this name is referenced inside
2413 the loop, do it before we process the statements of the loop. */
2415 {
2420 }
2424 /* We must evaluate the condition after we've entered the
2425 loop so that any expression actions get done in the right
2426 place. */
2432 /* Make the loop body into its own block, so any allocated
2433 storage will be released every iteration. This is needed
2434 for stack allocation. */
2437 gnu_block_stack
2454 {
2457 gnu_loop_var,
2459 integer_one_node));
2462 }
2468 {
2469 /* Close the nesting level that sourround the loop that was used to
2470 declare the loop index variable. */
2474 }
2477 {
2480 }
2481 }
2500 {
2501 /* Which loop to exit, NULL if the current loop. */
2503 /* The GCC version of the optional GNAT condition node attached to the
2504 exit statement. Exit the loop if this is false. */
2508 loop_id
2517 }
2521 {
2522 /* The gnu function type of the subprogram currently processed. */
2524 /* The return value from the subprogram. */
2527 /* If we are dealing with a "return;" from an Ada procedure with
2528 parameters passed by copy in copy out, we need to return a record
2529 containing the final values of these parameters. If the list
2530 contains only one entry, return just that entry.
2532 For a full description of the copy in copy out parameter mechanism,
2533 see the part of the gnat_to_gnu_entity routine dealing with the
2534 translation of subprograms.
2536 But if we have a return label defined, convert this into
2537 a branch to that label. */
2540 {
2544 }
2547 {
2550 else
2551 gnu_ret_val
2554 }
2556 /* If the Ada subprogram is a function, we just need to return the
2557 expression. If the subprogram returns an unconstrained
2558 array, we have to allocate a new version of the result and
2559 return it. If we return by reference, return a pointer. */
2562 {
2565 /* Do not remove the padding from GNU_RET_VAL if the inner
2566 type is self-referential since we want to allocate the fixed
2567 size in that case. */
2571 && (TYPE_IS_PADDING_P
2573 && (CONTAINS_PLACEHOLDER_P
2582 {
2585 /* We have two cases: either the function returns with
2586 depressed stack or not. If not, we allocate on the
2587 secondary stack. If so, we allocate in the stack frame.
2588 if no copy is needed, the front end will set By_Ref,
2589 which we handle in the case above. */
2591 gnu_ret_val
2594 gnat_node);
2595 else
2596 gnu_ret_val
2601 }
2602 }
2605 }
2612 /****************************/
2613 /* Chapter 6: Subprograms: */
2614 /****************************/
2617 /* Unless there is a freeze node, declare the subprogram. We consider
2618 this a "definition" even though we're not generating code for
2619 the subprogram because we will be making the corresponding GCC
2620 node here. */
2629 /* This subprogram doesn't exist for code generation purposes, but we
2630 have to elaborate the types of any parameters, unless they are
2631 imported types (nothing to generate in this case). */
2643 /* For a child unit identifier go up a level to get the
2644 specificaton. We get this when we try to find the spec of
2645 a child unit package that is the compilation unit being compiled. */
2650 {
2651 /* Save debug output mode in case it is reset. */
2654 /* Definining identifier of a parameter to the subprogram. */
2655 Entity_Id gnat_param;
2656 /* The defining identifier for the subprogram body. Note that if a
2657 specification has appeared before for this body, then the identifier
2658 occurring in that specification will also be a defining identifier
2659 and all the calls to this subprogram will point to that
2660 specification. */
2661 Entity_Id gnat_subprog_id
2665 /* The FUNCTION_DECL node corresponding to the subprogram spec. */
2666 tree gnu_subprog_decl;
2667 /* The FUNCTION_TYPE node corresponding to the subprogram spec. */
2668 tree gnu_subprog_type;
2669 tree gnu_cico_list;
2671 /* If this is a generic object or if it has been eliminated,
2672 ignore it. */
2679 /* If debug information is suppressed for the subprogram,
2680 turn debug mode off for the duration of processing. */
2682 {
2685 }
2687 /* If this subprogram acts as its own spec, define it. Otherwise,
2688 just get the already-elaborated tree node. However, if this
2689 subprogram had its elaboration deferred, we will already have
2690 made a tree node for it. So treat it as not being defined in
2691 that case. Such a subprogram cannot have an address clause or
2692 a freeze node, so this test is safe, though it does disable
2693 some otherwise-useful error checking. */
2694 gnu_subprog_decl
2701 /* ??? Temporarily do this to avoid GC throwing away outer stuff. */
2704 /* Set the line number in the decl to correspond to that of
2705 the body so that the line number notes are written
2706 correctly. */
2712 /* There used to be a second call to set_lineno here, with
2713 write_note_p set, but begin_subprog_body actually already emits the
2714 note we want (via init_function_start).
2716 Emitting a second note here was necessary for -ftest-coverage with
2717 GCC 2.8.1, as the first one was skipped by branch_prob. This is no
2718 longer the case with GCC 3.x, so emitting a second note here would
2719 result in having the first line of the subprogram counted twice by
2720 gcov. */
2729 /* If there are OUT parameters, we need to ensure that the
2730 return statement properly copies them out. We do this by
2731 making a new block and converting any inner return into a goto
2732 to a label at the end of the block. */
2735 {
2736 gnu_return_label_stack
2739 gnu_return_label_stack);
2742 }
2743 else
2744 gnu_return_label_stack
2747 /* See if there are any parameters for which we don't yet have
2748 GCC entities. These must be for OUT parameters for which we
2749 will be making VAR_DECL nodes here. Fill them in to
2750 TYPE_CI_CO_LIST, which must contain the empty entry as well.
2751 We can match up the entries because TYPE_CI_CO_LIST is in the
2752 order of the parameters. */
2758 {
2759 /* Skip any entries that have been already filled in; they
2760 must correspond to IN OUT parameters. */
2763 ;
2765 /* Do any needed references for padded types. */
2769 }
2776 /* Generate the code of the subprogram itself. A return statement
2777 will be present and any OUT parameters will be handled there. */
2785 {
2786 tree gnu_retval;
2796 else
2798 gnu_cico_list);
2801 gnu_retval
2804 expand_return
2807 gnu_retval));
2809 }
2813 /* Disconnect the trees for parameters that we made variables for
2814 from the GNAT entities since these will become unusable after
2815 we end the function. */
2827 }
2832 {
2833 /* The GCC node corresponding to the GNAT subprogram name. This can
2834 either be a FUNCTION_DECL node if we are dealing with a standard
2835 subprogram call, or an indirect reference expression (an
2836 INDIRECT_REF node) pointing to a subprogram. */
2838 /* The FUNCTION_TYPE node giving the GCC type of the subprogram. */
2840 tree gnu_subprog_addr
2842 Entity_Id gnat_formal;
2843 Node_Id gnat_actual;
2848 tree gnu_subprog_call;
2851 {
2858 }
2863 /* If we are calling a stubbed function, make this into a
2864 raise of Program_Error. Elaborate all our args first. */
2868 {
2875 {
2877 gnu_result
2880 }
2881 else
2882 gnu_result
2886 }
2888 /* The only way we can be making a call via an access type is
2889 if Name is an explicit dereference. In that case, get the
2890 list of formal args from the type the access type is pointing
2891 to. Otherwise, get the formals from entity being called. */
2895 /* Assume here that this must be 'Elab_Body or 'Elab_Spec. */
2897 else
2900 /* Create the list of the actual parameters as GCC expects it, namely
2901 a chain of TREE_LIST nodes in which the TREE_VALUE field of each
2902 node is a parameter-expression and the TREE_PURPOSE field is
2903 null. Skip OUT parameters that are not passed by reference and
2904 don't need to be copied in. */
2910 {
2912 /* We treat a conversion between aggregate types as if it
2913 is an unchecked conversion. */
2914 int unchecked_convert_p
2919 Node_Id gnat_name
2923 tree gnu_actual;
2925 /* If it's possible we may need to use this expression twice,
2926 make sure than any side-effects are handled via SAVE_EXPRs.
2927 Likewise if we need to force side-effects before the call.
2928 ??? This is more conservative than we need since we don't
2929 need to do this for pass-by-ref with no conversion.
2930 If we are passing a non-addressable Out or In Out parameter by
2931 reference, pass the address of a copy and set up to copy back
2932 out after the call. */
2935 {
2941 && (DECL_BY_COMPONENT_PTR_P
2943 || DECL_BY_DESCRIPTOR_P
2945 {
2947 tree gnu_temp;
2949 /* Remove any unpadding on the actual and make a copy.
2950 But if the actual is a left-justified modular type,
2951 first convert to it. */
2955 && (TYPE_IS_PADDING_P
2959 && (TYPE_LEFT_JUSTIFIED_MODULAR_P
2965 /* Since we're going to take the address of the SAVE_EXPR,
2966 we don't want it to be marked as unchanging.
2967 So set TREE_ADDRESSABLE. */
2970 {
2973 }
2975 /* Set up to move the copy back to the original. */
2976 gnu_temp
2985 }
2986 }
2988 /* If this was a procedure call, we may not have removed any
2989 padding. So do it here for the part we will use as an
2990 input, if any. */
2996 gnu_actual);
2999 && ! unchecked_convert_p
3003 /* Do any needed conversions. We need only check for
3004 unchecked conversion since normal conversions will be handled
3005 by just converting to the formal type. */
3007 {
3008 gnu_actual
3010 gnu_actual,
3015 /* One we've done the unchecked conversion, we still
3016 must ensure that the object is in range of the formal's
3017 type. */
3022 }
3024 /* We may have suppressed a conversion to the Etype of the
3025 actual since the parent is a procedure call. So add the
3026 conversion here. */
3028 gnu_actual);
3033 /* If we have not saved a GCC object for the formal, it means it
3034 is an OUT parameter not passed by reference and that does not
3035 need to be copied in. Otherwise, look at the PARM_DECL to see
3036 if it is passed by reference. */
3040 {
3042 {
3045 /* If we have a padded type, be sure we've removed the
3046 padding. */
3050 gnu_actual
3052 gnu_actual);
3053 }
3055 /* Otherwise, if we have a non-addressable COMPONENT_REF of a
3056 variable-size type see if it's doing a unpadding operation.
3057 If so, remove that operation since we have no way of
3058 allocating the required temporary. */
3068 /* The symmetry of the paths to the type of an entity is
3069 broken here since arguments don't know that they will
3070 be passed by ref. */
3073 gnu_actual);
3074 }
3078 {
3085 {
3086 gnu_formal_type
3089 }
3091 /* Take the address of the object and convert to the
3092 proper pointer type. We'd like to actually compute
3093 the address of the beginning of the array using
3094 an ADDR_EXPR of an ARRAY_REF, but there's a possibility
3095 that the ARRAY_REF might return a constant and we'd
3096 be getting the wrong address. Neither approach is
3097 exactly correct, but this is the most likely to work
3098 in all cases. */
3101 gnu_actual));
3102 }
3106 {
3107 /* If arg is 'Null_Parameter, pass zero descriptor. */
3111 gnu_actual
3113 integer_zero_node);
3114 else
3115 gnu_actual
3118 gnat_formal));
3119 }
3120 else
3121 {
3125 gnu_name_list
3133 /* If this is 'Null_Parameter, pass a zero even though we are
3134 dereferencing it. */
3139 BITS_PER_WORD))
3140 gnu_actual
3141 = unchecked_convert
3146 else
3147 gnu_actual
3150 gnu_actual);
3151 }
3153 gnu_actual_list
3156 }
3160 NULL_TREE);
3163 /* If it is a function call, the result is the call expression. */
3165 {
3168 /* If the function returns an unconstrained array or by reference,
3169 we have to de-dereference the pointer. */
3173 gnu_result);
3177 }
3179 /* If this is the case where the GNAT tree contains a procedure call
3180 but the Ada procedure has copy in copy out parameters, the special
3181 parameter passing mechanism must be used. */
3183 {
3184 /* List of FIELD_DECLs associated with the PARM_DECLs of the copy
3185 in copy out parameters. */
3190 {
3191 tree gnu_name;
3195 /* If any of the names had side-effects, ensure they are
3196 all evaluated before the call. */
3200 gnu_subprog_call
3203 }
3207 else
3214 /* If we are dealing with a copy in copy out parameter, we must
3215 retrieve its value from the record returned in the function
3216 call. */
3222 && ((DECL_BY_COMPONENT_PTR_P
3224 || (DECL_BY_DESCRIPTOR_P
3227 {
3228 /* Get the value to assign to this OUT or IN OUT
3229 parameter. It is either the result of the function if
3230 there is only a single such parameter or the appropriate
3231 field from the record returned. */
3232 tree gnu_result
3234 : build_component_ref
3237 int unchecked_conversion
3239 /* If the actual is a conversion, get the inner expression,
3240 which will be the real destination, and convert the
3241 result to the type of the actual parameter. */
3242 tree gnu_actual
3245 /* If the result is a padded type, remove the padding. */
3248 gnu_result
3251 gnu_result);
3253 /* If the result is a type conversion, do it. */
3255 gnu_result
3256 = convert_with_check
3263 gnu_result
3266 else
3267 {
3277 gnu_result);
3278 }
3280 gnu_result
3290 }
3291 }
3292 else
3293 {
3297 }
3303 }
3306 /*************************/
3307 /* Chapter 7: Packages: */
3308 /*************************/
3324 /* If this is the body of a generic package - do nothing */
3333 {
3337 }
3340 /*********************************/
3341 /* Chapter 8: Visibility Rules: */
3342 /*********************************/
3346 /* Nothing to do here - but these may appear in list of declarations */
3349 /***********************/
3350 /* Chapter 9: Tasks: */
3351 /***********************/
3360 /***********************************************************/
3361 /* Chapter 10: Program Structure and Compilation Issues: */
3362 /***********************************************************/
3366 /* For a body, first process the spec if there is one. */
3375 {
3382 };
3391 /* Process any pragmas following the unit. */
3397 /* Put all the Actions into the elaboration routine if we already had
3398 elaborations. This will happen anyway if they are statements, but we
3399 want to force declarations there too due to order-of-elaboration
3400 issues. Most should have Is_Statically_Allocated set. If we
3401 have had no elaborations, we have no order-of-elaboration issue and
3402 don't want to create elaborations here. */
3406 {
3410 else
3412 }
3414 /* Generate elaboration code for this unit, if necessary, and
3415 say whether we did or not. */
3416 Set_Has_No_Elaboration_Code
3418 build_unit_elab
3430 /* Simply process whatever unit is being inserted. */
3438 /***************************/
3439 /* Chapter 11: Exceptions: */
3440 /***************************/
3444 /* The GCC exception handling mechanism can handle both ZCX and SJLJ
3445 schemes and we have our own SJLJ mechanism. To call the GCC
3446 mechanism, we first call expand_eh_region_start if there is at least
3447 one handler associated with the region. We then generate code for
3448 the region and call expand_start_all_catch to announce that the
3449 associated handlers are going to be generated.
3451 For each handler we call expand_start_catch, generate code for the
3452 handler, and then call expand_end_catch.
3454 After all the handlers, we call expand_end_all_catch.
3456 Here we deal with the region level calls and the
3457 N_Exception_Handler branch deals with the handler level calls
3458 (start_catch/end_catch).
3460 ??? The region level calls down there have been specifically put in
3461 place for a ZCX context and currently the order in which things are
3462 emitted (region/handlers) is different from the SJLJ case. Instead of
3463 putting other calls with different conditions at other places for the
3464 SJLJ case, it seems cleaner to reorder things for the SJLJ case and
3465 generalize the condition to make it not ZCX specific. */
3467 /* If there is an At_End procedure attached to this node, and the eh
3468 mechanism is GNAT oriented (SJLJ or ZCX with front end tables), we
3469 must have at least a corresponding At_End handler, unless the
3470 No_Exception_Handlers restriction is set. */
3478 {
3479 /* Need a binding level that we can exit for this sequence if there is
3480 at least one exception handler for this block (since each handler
3481 needs an identified exit point) or there is an At_End procedure
3482 attached to this node (in order to have an attachment point for a
3483 GCC cleanup). */
3484 bool exitable_binding_for_block
3485 = (! type_annotate_only
3489 /* Make a binding level that we can exit if we need one. */
3491 {
3494 }
3496 /* If we are to call a function when exiting this block, expand a GCC
3497 cleanup to take care. We have made a binding level for this cleanup
3498 above. */
3500 {
3501 tree gnu_cleanup_call
3504 tree gnu_cleanup_decl
3513 }
3515 /* Now we generate the code for this block, with a different layout
3516 for GNAT SJLJ and for GCC or front end ZCX. The handlers come first
3517 in the GNAT SJLJ case, while they come after the handled sequence
3518 in the other cases. */
3520 /* First deal with possible handlers for the GNAT SJLJ scheme. */
3524 {
3525 /* We already have a fresh binding level at hand. Declare a
3526 variable to save the old __gnat_jmpbuf value and a variable for
3527 our jmpbuf. Call setjmp and handle each of the possible
3528 exceptions if it returns one. */
3530 tree gnu_jmpsave_decl
3532 jmpbuf_ptr_type,
3536 tree gnu_jmpbuf_decl
3549 /* When we exit this block, restore the saved value. */
3552 gnu_jmpsave_decl));
3554 /* Call setjmp and handle exceptions if it returns one. */
3556 expand_start_cond
3559 gnu_jmpbuf_decl)),
3562 /* Restore our incoming longjmp value before we do anything. */
3563 expand_expr_stmt
3566 /* Make a binding level for the exception handling declarations
3567 and code. Don't assign it an exit label, since this is the
3568 outer block we want to exit at the end of each handler. */
3572 gnu_except_ptr_stack
3574 create_var_decl
3579 gnu_except_ptr_stack);
3584 /* Generate code for each handler. The N_Exception_Handler case
3585 below does the real work. We ignore the dummy exception handler
3586 for the identifier case, as this is used only by the front
3587 end. */
3593 /* If none of the exception handlers did anything, re-raise
3594 but do not defer abortion. */
3596 expand_expr_stmt
3602 /* End the binding level dedicated to the exception handlers. */
3606 /* End the "if" on setjmp. Note that we have arranged things so
3607 control never returns here. */
3610 /* This is now immediately before the body proper. Set our jmp_buf
3611 as the current buffer. */
3612 expand_expr_stmt
3615 gnu_jmpbuf_decl)));
3616 }
3618 /* Now comes the processing for the sequence body. */
3620 /* If we use the back-end eh support, tell the back-end we are
3621 starting a new exception region. */
3627 /* Generate code and declarations for the prefix of this block,
3628 if any. */
3635 /* Generate code for each statement in the block. */
3643 /* Exit the binding level we made, if any. */
3647 /* Compile the handlers for front end ZCX or back-end supported
3648 exceptions. */
3652 {
3663 }
3665 /* Close the binding level we made, if any. */
3667 {
3670 }
3671 }
3677 {
3678 /* Unless this is "Others" or the special "Non-Ada" exception
3679 for Ada, make an "if" statement to select the proper
3680 exceptions. For "Others", exclude exceptions where
3681 Handled_By_Others is nonzero unless the All_Others flag is set.
3682 For "Non-ada", accept an exception if "Lang" is 'V'. */
3687 {
3688 tree this_choice;
3691 {
3694 else
3695 this_choice
3696 = build_binary_op
3698 convert
3700 build_component_ref
3701 (build_unary_op
3706 integer_zero_node);
3707 }
3711 {
3714 /* Exception may be a renaming. Recover original exception
3715 which is the one elaborated and registered. */
3721 this_choice
3722 = build_binary_op
3725 convert
3729 /* If this is the distinguished exception "Non_Ada_Error"
3730 (and we are in VMS mode), also allow a non-Ada
3731 exception (a VMS condition) to match. */
3733 {
3734 tree gnu_comp
3735 = build_component_ref
3736 (build_unary_op
3741 this_choice
3742 = build_binary_op
3744 build_binary_op
3748 this_choice);
3749 }
3750 }
3751 else
3756 }
3761 }
3763 /* Tell the back end that we start an exception handler if necessary. */
3765 {
3766 /* We build a TREE_LIST of nodes representing what exception
3767 types this handler is able to catch, with special cases
3768 for others and all others cases.
3770 Each exception type is actually identified by a pointer to the
3771 exception id, with special value zero for "others" and one for
3772 "all others". Beware that these special values are known and used
3773 by the personality routine to identify the corresponding specific
3774 kinds of handlers.
3776 ??? For initial time frame reasons, the others and all_others
3777 cases have been handled using specific type trees, but this
3778 somehow hides information to the back-end, which expects NULL to
3779 be passed for catch all and end_cleanup to be used for cleanups.
3781 Care should be taken to ensure that the control flow impact of
3782 such clauses is rendered in some way. lang_eh_type_covers is
3783 doing the trick currently. */
3790 {
3792 gnu_etype
3797 {
3800 /* Exception may be a renaming. Recover original exception
3801 which is the one elaborated and registered. */
3807 gnu_etype
3810 /* The Non_Ada_Error case for VMS exceptions is handled
3811 by the personality routine. */
3812 }
3813 else
3816 /* The GCC interface expects NULL to be passed for catch all
3817 handlers, so it would be quite tempting to set gnu_etypes_list
3818 to NULL if gnu_etype is integer_zero_node. It would not work,
3819 however, because GCC's notion of "catch all" is stronger than
3820 our notion of "others". Until we correctly use the cleanup
3821 interface as well, the doing tht would prevent the "all
3822 others" handlers from beeing seen, because nothing can be
3823 caught beyond a catch all from GCC's point of view. */
3824 gnu_etypes_list
3827 }
3834 {
3835 /* Expand a call to the begin_handler hook at the beginning of the
3836 handler, and arrange for a call to the end_handler hook to
3837 occur on every possible exit path.
3839 The hooks expect a pointer to the low level occurrence. This
3840 is required for our stack management scheme because a raise
3841 inside the handler pushes a new occurrence on top of the
3842 stack, which means that this top does not necessarily match
3843 the occurrence this handler was dealing with.
3845 The EXC_PTR_EXPR object references the exception occurrence
3846 beeing propagated. Upon handler entry, this is the exception
3847 for which the handler is triggered. This might not be the case
3848 upon handler exit, however, as we might have a new occurrence
3849 propagated by the handler's body, and the end_handler hook
3850 called as a cleanup in this context.
3852 We use a local variable to retrieve the incoming value at
3853 handler entry time, and reuse it to feed the end_handler
3854 hook's argument at exit time. */
3855 tree gnu_current_exc_ptr
3857 tree gnu_incoming_exc_ptr
3865 expand_expr_stmt
3867 expand_decl_cleanup
3869 }
3870 }
3877 {
3878 /* Tell the back end that we're done with the current handler. */
3882 }
3883 else
3884 /* At the end of the handler, exit the block. We made this block in
3885 N_Handled_Sequence_Of_Statements. */
3893 /*******************************/
3894 /* Chapter 12: Generic Units: */
3895 /*******************************/
3905 /* These nodes can appear on a declaration list but there is nothing to
3906 to be done with them. */
3909 /***************************************************/
3910 /* Chapter 13: Representation Clauses and */
3911 /* Implementation-Dependent Features: */
3912 /***************************************************/
3916 /* The only one we need deal with is for 'Address. For the others, SEM
3917 puts the information elsewhere. We need only deal with 'Address
3918 if the object has a Freeze_Node (which it never will currently). */
3923 /* Get the value to use as the address and save it as the
3924 equivalent for GNAT_TEMP. When the object is frozen,
3925 gnat_to_gnu_entity will do the right thing. */
3933 /* We do nothing with these. SEM puts the information elsewhere. */
3938 {
3944 /* First process inputs, then outputs, then clobbers. */
3947 {
3952 gnu_input_list
3955 }
3959 {
3964 gnu_orig_out_list
3966 gnu_output_list
3969 }
3973 gnu_clobber_list
3976 gnu_clobber_list);
3983 gnu_clobber_list);
3985 }
3988 /***************************************************/
3989 /* Added Nodes */
3990 /***************************************************/
4006 {
4008 tree gnu_obj_type;
4009 tree gnu_obj_size;
4012 /* If this is a thin pointer, we must dereference it to create
4013 a fat pointer, then go back below to a thin pointer. The
4014 reason for this is that we need a fat pointer someplace in
4015 order to properly compute the size. */
4019 gnu_ptr));
4021 /* If this is an unconstrained array, we know the object must
4022 have been allocated with the template in front of the object.
4023 So pass the template address, but get the total size. Do this
4024 by converting to a thin pointer. */
4026 gnu_ptr
4028 (TYPE_OBJECT_RECORD_TYPE
4030 gnu_ptr);
4038 {
4041 tree gnu_byte_offset
4048 }
4050 gnu_result
4052 build_call_alloc_dealloc
4056 }
4069 /* If the type is VOID, this is a statement, so we need to
4070 generate the code for the call. Handle a Condition, if there
4071 is one. */
4073 {
4082 }
4083 else
4088 /* If the result is a pointer type, see if we are either converting
4089 from a non-pointer or from a pointer to a type with a different
4090 alias set and warn if so. If the result defined in the same unit as
4091 this unchecked convertion, we can allow this because we can know to
4092 make that type have alias set 0. */
4093 {
4104 {
4105 post_error_ne
4108 post_error
4110 gnat_node);
4111 post_error_ne
4114 }
4115 }
4127 }
4129 /* If the result is a statement, set needed flags and return it. */
4131 {
4136 }
4138 /* If the result is a constant that overflows, raise constraint error. */
4141 {
4144 gnu_result
4147 }
4149 /* If our result has side-effects and is of an unconstrained type,
4150 make a SAVE_EXPR so that we can be sure it will only be referenced
4151 once. Note we must do this before any conversions. */
4157 /* Now convert the result to the proper type. If the type is void or if
4158 we have no result, return error_mark_node to show we have no result.
4159 If the type of the result is correct or if we have a label (which doesn't
4160 have any well-defined type), return our result. Also don't do the
4161 conversion if the "desired" type involves a PLACEHOLDER_EXPR in its size
4162 since those are the cases where the front end may have the type wrong due
4163 to "instantiating" the unconstrained record with discriminant values
4164 or if this is a FIELD_DECL. If this is the Name of an assignment
4165 statement or a parameter of a procedure call, return what we have since
4166 the RHS has to be converted to our type there in that case, unless
4167 GNU_RESULT_TYPE has a simpler size. Similarly, if the two types are
4168 record types with the same name, the expression type has integral mode,
4169 and GNU_RESULT_TYPE BLKmode, don't convert. This will be the case when
4170 we are converting from a packable type to its actual type and we need
4171 those conversions to be NOPs in order for assignments into these types to
4172 work properly if the inner object is a bitfield and hence can't have
4173 its address taken. Finally, don't convert integral types that are the
4174 operand of an unchecked conversion since we need to ignore those
4175 conversions (for 'Valid). Otherwise, convert the result to the proper
4176 type. */
4196 && (CONTAINS_PLACEHOLDER_P
4200 {
4201 /* In this case remove padding only if the inner object is of
4202 self-referential size: in that case it must be an object of
4203 unconstrained type with a default discriminant. In other cases,
4204 we want to avoid copying too much data. */
4211 gnu_result);
4212 }
4228 {
4229 /* Remove any padding record, but do nothing more in this case. */
4233 gnu_result);
4234 }
4242 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RESULT. */
4249 }
4250 \f
4251 /* INSN is a list of insns. Return the first rtl in the list that isn't
4252 an INSN_NOTE_DELETED. */
4254 static rtx
4256 {
4260 ;
4263 }
4264 \f
4265 /* Push the BLOCK_STMT stack and allocate a new BLOCK_STMT. */
4267 static tree
4269 {
4270 tree gnu_block_stmt;
4272 /* First see if we can get one from the free list. */
4274 {
4277 }
4278 else
4279 {
4282 }
4289 }
4291 /* Add GNU_STMT to the current BLOCK_STMT node. We add them backwards
4292 order and the reverse in end_block_stmt. */
4294 void
4296 {
4301 {
4304 }
4306 /* If this is a DECL_STMT for a variable with DECL_INIT_BY_ASSIGN_P set,
4307 generate the assignment statement too. */
4311 {
4314 tree gnu_assign_stmt;
4316 /* If decl has a padded type, convert it to the unpadded type so the
4317 assignment is done properly. */
4320 gnu_lhs
4323 gnu_assign_stmt
4333 }
4334 }
4336 /* Add a declaration statement for GNU_DECL to the current BLOCK_STMT node.
4337 Get SLOC from Entity_Id. */
4339 void
4341 {
4342 tree gnu_stmt;
4344 /* If this is a variable that Gigi is to ignore, we may have been given
4345 an ERROR_MARK. So test for it. We also might have been given a
4346 reference for a renaming. So only do something for a decl. */
4354 }
4356 /* Return the BLOCK_STMT that corresponds to the statement that add_stmt
4357 has been emitting or just a single statement if only one. */
4359 static tree
4361 {
4368 /* If we have only one statement, return it and free this node. Otherwise,
4369 finish setting up this node and return it. If we have no statements,
4370 return a NULL_STMT. */
4372 {
4375 }
4378 else
4379 {
4384 }
4387 {
4390 }
4393 }
4395 /* Build a BLOCK_STMT from GNAT_LIST, a possibly-empty list of statements. */
4397 static tree
4399 {
4401 Node_Id gnat_node;
4415 }
4417 /* Build an EXPR_STMT to evaluate INSNS. Use Sloc from GNAT_NODE. */
4419 static tree
4421 {
4434 }
4435 \f
4436 /* GNU_STMT is a statement. We generate code for that statement. */
4438 void
4440 {
4447 {
4458 else
4459 {
4465 {
4468 }
4469 }
4486 {
4492 }
4495 {
4498 }
4517 else
4528 /* Copy all the intermediate outputs into the specified outputs. */
4531 gnu_elmt;
4535 {
4536 expand_expr_stmt
4541 }
4546 }
4547 }
4548 \f
4549 /* Force references to each of the entities in packages GNAT_NODE with's
4550 so that the debugging information for all of them are identical
4551 in all clients. Operate recursively on anything it with's, but check
4552 that we aren't elaborating something more than once. */
4554 /* The reason for this routine's existence is two-fold.
4555 First, with some debugging formats, notably MDEBUG on SGI
4556 IRIX, the linker will remove duplicate debugging information if two
4557 clients have identical debugguing information. With the normal scheme
4558 of elaboration, this does not usually occur, since entities in with'ed
4559 packages are elaborated on demand, and if clients have different usage
4560 patterns, the normal case, then the order and selection of entities
4561 will differ. In most cases however, it seems that linkers do not know
4562 how to eliminate duplicate debugging information, even if it is
4563 identical, so the use of this routine would increase the total amount
4564 of debugging information in the final executable.
4566 Second, this routine is called in type_annotate mode, to compute DDA
4567 information for types in withed units, for ASIS use */
4569 static void
4571 {
4574 /* Process each unit only once. As we trace the context of all relevant
4575 units transitively, including generic bodies, we may encounter the
4576 same generic unit repeatedly */
4581 /* Save entities in all context units. A body may have an implicit_with
4582 on its own spec, if the context includes a child unit, so don't save
4583 the spec twice. */
4591 {
4595 {
4612 }
4614 {
4615 Node_Id gnat_body
4618 /* Retrieve compilation unit node of generic body. */
4623 /* If body is available, elaborate its context. */
4626 }
4627 }
4631 }
4632 \f
4633 /* Do the processing of N_Freeze_Entity, GNAT_NODE. */
4635 static void
4637 {
4639 tree gnu_old;
4640 tree gnu_new;
4641 tree gnu_init
4646 /* If this is a package, need to generate code for the package. */
4648 {
4649 insert_code_for
4653 }
4655 /* Check for old definition after the above call. This Freeze_Node
4656 might be for one its Itypes. */
4657 gnu_old
4660 /* If this entity has an Address representation clause, GNU_OLD is the
4661 address, so discard it here. */
4665 /* Don't do anything for class-wide types they are always
4666 transformed into their root type. */
4672 /* Don't do anything for subprograms that may have been elaborated before
4673 their freeze nodes. This can happen, for example because of an inner call
4674 in an instance body. */
4681 /* If we have a non-dummy type old tree, we have nothing to do. Unless
4682 this is the public view of a private type whose full view was not
4683 delayed, this node was never delayed as it should have been.
4684 Also allow this to happen for concurrent types since we may have
4685 frozen both the Corresponding_Record_Type and this type. */
4689 {
4696 else
4698 }
4700 /* Reset the saved tree, if any, and elaborate the object or type for real.
4701 If there is a full declaration, elaborate it and copy the type to
4702 GNAT_ENTITY. Likewise if this is the record subtype corresponding to
4703 a class wide type or subtype. */
4705 {
4714 }
4718 {
4721 /* The above call may have defined this entity (the simplest example
4722 of this is when we have a private enumeral type since the bounds
4723 will have the public view. */
4729 }
4730 else
4733 /* If we've made any pointers to the old version of this type, we
4734 have to update them. */
4738 }
4739 \f
4740 /* Process the list of inlined subprograms of GNAT_NODE, which is an
4741 N_Compilation_Unit. */
4743 static void
4745 {
4746 Entity_Id gnat_entity;
4747 Node_Id gnat_body;
4749 /* If we can inline, generate RTL for all the inlined subprograms.
4750 Define the entity first so we set DECL_EXTERNAL. */
4755 {
4759 {
4760 /* ??? This really should always be Present. */
4764 gnat_body
4766 }
4769 {
4772 }
4773 }
4774 }
4775 \f
4776 /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present.
4777 We make two passes, one to elaborate anything other than bodies (but
4778 we declare a function if there was no spec). The second pass
4779 elaborates the bodies.
4781 GNAT_END_LIST gives the element in the list past the end. Normally,
4782 this is Empty, but can be First_Real_Statement for a
4783 Handled_Sequence_Of_Statements.
4785 We make a complete pass through both lists if PASS1P is true, then make
4786 the second pass over both lists if PASS2P is true. The lists usually
4787 correspond to the public and private parts of a package. */
4789 static void
4792 {
4794 Node_Id gnat_decl;
4804 {
4807 /* For package specs, we recurse inside the declarations,
4808 thus taking the two pass approach inside the boundary. */
4816 /* Similarly for any declarations in the actions of a
4817 freeze node. */
4819 {
4824 }
4826 /* Package bodies with freeze nodes get their elaboration deferred
4827 until the freeze node, but the code must be placed in the right
4828 place, so record the code position now. */
4836 (Corresponding_Spec
4839 record_code_position
4842 /* We defer most subprogram bodies to the second pass. */
4844 {
4846 {
4852 }
4853 }
4854 /* For bodies and stubs that act as their own specs, the entity
4855 itself must be elaborated in the first pass, because it may
4856 be used in other declarations. */
4858 {
4859 Node_Id gnat_subprog_id =
4866 }
4868 /* Concurrent stubs stand for the corresponding subprogram bodies,
4869 which are deferred like other bodies. */
4872 ;
4874 else
4875 {
4879 }
4880 }
4882 /* Here we elaborate everything we deferred above except for package bodies,
4883 which are elaborated at their freeze nodes. Note that we must also
4884 go inside things (package specs and freeze nodes) the first pass did. */
4890 {
4906 }
4907 }
4908 \f
4909 /* Emit code for a range check. GNU_EXPR is the expression to be checked,
4910 GNAT_RANGE_TYPE the gnat type or subtype containing the bounds against
4911 which we have to check. */
4913 static tree
4915 {
4921 /* If GNU_EXPR has an integral type that is narrower than GNU_RANGE_TYPE,
4922 we can't do anything since we might be truncating the bounds. No
4923 check is needed in this case. */
4929 /* Checked expressions must be evaluated only once. */
4932 /* There's no good type to use here, so we might as well use
4933 integer_type_node. Note that the form of the check is
4934 (not (expr >= lo)) or (not (expr >= hi))
4935 the reason for this slightly convoluted form is that NaN's
4936 are not considered to be in range in the float case. */
4937 return emit_check
4939 invert_truthvalue
4943 invert_truthvalue
4947 gnu_high)))),
4949 }
4950 \f
4951 /* Emit code for an index check. GNU_ARRAY_OBJECT is the array object
4952 which we are about to index, GNU_EXPR is the index expression to be
4953 checked, GNU_LOW and GNU_HIGH are the lower and upper bounds
4954 against which GNU_EXPR has to be checked. Note that for index
4955 checking we cannot use the emit_range_check function (although very
4956 similar code needs to be generated in both cases) since for index
4957 checking the array type against which we are checking the indeces
4958 may be unconstrained and consequently we need to retrieve the
4959 actual index bounds from the array object itself
4960 (GNU_ARRAY_OBJECT). The place where we need to do that is in
4961 subprograms having unconstrained array formal parameters */
4963 static tree
4965 tree gnu_expr,
4966 tree gnu_low,
4967 tree gnu_high)
4968 {
4969 tree gnu_expr_check;
4971 /* Checked expressions must be evaluated only once. */
4974 /* Must do this computation in the base type in case the expression's
4975 type is an unsigned subtypes. */
4978 /* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
4979 the object we are handling. */
4983 /* There's no good type to use here, so we might as well use
4984 integer_type_node. */
4985 return emit_check
4988 gnu_expr_check,
4990 gnu_low)),
4992 gnu_expr_check,
4994 gnu_high))),
4996 }
4997 \f
4998 /* Given GNU_COND which contains the condition corresponding to an access,
4999 discriminant or range check, of value GNU_EXPR, build a COND_EXPR
5000 that returns GNU_EXPR if GNU_COND is false and raises a
5001 CONSTRAINT_ERROR if GNU_COND is true. REASON is the code that says
5002 why the exception was raised. */
5004 static tree
5006 {
5007 tree gnu_call;
5008 tree gnu_result;
5012 /* Use an outer COMPOUND_EXPR to make sure that GNU_EXPR will get evaluated
5013 in front of the comparison in case it ends up being a SAVE_EXPR. Put the
5014 whole thing inside its own SAVE_EXPR so the inner SAVE_EXPR doesn't leak
5015 out. */
5019 gnu_expr));
5021 /* If GNU_EXPR has side effects, make the outer COMPOUND_EXPR and
5022 protect it. Otherwise, show GNU_RESULT has no side effects: we
5023 don't need to evaluate it just for the check. */
5025 gnu_result
5027 else
5030 /* ??? Unfortunately, if we don't put a SAVE_EXPR around this whole thing,
5031 we will repeatedly do the test. It would be nice if GCC was able
5032 to optimize this and only do it once. */
5034 }
5035 \f
5036 /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing
5037 overflow checks if OVERFLOW_P is nonzero and range checks if
5038 RANGE_P is nonzero. GNAT_TYPE is known to be an integral type.
5039 If TRUNCATE_P is nonzero, do a float to integer conversion with
5040 truncation; otherwise round. */
5042 static tree
5044 tree gnu_expr,
5048 {
5056 /* If we are not doing any checks, the output is an integral type, and
5057 the input is not a floating type, just do the conversion. This
5058 shortcut is required to avoid problems with packed array types
5059 and simplifies code in all cases anyway. */
5064 /* First convert the expression to its base type. This
5065 will never generate code, but makes the tests below much simpler.
5066 But don't do this if converting from an integer type to an unconstrained
5067 array type since then we need to get the bounds from the original
5068 (unpacked) type. */
5072 /* If overflow checks are requested, we need to be sure the result will
5073 fit in the output base type. But don't do this if the input
5074 is integer and the output floating-point. */
5077 {
5078 /* Ensure GNU_EXPR only gets evaluated once. */
5086 /* Convert the lower bounds to signed types, so we're sure we're
5087 comparing them properly. Likewise, convert the upper bounds
5088 to unsigned types. */
5102 /* Check each bound separately and only if the result bound
5103 is tighter than the bound on the input type. Note that all the
5104 types are base types, so the bounds must be constant. Also,
5105 the comparison is done in the base type of the input, which
5106 always has the proper signedness. First check for input
5107 integer (which means output integer), output float (which means
5108 both float), or mixed, in which case we always compare.
5109 Note that we have to do the comparison which would *fail* in the
5110 case of an error since if it's an FP comparison and one of the
5111 values is a NaN or Inf, the comparison will fail. */
5118 gnu_cond
5119 = invert_truthvalue
5122 gnu_out_lb)));
5130 gnu_cond
5132 invert_truthvalue
5134 gnu_input,
5136 gnu_out_ub))));
5140 CE_Overflow_Check_Failed);
5141 }
5143 /* Now convert to the result base type. If this is a non-truncating
5144 float-to-integer conversion, round. */
5147 {
5157 gnu_result
5159 }
5165 else
5168 /* Finally, do the range check if requested. Note that if the
5169 result type is a modular type, the range check is actually
5170 an overflow check. */
5178 }
5179 \f
5180 /* Return 1 if GNU_EXPR can be directly addressed. This is the case unless
5181 it is an expression involving computation or if it involves a bitfield
5182 reference. This returns the same as gnat_mark_addressable in most
5183 cases. */
5185 static int
5187 {
5189 {
5194 /* All DECLs are addressable: if they are in a register, we can force
5195 them to memory. */
5221 {
5222 /* This is addressable if we can avoid a copy. */
5236 }
5240 }
5241 }
5242 \f
5243 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
5244 a separate Freeze node exists, delay the bulk of the processing. Otherwise
5245 make a GCC type for GNAT_ENTITY and set up the correspondance. */
5247 void
5249 {
5250 tree gnu_old
5252 tree gnu_new;
5254 /* If we are to delay elaboration of this type, just do any
5255 elaborations needed for expressions within the declaration and
5256 make a dummy type entry for this node and its Full_View (if
5257 any) in case something points to it. Don't do this if it
5258 has already been done (the only way that can happen is if
5259 the private completion is also delayed). */
5265 {
5269 {
5278 }
5281 }
5283 /* If we saved away a dummy type for this node it means that this
5284 made the type that corresponds to the full type of an incomplete
5285 type. Clear that type for now and then update the type in the
5286 pointers. */
5288 {
5291 {
5292 /* If this was a withed access type, this is not an error
5293 and merely indicates we've already elaborated the type
5294 already. */
5299 }
5302 }
5304 /* Now fully elaborate the type. */
5310 /* If we have an old type and we've made pointers to this type,
5311 update those pointers. */
5316 /* If this is a record type corresponding to a task or protected type
5317 that is a completion of an incomplete type, perform a similar update
5318 on the type. */
5319 /* ??? Including protected types here is a guess. */
5324 {
5325 tree gnu_task_old
5335 }
5338 }
5339 \f
5340 /* GNAT_ASSOC is the front of the Component_Associations of an N_Aggregate.
5341 GNU_TYPE is the GCC type of the corresponding record.
5343 Return a CONSTRUCTOR to build the record. */
5345 static tree
5347 {
5350 /* We test for GNU_FIELD being empty in the case where a variant
5351 was the last thing since we don't take things off GNAT_ASSOC in
5352 that case. We check GNAT_ASSOC in case we have a variant, but it
5353 has no fields. */
5357 {
5362 /* The expander is supposed to put a single component selector name
5363 in every record component association */
5367 /* Before assigning a value in an aggregate make sure range checks
5368 are done if required. Then convert to the type of the field. */
5374 /* Add the field and expression to the list. */
5376 }
5380 /* Verify every enty in GNU_LIST was used. */
5386 }
5388 /* Builds a possibly nested constructor for array aggregates. GNAT_EXPR
5389 is the first element of an array aggregate. It may itself be an
5390 aggregate (an array or record aggregate). GNU_ARRAY_TYPE is the gnu type
5391 corresponding to the array aggregate. GNAT_COMPONENT_TYPE is the type
5392 of the array component. It is needed for range checking. */
5394 static tree
5396 tree gnu_array_type,
5397 Entity_Id gnat_component_type)
5398 {
5399 tree gnu_expr;
5403 {
5404 /* If the expression is itself an array aggregate then first build the
5405 innermost constructor if it is part of our array (multi-dimensional
5406 case). */
5413 gnat_component_type);
5414 else
5415 {
5418 /* before assigning the element to the array make sure it is
5419 in range */
5422 }
5424 gnu_expr_list
5426 gnu_expr_list);
5427 }
5430 }
5431 \f
5432 /* Subroutine of assoc_to_constructor: VALUES is a list of field associations,
5433 some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting
5434 of the associations that are from RECORD_TYPE. If we see an internal
5435 record, make a recursive call to fill it in as well. */
5437 static tree
5439 {
5444 {
5447 /* _Parent is an internal field, but may have values in the aggregate,
5448 so check for values first. */
5450 {
5453 }
5456 {
5461 }
5462 else
5463 /* If we have a record subtype, the names will match, but not the
5464 actual FIELD_DECLs. */
5467 {
5470 }
5476 }
5479 }
5480 \f
5481 /* EXP is to be treated as an array or record. Handle the cases when it is
5482 an access object and perform the required dereferences. */
5484 static tree
5486 {
5487 /* If the type is a pointer, dereference it. */
5492 /* If we got a padded type, remove it too. */
5498 }
5499 \f
5500 /* Protect EXP from multiple evaluation. This may make a SAVE_EXPR. */
5502 tree
5504 {
5507 /* If this has no side effects, we don't need to do anything. */
5511 /* If it is a conversion, protect what's inside the conversion.
5512 Similarly, if we're indirectly referencing something, we only
5513 actually need to protect the address since the data itself can't
5514 change in these situations. */
5523 /* If EXP is a fat pointer or something that can be placed into a register,
5524 just make a SAVE_EXPR. */
5528 /* Otherwise, dereference, protect the address, and re-reference. */
5529 else
5530 return
5534 exp)));
5535 }
5536 \f
5537 /* This is equivalent to stabilize_reference in GCC's tree.c, but we know
5538 how to handle our new nodes and we take an extra argument that says
5539 whether to force evaluation of everything. */
5541 tree
5543 {
5546 tree result;
5549 {
5553 /* No action is needed in this case. */
5565 result
5574 force));
5580 force),
5588 force),
5590 force));
5597 force));
5604 force));
5610 force),
5612 force));
5621 /* If arg isn't a kind of lvalue we recognize, make no change.
5622 Caller should recognize the error for an invalid lvalue. */
5628 }
5632 }
5634 /* Similar to stabilize_reference_1 in tree.c, but supports an extra
5635 arg to force a SAVE_EXPR for everything. */
5637 static tree
5639 {
5642 tree result;
5644 /* We cannot ignore const expressions because it might be a reference
5645 to a const array but whose index contains side-effects. But we can
5646 ignore things that are actual constant or that already have been
5647 handled by this function. */
5653 {
5666 /* Constants need no processing. In fact, we should never reach
5667 here. */
5671 /* Recursively stabilize each operand. */
5678 /* Recursively stabilize each operand. */
5681 force));
5686 }
5690 }
5691 \f
5692 /* GNAT_UNIT is the Defining_Identifier for some package or subprogram,
5693 either a spec or a body, BODY_P says which. If needed, make a function
5694 to be the elaboration routine for that object and perform the elaborations
5695 in GNU_ELAB_LIST.
5697 Return 1 if we didn't need an elaboration function, zero otherwise. */
5699 static int
5701 {
5702 tree gnu_decl;
5703 rtx insn;
5706 /* If we have nothing to do, return. */
5710 /* Prevent the elaboration list from being reclaimed by the GC. */
5712 gnu_elab_list);
5714 /* Set our file and line number to that of the object and set up the
5715 elaboration routine. */
5717 body_p ?
5729 /* Emit the assignments for the elaborations we have to do. If there
5730 is no destination, this is just a call to execute some statement
5731 that was placed within the declarative region. But first save a
5732 pointer so we can see if any insns were generated. */
5738 {
5741 }
5742 else
5743 {
5748 /* If LHS has a padded type, convert it to the unpadded type
5749 so the assignment is done properly. */
5758 }
5760 /* See if any non-NOTE insns were generated. */
5763 {
5766 }
5773 /* We are finished with the elaboration list it can now be discarded. */
5776 /* If there were no insns, we don't need an elab routine. It would
5777 be nice to not output this one, but there's no good way to do that. */
5779 }
5780 \f
5783 /* Determine the input_filename and the input_line from the source location
5784 (Sloc) of GNAT_NODE node. Set the global variable input_filename and
5785 input_line. If WRITE_NOTE_P is true, emit a line number note. */
5787 void
5789 {
5793 }
5795 /* Likewise, but passed a Sloc. */
5797 void
5799 {
5800 /* If node not from source code, ignore. */
5804 /* Use the identifier table to make a hashed, permanent copy of the filename,
5805 since the name table gets reallocated after Gigi returns but before all
5806 the debugging information is output. The __gnat_to_canonical_file_spec
5807 call translates filenames from pragmas Source_Reference that contain host
5808 style syntax not understood by gdb. */
5809 input_filename
5810 = IDENTIFIER_POINTER
5811 (get_identifier
5812 (__gnat_to_canonical_file_spec
5813 (Get_Name_String
5816 /* ref_filename is the reference file name as given by sinput (i.e no
5817 directory) */
5818 ref_filename
5819 = IDENTIFIER_POINTER
5820 (get_identifier
5821 (Get_Name_String
5827 }
5828 \f
5829 /* Post an error message. MSG is the error message, properly annotated.
5830 NODE is the node at which to post the error and the node to use for the
5831 "&" substitution. */
5833 void
5835 {
5836 String_Template temp;
5837 Fat_Pointer fp;
5843 }
5845 /* Similar, but NODE is the node at which to post the error and ENT
5846 is the node to use for the "&" substitution. */
5848 void
5850 {
5851 String_Template temp;
5852 Fat_Pointer fp;
5858 }
5860 /* Similar, but NODE is the node at which to post the error, ENT is the node
5861 to use for the "&" substitution, and N is the number to use for the ^. */
5863 void
5865 {
5866 String_Template temp;
5867 Fat_Pointer fp;
5875 }
5876 \f
5877 /* Similar to post_error_ne_num, but T is a GCC tree representing the
5878 number to write. If the tree represents a constant that fits within
5879 a host integer, the text inside curly brackets in MSG will be output
5880 (presumably including a '^'). Otherwise that text will not be output
5881 and the text inside square brackets will be output instead. */
5883 void
5885 {
5888 Fat_Pointer fp;
5896 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_INT
5897 &&
5898 compare_tree_int
5900 #endif
5901 )
5902 {
5905 }
5906 else
5910 {
5916 ;
5917 else
5919 }
5926 }
5928 /* Similar to post_error_ne_tree, except that NUM is a second
5929 integer to write in the message. */
5931 void
5933 Node_Id node,
5934 Entity_Id ent,
5935 tree t,
5937 {
5940 }
5942 /* Set the node for a second '&' in the error message. */
5944 void
5946 {
5948 }
5949 \f
5950 /* Signal abort, with "Gigi abort" as the error label, and error_gnat_node
5951 as the relevant node that provides the location info for the error */
5953 void
5955 {
5957 Fat_Pointer fp;
5963 }
5964 \f
5965 /* Initialize the table that maps GNAT codes to GCC codes for simple
5966 binary and unary operations. */
5968 void
5970 {
5996 }