| blob | 69e80d48c280c4f6d502e756cd0368f5aeed334e |
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 /* List of TREE_LIST nodes representing a stack of exception pointer
87 variables. TREE_VALUE is the VAR_DECL that stores the address of
88 the raised exception. Nonzero means we are in an exception
89 handler. Not used in the zero-cost case. */
92 /* List of TREE_LIST nodes containing pending elaborations lists.
93 used to prevent the elaborations being reclaimed by GC. */
96 /* Map GNAT tree codes to GCC tree codes for simple expressions. */
99 /* Current node being treated, in case gigi_abort called. */
100 Node_Id error_gnat_node;
102 /* Variable that stores a list of labels to be used as a goto target instead of
103 a return in some functions. See processing for N_Subprogram_Body. */
123 /* Constants for +0.5 and -0.5 for float-to-integer rounding. */
126 \f
127 /* This is the main program of the back-end. It sets up all the table
128 structures and then generates code. */
130 void
142 Int number_units ATTRIBUTE_UNUSED,
144 Entity_Id standard_integer,
145 Entity_Id standard_long_long_float,
146 Entity_Id standard_exception_type,
147 Int gigi_operating_mode)
148 {
149 tree gnu_standard_long_long_float;
150 tree gnu_standard_exception_type;
165 /* If we are just annotating types, give VOID_TYPE zero sizes to avoid
166 errors. */
168 {
171 }
173 /* See if we should discard file names in exception messages. */
181 /* Initialize ourselves. */
187 /* Enable GNAT stack checking method if needed */
191 /* Save the type we made for integer as the type for Standard.Integer.
192 Then make the rest of the standard types. Note that some of these
193 may be subtypes. */
202 gnu_standard_long_long_float
204 gnu_standard_exception_type
209 /* Process any Pragma Ident for the main unit. */
210 #ifdef ASM_OUTPUT_IDENT
212 ASM_OUTPUT_IDENT
215 #endif
217 /* If we are using the GCC exception mechanism, let GCC know. */
222 }
224 \f
225 /* This function is the driver of the GNAT to GCC tree transformation process.
226 GNAT_NODE is the root of some gnat tree. It generates code for that
227 part of the tree. */
229 void
231 {
232 tree gnu_root;
234 /* Save node number in case error */
239 /* If we return a statement, generate code for it. */
243 /* This should just generate code, not return a value. If it returns
244 a value, something is wrong. */
247 }
249 /* GNAT_NODE is the root of some GNAT tree. Return the root of the GCC
250 tree corresponding to that GNAT tree. Normally, no code is generated.
251 We just return an equivalent tree which is used elsewhere to generate
252 code. */
254 tree
256 {
257 tree gnu_root;
259 /* Save node number in case error */
264 /* If we got no code as a result, something is wrong. */
269 }
270 \f
271 /* This function is the driver of the GNAT to GCC tree transformation process.
272 It is the entry point of the tree transformer. GNAT_NODE is the root of
273 some GNAT tree. Return the root of the corresponding GCC tree or
274 error_mark_node to signal that there is no GCC tree to return.
276 The latter is the case if only code generation actions have to be performed
277 like in the case of if statements, loops, etc. This routine is wrapped
278 in the above two routines for most purposes. */
280 static tree
282 {
285 tree gnu_expr;
287 Node_Id gnat_temp;
288 Entity_Id gnat_temp_type;
290 /* Set input_file_name and lineno from the Sloc in the GNAT tree. */
293 /* If this is a Statement and we are at top level, we add the statement
294 as an elaboration for a null tree. That will cause it to be placed
295 in the elaboration procedure. */
308 {
312 }
314 /* If this node is a non-static subexpression and we are only
315 annotating types, make this into a NULL_EXPR for non-VOID types
316 and error_mark_node for void return types. But allow
317 N_Identifier since we use it for lots of things, including
318 getting trees for discriminants. */
324 {
329 else
332 }
335 {
336 /********************************/
337 /* Chapter 2: Lexical Elements: */
338 /********************************/
345 /* If the Etype of this node does not equal the Etype of the
346 Entity, something is wrong with the entity map, probably in
347 generic instantiation. However, this does not apply to
348 types. Since we sometime have strange Ekind's, just do
349 this test for objects. Also, if the Etype of the Entity is
350 private, the Etype of the N_Identifier is allowed to be the full
351 type and also we consider a packed array type to be the same as
352 the original type. Similarly, a class-wide type is equivalent
353 to a subtype of itself. Finally, if the types are Itypes,
354 one may be a copy of the other, which is also legal. */
378 /* If this is a reference to a deferred constant whose partial view
379 is an unconstrained private type, the proper type is on the full
380 view of the constant, not on the full view of the type, which may
381 be unconstrained.
383 This may be a reference to a type, for example in the prefix of the
384 attribute Position, generated for dispatching code (see Make_DT in
385 exp_disp,adb). In that case we need the type itself, not is parent,
386 in particular if it is a derived type */
392 {
396 }
397 else
398 {
399 /* Expand the type of this identitier first, in case it is
400 an enumeral literal, which only get made when the type
401 is expanded. There is no order-of-elaboration issue here.
402 We want to use the Actual_Subtype if it has already been
403 elaborated, otherwise the Etype. Avoid using Actual_Subtype
404 for packed arrays to simplify things. */
412 else
416 }
420 /* If we are in an exception handler, force this variable into memory
421 to ensure optimization does not remove stores that appear
422 redundant but are actually needed in case an exception occurs.
424 ??? Note that we need not do this if the variable is declared within
425 the handler, only if it is referenced in the handler and declared
426 in an enclosing block, but we have no way of testing that
427 right now. */
429 {
432 }
434 /* Some objects (such as parameters passed by reference, globals of
435 variable size, and renamed objects) actually represent the address
436 of the object. In that case, we must do the dereference. Likewise,
437 deal with parameters to foreign convention subprograms. Call fold
438 here since GNU_RESULT may be a CONST_DECL. */
443 {
449 gnu_result);
454 }
456 /* The GNAT tree has the type of a function as the type of its result.
457 Also use the type of the result if the Etype is a subtype which
458 is nominally unconstrained. But remove any padding from the
459 resulting type. */
462 {
467 }
469 /* We always want to return the underlying INTEGER_CST for an
470 enumeration literal to avoid the need to call fold in lots
471 of places. But don't do this is the parent will be taking
472 the address of this object. */
474 {
488 }
492 {
493 tree gnu_type;
495 /* Get the type of the result, looking inside any padding and
496 left-justified modular types. Then get the value in that type. */
505 /* If the result overflows (meaning it doesn't fit in its base type),
506 abort. We would like to check that the value is within the range
507 of the subtype, but that causes problems with subtypes whose usage
508 will raise Constraint_Error and with biased representation, so
509 we don't. */
512 }
516 /* If a Entity is present, it means that this was one of the
517 literals in a user-defined character type. In that case,
518 just return the value in the CONST_DECL. Otherwise, use the
519 character code. In that case, the base type should be an
520 INTEGER_TYPE, but we won't bother checking for that. */
524 else
530 /* If this is of a fixed-point type, the value we want is the
531 value of the corresponding integer. */
533 {
536 gnu_result_type);
539 }
541 /* We should never see a Vax_Float type literal, since the front end
542 is supposed to transform these using appropriate conversions */
546 else
547 {
552 /* If the real value is zero, so is the result. Otherwise,
553 convert it to a machine number if it isn't already. That
554 forces BASE to 0 or 2 and simplifies the rest of our logic. */
557 else
558 {
560 ur_realval
564 gnu_result
567 /* If we have a base of zero, divide by the denominator.
568 Otherwise, the base must be 2 and we scale the value, which
569 we know can fit in the mantissa of the type (hence the use
570 of that type above). */
572 gnu_result
575 gnu_result,
577 gnu_result_type));
581 else
582 {
583 REAL_VALUE_TYPE tmp;
588 }
589 }
591 /* Now see if we need to negate the result. Do it this way to
592 properly handle -0. */
594 gnu_result
596 gnu_result);
597 }
604 {
605 /* We assume here that all strings are of type standard.string.
606 "Weird" types of string have been converted to an aggregate
607 by the expander. */
613 /* Build the string with the characters in the literal. Note
614 that Ada strings are 1-origin. */
618 /* Put a null at the end of the string in case it's in a context
619 where GCC will want to treat it as a C string. */
624 /* Strings in GCC don't normally have types, but we want
625 this to not be converted to the array type. */
627 }
628 else
629 {
630 /* Build a list consisting of each character, then make
631 the aggregate. */
638 gnu_list
644 gnu_list);
646 gnu_result
648 }
655 /* Check for (and ignore) unrecognized pragma */
660 {
662 /* Do nothing at top level: all such variables are already
663 viewable. */
671 {
679 }
685 {
699 }
706 }
709 /**************************************/
710 /* Chapter 3: Declarations and Types: */
711 /**************************************/
726 /* If we are just annotating types and this object has an unconstrained
727 or task type, don't elaborate it. */
738 && (! type_annotate_only
740 {
745 /* If this object has its elaboration delayed, we must force
746 evaluation of GNU_EXPR right now and save it for when the object
747 is frozen. */
749 {
752 gnu_expr
756 else
760 }
761 }
762 else
777 /* Don't do anything if this renaming is handled by the front end.
778 or if we are just annotating types and this object has a
779 composite or task type, don't elaborate it. */
781 && ! (type_annotate_only
785 {
788 }
799 /* These are fully handled in the front end. */
802 /*************************************/
803 /* Chapter 4: Names and Expressions: */
804 /*************************************/
813 {
815 tree gnu_type;
823 /* If we got a padded type, remove it too. */
826 gnu_array_object
828 gnu_array_object);
832 /* First compute the number of dimensions of the array, then
833 fill the expression array, the order depending on whether
834 this is a Convention_Fortran array or not. */
839 ;
848 else
856 {
864 gnu_expr
865 = emit_index_check
872 }
873 }
879 {
880 tree gnu_type;
886 /* Do any implicit dereferences of the prefix and do any needed
887 range check. */
892 {
893 /* Get the bounds of the slice. */
894 tree gnu_index_type
900 /* Check to see that the minimum slice value is in range */
901 gnu_expr_l
902 = emit_index_check
907 /* Check to see that the maximum slice value is in range */
908 gnu_expr_h
909 = emit_index_check
914 /* Derive a good type to convert everything too */
917 /* Build a compound expression that does the range checks */
918 gnu_expr
923 /* Build a conditional expression that returns the range checks
924 expression if the slice range is not null (max >= min) or
925 returns the min if the slice range is null */
926 gnu_expr
930 gnu_max_expr),
932 gnu_min_expr)),
934 }
935 else
940 }
944 {
948 tree gnu_field;
952 {
957 }
961 /* For discriminant references in tagged types always substitute the
962 corresponding discriminant as the actual selected component. */
968 /* For discriminant references of untagged types always substitute the
969 corresponding stored discriminant. */
974 /* Handle extracting the real or imaginary part of a complex.
975 The real part is the first field and the imaginary the last. */
981 else
982 {
985 /* If there are discriminants, the prefix might be
986 evaluated more than once, which is a problem if it has
987 side-effects. */
994 gnu_result
998 }
1004 }
1008 {
1009 /* The attribute designator (like an enumeration value). */
1012 tree gnu_prefix;
1013 tree gnu_type;
1015 /* The Elab_Spec and Elab_Body attributes are special in that
1016 Prefix is a unit, not an object with a GCC equivalent. Similarly
1017 for Elaborated, since that variable isn't otherwise known. */
1019 {
1020 gnu_prefix
1021 = create_subprog_decl
1023 attribute == Attr_Elab_Body
1027 }
1032 /* If the input is a NULL_EXPR, make a new one. */
1034 {
1039 }
1042 {
1045 /* These are just conversions until since representation
1046 clauses for enumerations are handled in the front end. */
1047 {
1054 }
1059 /* These just add or subject the constant 1. Representation
1060 clauses for enumerations are handled in the front-end. */
1065 {
1067 gnu_expr
1068 = emit_check
1070 gnu_expr,
1071 attribute == Attr_Pred
1075 }
1077 gnu_result
1087 /* Conversions don't change something's address but can cause
1088 us to miss the COMPONENT_REF case below, so strip them off. */
1089 gnu_prefix
1093 /* If we are taking 'Address of an unconstrained object,
1094 this is the pointer to the underlying array. */
1097 /* ... fall through ... */
1104 gnu_result
1111 /* For 'Code_Address, find an inner ADDR_EXPR and mark it
1112 so that we don't try to build a trampoline. */
1114 {
1120 ;
1124 }
1129 {
1130 tree gnu_obj_type;
1135 /* If this is an unconstrained array, we know the object must
1136 have been allocated with the template in front of the object.
1137 So compute the template address.*/
1140 gnu_ptr
1142 (TYPE_OBJECT_RECORD_TYPE
1144 gnu_ptr);
1149 {
1152 tree gnu_byte_offset
1159 }
1162 }
1172 /* Remove NOPS from gnu_expr and conversions from gnu_prefix.
1173 We only use GNU_EXPR to see if a COMPONENT_REF was involved. */
1181 /* Replace an unconstrained array type with the type of the
1182 underlying array. We can't do this with a call to
1183 maybe_unconstrained_array since we may have a TYPE_DECL.
1184 For 'Max_Size_In_Storage_Elements, use the record type
1185 that will be used to allocate the object and its template. */
1188 {
1192 }
1194 /* If we are looking for the size of a field, return the
1195 field size. Otherwise, if the prefix is an object,
1196 or if 'Object_Size or 'Max_Size_In_Storage_Elements has
1197 been specified, the result is the GCC size of the type.
1198 Otherwise, the result is the RM_Size of the type. */
1204 {
1205 /* If this is a padded type, the GCC size isn't relevant
1206 to the programmer. Normally, what we want is the RM_Size,
1207 which was set from the specified size, but if it was not
1208 set, we want the size of the relevant field. Using the MAX
1209 of those two produces the right result in all case. Don't
1210 use the size of the field if it's a self-referential type,
1211 since that's never what's wanted. */
1215 {
1219 gnu_result
1222 }
1223 else
1225 }
1226 else
1232 /* Deal with a self-referential size by returning the maximum
1233 size for a type and by qualifying the size with
1234 the object for 'Size of an object. */
1237 {
1241 else
1243 }
1245 /* If the type contains a template, subtract the size of the
1246 template. */
1254 /* Always perform division using unsigned arithmetic as the
1255 size cannot be negative, but may be an overflowed positive
1256 value. This provides correct results for sizes up to 512 MB.
1257 ??? Size should be calculated in storage elements directly. */
1262 gnu_result,
1263 bitsize_unit_node)));
1270 && (TYPE_IS_PADDING_P
1279 gnu_result
1281 else
1292 {
1299 else
1300 gnu_result
1301 = build_binary_op
1303 build_binary_op
1315 }
1316 /* ... fall through ... */
1318 {
1319 int Dimension
1324 /* Make sure any implicit dereference gets done. */
1332 {
1334 tree gnu_type_temp;
1340 ;
1343 }
1352 gnu_result
1355 gnu_result
1357 else
1358 /* 'Length or 'Range_Length. */
1359 {
1360 tree gnu_compute_type
1361 = gnat_signed_or_unsigned_type
1364 gnu_result
1365 = build_binary_op
1367 build_binary_op
1369 build_binary_op
1372 TYPE_MAX_VALUE
1375 TYPE_MIN_VALUE
1379 }
1381 /* If this has a PLACEHOLDER_EXPR, qualify it by the object
1382 we are handling. Note that these attributes could not
1383 have been used on an unconstrained array type. */
1389 }
1396 {
1397 HOST_WIDE_INT bitsize;
1398 HOST_WIDE_INT bitpos;
1399 tree gnu_offset;
1400 tree gnu_field_bitpos;
1401 tree gnu_field_offset;
1402 tree gnu_inner;
1410 /* We can have 'Bit on any object, but if it isn't a
1411 COMPONENT_REF, the result is zero. Do not allow
1412 'Bit on a bare component, though. */
1416 {
1419 }
1430 {
1431 gnu_field_bitpos
1433 gnu_field_offset
1440 {
1441 gnu_field_bitpos
1445 gnu_field_offset
1449 }
1450 }
1452 {
1455 }
1456 else
1457 {
1460 }
1463 {
1475 gnu_result
1479 bitsize_one_node);
1485 }
1487 /* If this has a PLACEHOLDER_EXPR, qualify it by the object
1488 we are handling. */
1494 }
1517 && (TYPE_IS_PADDING_P
1525 gnu_type
1535 /* Note this size cannot be self-referential. */
1542 /* This is just a zero cast to the pointer type for
1543 our prefix and dereferenced. */
1545 gnu_result
1548 integer_zero_node));
1553 {
1560 {
1565 ;
1566 }
1574 && (DECL_BY_COMPONENT_PTR_P
1578 }
1582 /* Say we have an unimplemented attribute. Then set the
1583 value to be returned to be a zero and hope that's something
1584 we can convert to the type of this attribute. */
1590 }
1592 /* If this is an attribute where the prefix was unused,
1593 force a use of it if it has a side-effect. But don't do it if
1594 the prefix is just an entity name. However, if an access check
1595 is needed, we must do it. See second example in AARM 11.6(5.e). */
1600 }
1604 /* Like 'Access as far as we are concerned. */
1612 {
1613 tree gnu_aggr_type;
1615 /* ??? It is wrong to evaluate the type now, but there doesn't
1616 seem to be any other practical way of doing it. */
1618 gnu_aggr_type = gnu_result_type
1623 gnu_aggr_type
1630 gnu_result
1632 gnu_aggr_type);
1634 {
1635 /* The first element is the discrimant, which we ignore. The
1636 next is the field we're building. Convert the expression
1637 to the type of the field and then to the union type. */
1638 Node_Id gnat_assoc
1641 tree gnu_field_type
1646 }
1649 gnu_aggr_type,
1652 gnu_result
1653 = build_binary_op
1658 (Next
1660 else
1664 }
1674 /* Get the operand expression. */
1678 gnu_result
1690 /* If the result is a pointer type, see if we are improperly
1691 converting to a stricter alignment. */
1695 {
1701 post_error_ne_tree_2
1705 }
1713 {
1716 tree gnu_low;
1717 tree gnu_high;
1719 /* GNAT_RANGE is either an N_Range node or an identifier
1720 denoting a subtype. */
1722 {
1725 }
1728 {
1733 }
1734 else
1739 /* If LOW and HIGH are identical, perform an equality test.
1740 Otherwise, ensure that GNU_OBJECT is only evaluated once
1741 and perform a full range test. */
1745 else
1746 {
1748 gnu_result
1754 }
1758 }
1766 ? RDIV_EXPR
1773 {
1774 /* Some processing below (e.g. clear_last_expr) requires access to
1775 status fields now maintained in the current function context, so
1776 we'll setup a dummy one if needed. We cannot use global_binding_p,
1777 since it might be true due to force_global and making a dummy
1778 context would kill the current function context. */
1781 tree gnu_rhs_side;
1786 /* The elaboration of the RHS may generate code. If so,
1787 we need to make sure it gets executed after the LHS. */
1802 gnu_rhs);
1805 }
1809 /* These can either be operations on booleans or on modular types.
1810 Fall through for boolean types since that's the way GNU_CODES is
1811 set up. */
1813 Modular_Integer_Kind))
1814 {
1815 enum tree_code code
1826 }
1828 /* ... fall through ... */
1839 {
1841 tree gnu_type;
1847 /* If this is a comparison operator, convert any references to
1848 an unconstrained array value into a reference to the
1849 actual array. */
1851 {
1854 }
1856 /* If the result type is a private type, its full view may be a
1857 numeric subtype. The representation we need is that of its base
1858 type, given that it is the result of an arithmetic operation. */
1860 gnu_type = gnu_result_type
1863 /* If this is a shift whose count is not guaranteed to be correct,
1864 we need to adjust the shift count. */
1867 {
1869 tree gnu_max_shift
1877 gnu_rhs
1878 = build_binary_op
1881 gnu_count_type,
1882 gnu_max_shift,
1884 integer_one_node)),
1885 gnu_rhs);
1886 }
1888 /* For right shifts, the type says what kind of shift to do,
1889 so we may need to choose a different type. */
1898 {
1901 }
1905 /* If this is a logical shift with the shift count not verified,
1906 we must return zero if it is too large. We cannot compensate
1907 above in this case. */
1911 gnu_result
1912 = build_cond_expr
1915 gnu_rhs,
1919 gnu_result);
1920 }
1924 {
1927 tree gnu_false
1934 }
1943 /* This case can apply to a boolean or a modular type.
1944 Fall through for a boolean operand since GNU_CODES is set
1945 up to handle this. */
1947 {
1951 gnu_expr);
1953 }
1955 /* ... fall through ... */
1962 else
1971 {
1973 tree gnu_type;
1977 /* The Expression operand can either be an N_Identifier or
1978 Expanded_Name, which must represent a type, or a
1979 N_Qualified_Expression, which contains both the object type and an
1980 initial value for the object. */
1985 {
1986 Entity_Id gnat_desig_type
1997 {
2000 }
2001 else
2002 {
2008 }
2009 }
2010 else
2017 }
2020 /***************************/
2021 /* Chapter 5: Statements: */
2022 /***************************/
2026 {
2032 /* If this is the first label of an exception handler, we must
2033 mark that any CALL_INSN can jump to it. */
2037 nonlocal_goto_handler_labels
2039 nonlocal_goto_handler_labels);
2040 }
2050 /* Get the LHS and RHS of the statement and convert any reference to an
2051 unconstrained array into a reference to the underlying array. */
2053 gnu_rhs
2056 /* If range check is needed, emit code to generate it */
2060 /* If either side's type has a size that overflows, convert this
2061 into raise of Storage_Error: execution shouldn't have gotten
2062 here anyway. */
2068 else
2069 gnu_result
2076 /* Start an IF statement giving the condition. */
2081 /* Generate code for the statements to be executed if the condition
2082 is true. */
2089 /* Generate each of the "else if" parts. */
2091 {
2095 {
2096 Node_Id gnat_statement;
2100 /* Set up the line numbers for each condition we test. */
2108 }
2109 }
2111 /* Finally, handle any statements in the "else" part. */
2113 {
2120 }
2126 {
2127 Node_Id gnat_when;
2128 Node_Id gnat_choice;
2129 tree gnu_label;
2130 Node_Id gnat_statement;
2135 /* The range of values in a case statement is determined by the
2136 rules in RM 5.4(7-9). In almost all cases, this range is
2137 represented by the Etype of the expression. One exception arises
2138 in the case of a simple name that is parenthesized. This still
2139 has the Etype of the name, but since it is not a name, para 7
2140 does not apply, and we need to go to the base type. This is the
2141 only case where parenthesization affects the dynamic semantics
2142 (i.e. the range of possible values at runtime that is covered by
2143 the others alternative.
2145 Another exception is if the subtype of the expression is
2146 non-static. In that case, we also have to use the base type. */
2158 {
2159 /* First compile all the different case choices for the current
2160 WHEN alternative. */
2164 {
2171 {
2173 /* Abort on all errors except range empty, which
2174 means we ignore this alternative. */
2175 error_code
2185 error_code
2186 = pushcase_range
2199 /* This represents either a subtype range or a static value
2200 of some kind; Ekind says which. If a static value,
2201 fall through to the next case. */
2203 {
2206 error_code
2214 }
2215 /* ... fall through ... */
2230 }
2231 }
2233 /* After compiling the choices attached to the WHEN compile the
2234 body of statements that have to be executed, should the
2235 "WHEN ... =>" be taken. Push a binding level here in case
2236 variables are declared since we want them to be local to this
2237 set of statements instead of the block containing the Case
2238 statement. */
2246 /* Communicate to GCC that we are done with the current WHEN,
2247 i.e. insert a "break" statement. */
2251 }
2254 }
2258 {
2259 /* The loop variable in GCC form, if any. */
2261 /* PREINCREMENT_EXPR or PREDECREMENT_EXPR. */
2263 /* Used if this is a named loop for so EXIT can work. */
2265 /* Condition to continue loop tested at top of loop. */
2267 /* Similar, but tested at bottom of loop. */
2269 Node_Id gnat_statement;
2274 /* Set the condition that under which the loop should continue.
2275 For "LOOP .... END LOOP;" the condition is always true. */
2277 ;
2278 /* The case "WHILE condition LOOP ..... END LOOP;" */
2281 else
2282 {
2283 /* We have an iteration scheme. */
2284 Node_Id gnat_loop_spec
2296 tree gnu_limit
2300 /* We know the loop variable will not overflow if GNU_LAST is
2301 a constant and is not equal to GNU_LIMIT. If it might
2302 overflow, we have to move the limit test to the end of
2303 the loop. In that case, we have to test for an
2304 empty loop outside the loop. */
2308 {
2314 }
2316 /* Open a new nesting level that will surround the loop to declare
2317 the loop index variable. */
2321 /* Declare the loop index and set it to its initial value. */
2325 gnu_loop_var);
2327 /* The loop variable might be a padded type, so use `convert' to
2328 get a reference to the inner variable if so. */
2331 /* Set either the top or bottom exit condition as
2332 appropriate depending on whether we know an overflow
2333 cannot occur or not. */
2335 gnu_bottom_condition
2338 else
2339 gnu_top_condition
2344 }
2349 else
2352 /* If the loop was named, have the name point to this loop. In this
2353 case, the association is not a ..._DECL node; in fact, it isn't
2354 a GCC tree node at all. Since this name is referenced inside
2355 the loop, do it before we process the statements of the loop. */
2357 {
2362 }
2366 /* We must evaluate the condition after we've entered the
2367 loop so that any expression actions get done in the right
2368 place. */
2374 /* Make the loop body into its own block, so any allocated
2375 storage will be released every iteration. This is needed
2376 for stack allocation. */
2379 gnu_block_stack
2396 {
2399 gnu_loop_var,
2401 integer_one_node));
2404 }
2410 {
2411 /* Close the nesting level that sourround the loop that was used to
2412 declare the loop index variable. */
2416 }
2419 {
2422 }
2423 }
2440 {
2441 /* Which loop to exit, NULL if the current loop. */
2443 /* The GCC version of the optional GNAT condition node attached to the
2444 exit statement. Exit the loop if this is false. */
2448 loop_id
2457 }
2464 {
2465 /* The gnu function type of the subprogram currently processed. */
2467 /* The return value from the subprogram. */
2470 /* If we are dealing with a "return;" from an Ada procedure with
2471 parameters passed by copy in copy out, we need to return a record
2472 containing the final values of these parameters. If the list
2473 contains only one entry, return just that entry.
2475 For a full description of the copy in copy out parameter mechanism,
2476 see the part of the gnat_to_gnu_entity routine dealing with the
2477 translation of subprograms.
2479 But if we have a return label defined, convert this into
2480 a branch to that label. */
2486 {
2489 else
2490 gnu_ret_val
2493 }
2495 /* If the Ada subprogram is a function, we just need to return the
2496 expression. If the subprogram returns an unconstrained
2497 array, we have to allocate a new version of the result and
2498 return it. If we return by reference, return a pointer. */
2501 {
2504 /* Do not remove the padding from GNU_RET_VAL if the inner
2505 type is self-referential since we want to allocate the fixed
2506 size in that case. */
2510 && (TYPE_IS_PADDING_P
2512 && (CONTAINS_PLACEHOLDER_P
2521 {
2524 /* We have two cases: either the function returns with
2525 depressed stack or not. If not, we allocate on the
2526 secondary stack. If so, we allocate in the stack frame.
2527 if no copy is needed, the front end will set By_Ref,
2528 which we handle in the case above. */
2530 gnu_ret_val
2533 gnat_node);
2534 else
2535 gnu_ret_val
2540 }
2541 }
2547 gnu_ret_val));
2548 else
2551 }
2564 /****************************/
2565 /* Chapter 6: Subprograms: */
2566 /****************************/
2569 /* Unless there is a freeze node, declare the subprogram. We consider
2570 this a "definition" even though we're not generating code for
2571 the subprogram because we will be making the corresponding GCC
2572 node here. */
2581 /* This subprogram doesn't exist for code generation purposes, but we
2582 have to elaborate the types of any parameters, unless they are
2583 imported types (nothing to generate in this case). */
2595 /* For a child unit identifier go up a level to get the
2596 specificaton. We get this when we try to find the spec of
2597 a child unit package that is the compilation unit being compiled. */
2602 {
2603 /* Save debug output mode in case it is reset. */
2606 /* Definining identifier of a parameter to the subprogram. */
2607 Entity_Id gnat_param;
2608 /* The defining identifier for the subprogram body. Note that if a
2609 specification has appeared before for this body, then the identifier
2610 occurring in that specification will also be a defining identifier
2611 and all the calls to this subprogram will point to that
2612 specification. */
2613 Entity_Id gnat_subprog_id
2617 /* The FUNCTION_DECL node corresponding to the subprogram spec. */
2618 tree gnu_subprog_decl;
2619 /* The FUNCTION_TYPE node corresponding to the subprogram spec. */
2620 tree gnu_subprog_type;
2621 tree gnu_cico_list;
2623 /* If this is a generic object or if it has been eliminated,
2624 ignore it. */
2631 /* If debug information is suppressed for the subprogram,
2632 turn debug mode off for the duration of processing. */
2634 {
2637 }
2639 /* If this subprogram acts as its own spec, define it. Otherwise,
2640 just get the already-elaborated tree node. However, if this
2641 subprogram had its elaboration deferred, we will already have
2642 made a tree node for it. So treat it as not being defined in
2643 that case. Such a subprogram cannot have an address clause or
2644 a freeze node, so this test is safe, though it does disable
2645 some otherwise-useful error checking. */
2646 gnu_subprog_decl
2653 /* Set the line number in the decl to correspond to that of
2654 the body so that the line number notes are written
2655 correctly. */
2661 /* There used to be a second call to set_lineno here, with
2662 write_note_p set, but begin_subprog_body actually already emits the
2663 note we want (via init_function_start).
2665 Emitting a second note here was necessary for -ftest-coverage with
2666 GCC 2.8.1, as the first one was skipped by branch_prob. This is no
2667 longer the case with GCC 3.x, so emitting a second note here would
2668 result in having the first line of the subprogram counted twice by
2669 gcov. */
2677 /* If there are OUT parameters, we need to ensure that the
2678 return statement properly copies them out. We do this by
2679 making a new block and converting any inner return into a goto
2680 to a label at the end of the block. */
2683 {
2684 gnu_return_label_stack
2687 gnu_return_label_stack);
2690 }
2691 else
2692 gnu_return_label_stack
2695 /* See if there are any parameters for which we don't yet have
2696 GCC entities. These must be for OUT parameters for which we
2697 will be making VAR_DECL nodes here. Fill them in to
2698 TYPE_CI_CO_LIST, which must contain the empty entry as well.
2699 We can match up the entries because TYPE_CI_CO_LIST is in the
2700 order of the parameters. */
2707 else
2708 {
2709 /* Skip any entries that have been already filled in; they
2710 must correspond to IN OUT parameters. */
2713 ;
2715 /* Do any needed references for padded types. */
2719 }
2723 /* Generate the code of the subprogram itself. A return statement
2724 will be present and any OUT parameters will be handled there. */
2732 {
2733 tree gnu_retval;
2743 else
2745 gnu_cico_list);
2748 gnu_retval
2751 expand_return
2754 gnu_retval));
2756 }
2760 /* Disconnect the trees for parameters that we made variables for
2761 from the GNAT entities since these will become unusable after
2762 we end the function. */
2773 }
2782 {
2783 /* The GCC node corresponding to the GNAT subprogram name. This can
2784 either be a FUNCTION_DECL node if we are dealing with a standard
2785 subprogram call, or an indirect reference expression (an
2786 INDIRECT_REF node) pointing to a subprogram. */
2788 /* The FUNCTION_TYPE node giving the GCC type of the subprogram. */
2790 tree gnu_subprog_addr
2792 Entity_Id gnat_formal;
2793 Node_Id gnat_actual;
2797 tree gnu_subprog_call;
2800 {
2807 }
2812 /* If we are calling a stubbed function, make this into a
2813 raise of Program_Error. Elaborate all our args first. */
2817 {
2824 {
2826 gnu_result
2829 }
2830 else
2831 expand_expr_stmt
2834 }
2836 /* The only way we can be making a call via an access type is
2837 if Name is an explicit dereference. In that case, get the
2838 list of formal args from the type the access type is pointing
2839 to. Otherwise, get the formals from entity being called. */
2843 /* Assume here that this must be 'Elab_Body or 'Elab_Spec. */
2845 else
2848 /* Create the list of the actual parameters as GCC expects it, namely
2849 a chain of TREE_LIST nodes in which the TREE_VALUE field of each
2850 node is a parameter-expression and the TREE_PURPOSE field is
2851 null. Skip OUT parameters that are not passed by reference and
2852 don't need to be copied in. */
2858 {
2860 /* We treat a conversion between aggregate types as if it
2861 is an unchecked conversion. */
2862 int unchecked_convert_p
2867 Node_Id gnat_name
2871 tree gnu_actual;
2873 /* If it's possible we may need to use this expression twice,
2874 make sure than any side-effects are handled via SAVE_EXPRs.
2875 Likewise if we need to force side-effects before the call.
2876 ??? This is more conservative than we need since we don't
2877 need to do this for pass-by-ref with no conversion.
2878 If we are passing a non-addressable Out or In Out parameter by
2879 reference, pass the address of a copy and set up to copy back
2880 out after the call. */
2883 {
2889 && (DECL_BY_COMPONENT_PTR_P
2891 || DECL_BY_DESCRIPTOR_P
2893 {
2895 tree gnu_temp;
2897 /* Remove any unpadding on the actual and make a copy.
2898 But if the actual is a left-justified modular type,
2899 first convert to it. */
2903 && (TYPE_IS_PADDING_P
2907 && (TYPE_LEFT_JUSTIFIED_MODULAR_P
2913 /* Since we're going to take the address of the SAVE_EXPR,
2914 we don't want it to be marked as unchanging.
2915 So set TREE_ADDRESSABLE. */
2918 {
2921 }
2923 /* Set up to move the copy back to the original. */
2925 gnu_after_list);
2928 }
2929 }
2931 /* If this was a procedure call, we may not have removed any
2932 padding. So do it here for the part we will use as an
2933 input, if any. */
2939 gnu_actual);
2942 && ! unchecked_convert_p
2946 /* Do any needed conversions. We need only check for
2947 unchecked conversion since normal conversions will be handled
2948 by just converting to the formal type. */
2950 {
2951 gnu_actual
2953 gnu_actual,
2958 /* One we've done the unchecked conversion, we still
2959 must ensure that the object is in range of the formal's
2960 type. */
2965 }
2967 /* We may have suppressed a conversion to the Etype of the
2968 actual since the parent is a procedure call. So add the
2969 conversion here. */
2971 gnu_actual);
2976 /* If we have not saved a GCC object for the formal, it means it
2977 is an OUT parameter not passed by reference and that does not
2978 need to be copied in. Otherwise, look at the PARM_DECL to see
2979 if it is passed by reference. */
2983 {
2985 {
2988 /* If we have a padded type, be sure we've removed the
2989 padding. */
2993 gnu_actual
2995 gnu_actual);
2996 }
2998 /* Otherwise, if we have a non-addressable COMPONENT_REF of a
2999 variable-size type see if it's doing a unpadding operation.
3000 If so, remove that operation since we have no way of
3001 allocating the required temporary. */
3011 /* The symmetry of the paths to the type of an entity is
3012 broken here since arguments don't know that they will
3013 be passed by ref. */
3016 gnu_actual);
3017 }
3021 {
3028 {
3029 gnu_formal_type
3032 }
3034 /* Take the address of the object and convert to the
3035 proper pointer type. We'd like to actually compute
3036 the address of the beginning of the array using
3037 an ADDR_EXPR of an ARRAY_REF, but there's a possibility
3038 that the ARRAY_REF might return a constant and we'd
3039 be getting the wrong address. Neither approach is
3040 exactly correct, but this is the most likely to work
3041 in all cases. */
3044 gnu_actual));
3045 }
3049 {
3050 /* If arg is 'Null_Parameter, pass zero descriptor. */
3054 gnu_actual
3056 integer_zero_node);
3057 else
3058 gnu_actual
3061 gnat_formal));
3062 }
3063 else
3064 {
3068 gnu_name_list
3076 /* If this is 'Null_Parameter, pass a zero even though we are
3077 dereferencing it. */
3082 BITS_PER_WORD))
3083 gnu_actual
3084 = unchecked_convert
3089 else
3090 gnu_actual
3093 gnu_actual);
3094 }
3096 gnu_actual_list
3099 }
3103 NULL_TREE);
3106 /* If it is a function call, the result is the call expression. */
3108 {
3111 /* If the function returns an unconstrained array or by reference,
3112 we have to de-dereference the pointer. */
3116 gnu_result);
3119 }
3121 /* If this is the case where the GNAT tree contains a procedure call
3122 but the Ada procedure has copy in copy out parameters, the special
3123 parameter passing mechanism must be used. */
3125 {
3126 /* List of FIELD_DECLs associated with the PARM_DECLs of the copy
3127 in copy out parameters. */
3132 {
3133 tree gnu_name;
3137 /* If any of the names had side-effects, ensure they are
3138 all evaluated before the call. */
3142 gnu_subprog_call
3145 }
3149 else
3156 /* If we are dealing with a copy in copy out parameter, we must
3157 retrieve its value from the record returned in the function
3158 call. */
3164 && ((DECL_BY_COMPONENT_PTR_P
3166 || (DECL_BY_DESCRIPTOR_P
3169 {
3170 /* Get the value to assign to this OUT or IN OUT
3171 parameter. It is either the result of the function if
3172 there is only a single such parameter or the appropriate
3173 field from the record returned. */
3174 tree gnu_result
3176 : build_component_ref
3179 int unchecked_conversion
3181 /* If the actual is a conversion, get the inner expression,
3182 which will be the real destination, and convert the
3183 result to the type of the actual parameter. */
3184 tree gnu_actual
3187 /* If the result is a padded type, remove the padding. */
3190 gnu_result
3193 gnu_result);
3195 /* If the result is a type conversion, do it. */
3197 gnu_result
3198 = convert_with_check
3205 gnu_result
3208 else
3209 {
3219 gnu_result);
3220 }
3227 }
3228 }
3229 else
3230 {
3233 }
3235 /* Handle anything we need to assign back. */
3237 gnu_expr;
3242 }
3245 /*************************/
3246 /* Chapter 7: Packages: */
3247 /*************************/
3261 /* If this is the body of a generic package - do nothing */
3268 {
3272 }
3275 /*********************************/
3276 /* Chapter 8: Visibility Rules: */
3277 /*********************************/
3281 /* Nothing to do here - but these may appear in list of declarations */
3284 /***********************/
3285 /* Chapter 9: Tasks: */
3286 /***********************/
3295 /***********************************************************/
3296 /* Chapter 10: Program Structure and Compilation Issues: */
3297 /***********************************************************/
3301 /* For a body, first process the spec if there is one. */
3310 {
3317 };
3324 /* Process any pragmas following the unit. */
3330 /* Put all the Actions into the elaboration routine if we already had
3331 elaborations. This will happen anyway if they are statements, but we
3332 want to force declarations there too due to order-of-elaboration
3333 issues. Most should have Is_Statically_Allocated set. If we
3334 have had no elaborations, we have no order-of-elaboration issue and
3335 don't want to create elaborations here. */
3339 {
3343 else
3345 }
3347 /* Generate elaboration code for this unit, if necessary, and
3348 say whether we did or not. */
3349 Set_Has_No_Elaboration_Code
3351 build_unit_elab
3363 /* Simply process whatever unit is being inserted. */
3371 /***************************/
3372 /* Chapter 11: Exceptions: */
3373 /***************************/
3377 /* The GCC exception handling mechanism can handle both ZCX and SJLJ
3378 schemes and we have our own SJLJ mechanism. To call the GCC
3379 mechanism, we first call expand_eh_region_start if there is at least
3380 one handler associated with the region. We then generate code for
3381 the region and call expand_start_all_catch to announce that the
3382 associated handlers are going to be generated.
3384 For each handler we call expand_start_catch, generate code for the
3385 handler, and then call expand_end_catch.
3387 After all the handlers, we call expand_end_all_catch.
3389 Here we deal with the region level calls and the
3390 N_Exception_Handler branch deals with the handler level calls
3391 (start_catch/end_catch).
3393 ??? The region level calls down there have been specifically put in
3394 place for a ZCX context and currently the order in which things are
3395 emitted (region/handlers) is different from the SJLJ case. Instead of
3396 putting other calls with different conditions at other places for the
3397 SJLJ case, it seems cleaner to reorder things for the SJLJ case and
3398 generalize the condition to make it not ZCX specific. */
3400 /* If there is an At_End procedure attached to this node, and the eh
3401 mechanism is GNAT oriented (SJLJ or ZCX with front end tables), we
3402 must have at least a corresponding At_End handler, unless the
3403 No_Exception_Handlers restriction is set. */
3411 {
3412 /* Need a binding level that we can exit for this sequence if there is
3413 at least one exception handler for this block (since each handler
3414 needs an identified exit point) or there is an At_End procedure
3415 attached to this node (in order to have an attachment point for a
3416 GCC cleanup). */
3417 bool exitable_binding_for_block
3418 = (! type_annotate_only
3422 /* Make a binding level that we can exit if we need one. */
3424 {
3427 }
3429 /* If we are to call a function when exiting this block, expand a GCC
3430 cleanup to take care. We have made a binding level for this cleanup
3431 above. */
3433 {
3434 tree gnu_cleanup_call
3437 tree gnu_cleanup_decl
3443 }
3445 /* Now we generate the code for this block, with a different layout
3446 for GNAT SJLJ and for GCC or front end ZCX. The handlers come first
3447 in the GNAT SJLJ case, while they come after the handled sequence
3448 in the other cases. */
3450 /* First deal with possible handlers for the GNAT SJLJ scheme. */
3454 {
3455 /* We already have a fresh binding level at hand. Declare a
3456 variable to save the old __gnat_jmpbuf value and a variable for
3457 our jmpbuf. Call setjmp and handle each of the possible
3458 exceptions if it returns one. */
3460 tree gnu_jmpsave_decl
3462 jmpbuf_ptr_type,
3466 tree gnu_jmpbuf_decl
3474 /* When we exit this block, restore the saved value. */
3477 gnu_jmpsave_decl));
3479 /* Call setjmp and handle exceptions if it returns one. */
3481 expand_start_cond
3484 gnu_jmpbuf_decl)),
3487 /* Restore our incoming longjmp value before we do anything. */
3488 expand_expr_stmt
3491 /* Make a binding level for the exception handling declarations
3492 and code. Don't assign it an exit label, since this is the
3493 outer block we want to exit at the end of each handler. */
3497 gnu_except_ptr_stack
3499 create_var_decl
3504 gnu_except_ptr_stack);
3506 /* Generate code for each handler. The N_Exception_Handler case
3507 below does the real work. We ignore the dummy exception handler
3508 for the identifier case, as this is used only by the front
3509 end. */
3515 /* If none of the exception handlers did anything, re-raise
3516 but do not defer abortion. */
3518 expand_expr_stmt
3524 /* End the binding level dedicated to the exception handlers. */
3528 /* End the "if" on setjmp. Note that we have arranged things so
3529 control never returns here. */
3532 /* This is now immediately before the body proper. Set our jmp_buf
3533 as the current buffer. */
3534 expand_expr_stmt
3537 gnu_jmpbuf_decl)));
3538 }
3540 /* Now comes the processing for the sequence body. */
3542 /* If we use the back-end eh support, tell the back-end we are
3543 starting a new exception region. */
3549 /* Generate code and declarations for the prefix of this block,
3550 if any. */
3555 /* Generate code for each statement in the block. */
3563 /* Exit the binding level we made, if any. */
3567 /* Compile the handlers for front end ZCX or back-end supported
3568 exceptions. */
3572 {
3583 }
3585 /* Close the binding level we made, if any. */
3587 {
3590 }
3591 }
3597 {
3598 /* Unless this is "Others" or the special "Non-Ada" exception
3599 for Ada, make an "if" statement to select the proper
3600 exceptions. For "Others", exclude exceptions where
3601 Handled_By_Others is nonzero unless the All_Others flag is set.
3602 For "Non-ada", accept an exception if "Lang" is 'V'. */
3607 {
3608 tree this_choice;
3611 {
3614 else
3615 this_choice
3616 = build_binary_op
3618 convert
3620 build_component_ref
3621 (build_unary_op
3626 integer_zero_node);
3627 }
3631 {
3634 /* Exception may be a renaming. Recover original exception
3635 which is the one elaborated and registered. */
3639 /* ??? Note that we have to use gnat_to_gnu_entity here
3640 since the type of the exception will be wrong in the
3641 VMS case and that's exactly what this test is for. */
3644 /* If this was a VMS exception, check import_code
3645 against the value of the exception. */
3647 this_choice
3648 = build_binary_op
3650 build_component_ref
3651 (build_unary_op
3655 gnu_expr);
3656 else
3657 this_choice
3658 = build_binary_op
3661 convert
3665 /* If this is the distinguished exception "Non_Ada_Error"
3666 (and we are in VMS mode), also allow a non-Ada
3667 exception (a VMS condition) to match. */
3669 {
3670 tree gnu_comp
3671 = build_component_ref
3672 (build_unary_op
3677 this_choice
3678 = build_binary_op
3680 build_binary_op
3684 this_choice);
3685 }
3686 }
3687 else
3692 }
3697 }
3699 /* Tell the back end that we start an exception handler if necessary. */
3701 {
3702 /* We build a TREE_LIST of nodes representing what exception
3703 types this handler is able to catch, with special cases
3704 for others and all others cases.
3706 Each exception type is actually identified by a pointer to the
3707 exception id, with special value zero for "others" and one for
3708 "all others". Beware that these special values are known and used
3709 by the personality routine to identify the corresponding specific
3710 kinds of handlers.
3712 ??? For initial time frame reasons, the others and all_others
3713 cases have been handled using specific type trees, but this
3714 somehow hides information to the back-end, which expects NULL to
3715 be passed for catch all and end_cleanup to be used for cleanups.
3717 Care should be taken to ensure that the control flow impact of
3718 such clauses is rendered in some way. lang_eh_type_covers is
3719 doing the trick currently. */
3726 {
3728 gnu_etype
3733 {
3736 /* Exception may be a renaming. Recover original exception
3737 which is the one elaborated and registered. */
3743 gnu_etype
3745 }
3746 else
3749 /* The GCC interface expects NULL to be passed for catch all
3750 handlers, so it would be quite tempting to set gnu_etypes_list
3751 to NULL if gnu_etype is integer_zero_node. It would not work,
3752 however, because GCC's notion of "catch all" is stronger than
3753 our notion of "others". Until we correctly use the cleanup
3754 interface as well, the doing tht would prevent the "all
3755 others" handlers from beeing seen, because nothing can be
3756 caught beyond a catch all from GCC's point of view. */
3757 gnu_etypes_list
3760 }
3767 {
3768 /* Expand a call to the begin_handler hook at the beginning of the
3769 handler, and arrange for a call to the end_handler hook to
3770 occur on every possible exit path.
3772 The hooks expect a pointer to the low level occurrence. This
3773 is required for our stack management scheme because a raise
3774 inside the handler pushes a new occurrence on top of the
3775 stack, which means that this top does not necessarily match
3776 the occurrence this handler was dealing with.
3778 The EXC_PTR_EXPR object references the exception occurrence
3779 beeing propagated. Upon handler entry, this is the exception
3780 for which the handler is triggered. This might not be the case
3781 upon handler exit, however, as we might have a new occurrence
3782 propagated by the handler's body, and the end_handler hook
3783 called as a cleanup in this context.
3785 We use a local variable to retrieve the incoming value at
3786 handler entry time, and reuse it to feed the end_handler
3787 hook's argument at exit time. */
3788 tree gnu_current_exc_ptr
3790 tree gnu_incoming_exc_ptr
3795 expand_expr_stmt
3797 expand_decl_cleanup
3799 }
3800 }
3807 {
3808 /* Tell the back end that we're done with the current handler. */
3813 }
3814 else
3815 /* At the end of the handler, exit the block. We made this block in
3816 N_Handled_Sequence_Of_Statements. */
3824 /*******************************/
3825 /* Chapter 12: Generic Units: */
3826 /*******************************/
3836 /* These nodes can appear on a declaration list but there is nothing to
3837 to be done with them. */
3840 /***************************************************/
3841 /* Chapter 13: Representation Clauses and */
3842 /* Implementation-Dependent Features: */
3843 /***************************************************/
3847 /* The only one we need deal with is for 'Address. For the others, SEM
3848 puts the information elsewhere. We need only deal with 'Address
3849 if the object has a Freeze_Node (which it never will currently). */
3854 /* Get the value to use as the address and save it as the
3855 equivalent for GNAT_TEMP. When the object is frozen,
3856 gnat_to_gnu_entity will do the right thing. */
3864 /* We do nothing with these. SEM puts the information elsewhere. */
3869 {
3875 /* First process inputs, then outputs, then clobbers. */
3878 {
3883 gnu_input_list
3886 }
3890 {
3895 gnu_orig_out_list
3897 gnu_output_list
3900 }
3904 gnu_clobber_list
3907 gnu_clobber_list);
3914 input_location);
3916 /* Copy all the intermediate outputs into the specified outputs. */
3921 {
3922 expand_expr_stmt
3927 }
3928 }
3931 /***************************************************/
3932 /* Added Nodes */
3933 /***************************************************/
3947 {
3949 tree gnu_obj_type;
3950 tree gnu_obj_size;
3953 /* If this is a thin pointer, we must dereference it to create
3954 a fat pointer, then go back below to a thin pointer. The
3955 reason for this is that we need a fat pointer someplace in
3956 order to properly compute the size. */
3960 gnu_ptr));
3962 /* If this is an unconstrained array, we know the object must
3963 have been allocated with the template in front of the object.
3964 So pass the template address, but get the total size. Do this
3965 by converting to a thin pointer. */
3967 gnu_ptr
3969 (TYPE_OBJECT_RECORD_TYPE
3971 gnu_ptr);
3979 {
3982 tree gnu_byte_offset
3989 }
3992 expand_expr_stmt
3996 }
4009 /* If the type is VOID, this is a statement, so we need to
4010 generate the code for the call. Handle a Condition, if there
4011 is one. */
4013 {
4023 }
4024 else
4029 /* If the result is a pointer type, see if we are either converting
4030 from a non-pointer or from a pointer to a type with a different
4031 alias set and warn if so. If the result defined in the same unit as
4032 this unchecked convertion, we can allow this because we can know to
4033 make that type have alias set 0. */
4034 {
4045 {
4046 post_error_ne
4049 post_error
4051 gnat_node);
4052 post_error_ne
4055 }
4056 }
4068 }
4070 /* If the result is a statement, set needed flags and return it. */
4072 {
4077 }
4079 /* If the result is a constant that overflows, raise constraint error. */
4082 {
4085 gnu_result
4088 }
4090 /* If our result has side-effects and is of an unconstrained type,
4091 make a SAVE_EXPR so that we can be sure it will only be referenced
4092 once. Note we must do this before any conversions. */
4098 /* Now convert the result to the proper type. If the type is void or if
4099 we have no result, return error_mark_node to show we have no result.
4100 If the type of the result is correct or if we have a label (which doesn't
4101 have any well-defined type), return our result. Also don't do the
4102 conversion if the "desired" type involves a PLACEHOLDER_EXPR in its size
4103 since those are the cases where the front end may have the type wrong due
4104 to "instantiating" the unconstrained record with discriminant values
4105 or if this is a FIELD_DECL. If this is the Name of an assignment
4106 statement or a parameter of a procedure call, return what we have since
4107 the RHS has to be converted to our type there in that case, unless
4108 GNU_RESULT_TYPE has a simpler size. Similarly, if the two types are
4109 record types with the same name, the expression type has integral mode,
4110 and GNU_RESULT_TYPE BLKmode, don't convert. This will be the case when
4111 we are converting from a packable type to its actual type and we need
4112 those conversions to be NOPs in order for assignments into these types to
4113 work properly if the inner object is a bitfield and hence can't have
4114 its address taken. Finally, don't convert integral types that are the
4115 operand of an unchecked conversion since we need to ignore those
4116 conversions (for 'Valid). Otherwise, convert the result to the proper
4117 type. */
4137 && (CONTAINS_PLACEHOLDER_P
4141 {
4142 /* In this case remove padding only if the inner object is of
4143 self-referential size: in that case it must be an object of
4144 unconstrained type with a default discriminant. In other cases,
4145 we want to avoid copying too much data. */
4152 gnu_result);
4153 }
4169 {
4170 /* Remove any padding record, but do nothing more in this case. */
4174 gnu_result);
4175 }
4183 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RESULT. */
4190 }
4191 \f
4192 /* GNU_STMT is a statement. We generate code for that statement. */
4194 void
4196 {
4200 {
4207 }
4208 }
4209 \f
4210 /* Force references to each of the entities in packages GNAT_NODE with's
4211 so that the debugging information for all of them are identical
4212 in all clients. Operate recursively on anything it with's, but check
4213 that we aren't elaborating something more than once. */
4215 /* The reason for this routine's existence is two-fold.
4216 First, with some debugging formats, notably MDEBUG on SGI
4217 IRIX, the linker will remove duplicate debugging information if two
4218 clients have identical debugguing information. With the normal scheme
4219 of elaboration, this does not usually occur, since entities in with'ed
4220 packages are elaborated on demand, and if clients have different usage
4221 patterns, the normal case, then the order and selection of entities
4222 will differ. In most cases however, it seems that linkers do not know
4223 how to eliminate duplicate debugging information, even if it is
4224 identical, so the use of this routine would increase the total amount
4225 of debugging information in the final executable.
4227 Second, this routine is called in type_annotate mode, to compute DDA
4228 information for types in withed units, for ASIS use */
4230 static void
4232 {
4235 /* Process each unit only once. As we trace the context of all relevant
4236 units transitively, including generic bodies, we may encounter the
4237 same generic unit repeatedly */
4242 /* Save entities in all context units. A body may have an implicit_with
4243 on its own spec, if the context includes a child unit, so don't save
4244 the spec twice. */
4252 {
4256 {
4273 }
4275 {
4276 Node_Id gnat_body
4279 /* Retrieve compilation unit node of generic body. */
4284 /* If body is available, elaborate its context. */
4287 }
4288 }
4292 }
4293 \f
4294 /* Do the processing of N_Freeze_Entity, GNAT_NODE. */
4296 static void
4298 {
4300 tree gnu_old;
4301 tree gnu_new;
4302 tree gnu_init
4307 /* If this is a package, need to generate code for the package. */
4309 {
4310 insert_code_for
4314 }
4316 /* Check for old definition after the above call. This Freeze_Node
4317 might be for one its Itypes. */
4318 gnu_old
4321 /* If this entity has an Address representation clause, GNU_OLD is the
4322 address, so discard it here. */
4326 /* Don't do anything for class-wide types they are always
4327 transformed into their root type. */
4333 /* Don't do anything for subprograms that may have been elaborated before
4334 their freeze nodes. This can happen, for example because of an inner call
4335 in an instance body. */
4342 /* If we have a non-dummy type old tree, we have nothing to do. Unless
4343 this is the public view of a private type whose full view was not
4344 delayed, this node was never delayed as it should have been.
4345 Also allow this to happen for concurrent types since we may have
4346 frozen both the Corresponding_Record_Type and this type. */
4350 {
4357 else
4359 }
4361 /* Reset the saved tree, if any, and elaborate the object or type for real.
4362 If there is a full declaration, elaborate it and copy the type to
4363 GNAT_ENTITY. Likewise if this is the record subtype corresponding to
4364 a class wide type or subtype. */
4366 {
4375 }
4379 {
4382 /* The above call may have defined this entity (the simplest example
4383 of this is when we have a private enumeral type since the bounds
4384 will have the public view. */
4390 }
4391 else
4394 /* If we've made any pointers to the old version of this type, we
4395 have to update them. */
4399 }
4400 \f
4401 /* Process the list of inlined subprograms of GNAT_NODE, which is an
4402 N_Compilation_Unit. */
4404 static void
4406 {
4407 Entity_Id gnat_entity;
4408 Node_Id gnat_body;
4410 /* If we can inline, generate RTL for all the inlined subprograms.
4411 Define the entity first so we set DECL_EXTERNAL. */
4416 {
4420 {
4421 /* ??? This really should always be Present. */
4425 gnat_body
4427 }
4430 {
4433 }
4434 }
4435 }
4436 \f
4437 /* Elaborate decls in the lists GNAT_DECLS and GNAT_DECLS2, if present.
4438 We make two passes, one to elaborate anything other than bodies (but
4439 we declare a function if there was no spec). The second pass
4440 elaborates the bodies.
4442 GNAT_END_LIST gives the element in the list past the end. Normally,
4443 this is Empty, but can be First_Real_Statement for a
4444 Handled_Sequence_Of_Statements.
4446 We make a complete pass through both lists if PASS1P is true, then make
4447 the second pass over both lists if PASS2P is true. The lists usually
4448 correspond to the public and private parts of a package. */
4450 static void
4452 List_Id gnat_decls2,
4453 Node_Id gnat_end_list,
4456 {
4458 Node_Id gnat_decl;
4468 {
4471 /* For package specs, we recurse inside the declarations,
4472 thus taking the two pass approach inside the boundary. */
4480 /* Similarly for any declarations in the actions of a
4481 freeze node. */
4483 {
4486 }
4488 /* Package bodies with freeze nodes get their elaboration deferred
4489 until the freeze node, but the code must be placed in the right
4490 place, so record the code position now. */
4498 (Corresponding_Spec
4501 record_code_position
4504 /* We defer most subprogram bodies to the second pass. */
4506 {
4508 {
4514 }
4515 }
4516 /* For bodies and stubs that act as their own specs, the entity
4517 itself must be elaborated in the first pass, because it may
4518 be used in other declarations. */
4520 {
4521 Node_Id gnat_subprog_id =
4528 }
4530 /* Concurrent stubs stand for the corresponding subprogram bodies,
4531 which are deferred like other bodies. */
4534 ;
4536 else
4538 }
4540 /* Here we elaborate everything we deferred above except for package bodies,
4541 which are elaborated at their freeze nodes. Note that we must also
4542 go inside things (package specs and freeze nodes) the first pass did. */
4548 {
4564 }
4565 }
4566 \f
4567 /* Emit code for a range check. GNU_EXPR is the expression to be checked,
4568 GNAT_RANGE_TYPE the gnat type or subtype containing the bounds against
4569 which we have to check. */
4571 static tree
4573 {
4579 /* If GNU_EXPR has an integral type that is narrower than GNU_RANGE_TYPE,
4580 we can't do anything since we might be truncating the bounds. No
4581 check is needed in this case. */
4587 /* Checked expressions must be evaluated only once. */
4590 /* There's no good type to use here, so we might as well use
4591 integer_type_node. Note that the form of the check is
4592 (not (expr >= lo)) or (not (expr >= hi))
4593 the reason for this slightly convoluted form is that NaN's
4594 are not considered to be in range in the float case. */
4595 return emit_check
4597 invert_truthvalue
4601 invert_truthvalue
4605 gnu_high)))),
4607 }
4608 \f
4609 /* Emit code for an index check. GNU_ARRAY_OBJECT is the array object
4610 which we are about to index, GNU_EXPR is the index expression to be
4611 checked, GNU_LOW and GNU_HIGH are the lower and upper bounds
4612 against which GNU_EXPR has to be checked. Note that for index
4613 checking we cannot use the emit_range_check function (although very
4614 similar code needs to be generated in both cases) since for index
4615 checking the array type against which we are checking the indeces
4616 may be unconstrained and consequently we need to retrieve the
4617 actual index bounds from the array object itself
4618 (GNU_ARRAY_OBJECT). The place where we need to do that is in
4619 subprograms having unconstrained array formal parameters */
4621 static tree
4623 tree gnu_expr,
4624 tree gnu_low,
4625 tree gnu_high)
4626 {
4627 tree gnu_expr_check;
4629 /* Checked expressions must be evaluated only once. */
4632 /* Must do this computation in the base type in case the expression's
4633 type is an unsigned subtypes. */
4636 /* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
4637 the object we are handling. */
4646 /* There's no good type to use here, so we might as well use
4647 integer_type_node. */
4648 return emit_check
4651 gnu_expr_check,
4653 gnu_low)),
4655 gnu_expr_check,
4657 gnu_high))),
4659 }
4660 \f
4661 /* Given GNU_COND which contains the condition corresponding to an access,
4662 discriminant or range check, of value GNU_EXPR, build a COND_EXPR
4663 that returns GNU_EXPR if GNU_COND is false and raises a
4664 CONSTRAINT_ERROR if GNU_COND is true. REASON is the code that says
4665 why the exception was raised. */
4667 static tree
4669 {
4670 tree gnu_call;
4671 tree gnu_result;
4675 /* Use an outer COMPOUND_EXPR to make sure that GNU_EXPR will get evaluated
4676 in front of the comparison in case it ends up being a SAVE_EXPR. Put the
4677 whole thing inside its own SAVE_EXPR so the inner SAVE_EXPR doesn't leak
4678 out. */
4682 gnu_expr));
4684 /* If GNU_EXPR has side effects, make the outer COMPOUND_EXPR and
4685 protect it. Otherwise, show GNU_RESULT has no side effects: we
4686 don't need to evaluate it just for the check. */
4688 gnu_result
4690 else
4693 /* ??? Unfortunately, if we don't put a SAVE_EXPR around this whole thing,
4694 we will repeatedly do the test. It would be nice if GCC was able
4695 to optimize this and only do it once. */
4697 }
4698 \f
4699 /* Return an expression that converts GNU_EXPR to GNAT_TYPE, doing
4700 overflow checks if OVERFLOW_P is nonzero and range checks if
4701 RANGE_P is nonzero. GNAT_TYPE is known to be an integral type.
4702 If TRUNCATE_P is nonzero, do a float to integer conversion with
4703 truncation; otherwise round. */
4705 static tree
4707 tree gnu_expr,
4711 {
4719 /* If we are not doing any checks, the output is an integral type, and
4720 the input is not a floating type, just do the conversion. This
4721 shortcut is required to avoid problems with packed array types
4722 and simplifies code in all cases anyway. */
4727 /* First convert the expression to its base type. This
4728 will never generate code, but makes the tests below much simpler.
4729 But don't do this if converting from an integer type to an unconstrained
4730 array type since then we need to get the bounds from the original
4731 (unpacked) type. */
4735 /* If overflow checks are requested, we need to be sure the result will
4736 fit in the output base type. But don't do this if the input
4737 is integer and the output floating-point. */
4740 {
4741 /* Ensure GNU_EXPR only gets evaluated once. */
4749 /* Convert the lower bounds to signed types, so we're sure we're
4750 comparing them properly. Likewise, convert the upper bounds
4751 to unsigned types. */
4765 /* Check each bound separately and only if the result bound
4766 is tighter than the bound on the input type. Note that all the
4767 types are base types, so the bounds must be constant. Also,
4768 the comparison is done in the base type of the input, which
4769 always has the proper signedness. First check for input
4770 integer (which means output integer), output float (which means
4771 both float), or mixed, in which case we always compare.
4772 Note that we have to do the comparison which would *fail* in the
4773 case of an error since if it's an FP comparison and one of the
4774 values is a NaN or Inf, the comparison will fail. */
4781 gnu_cond
4782 = invert_truthvalue
4785 gnu_out_lb)));
4793 gnu_cond
4795 invert_truthvalue
4797 gnu_input,
4799 gnu_out_ub))));
4803 CE_Overflow_Check_Failed);
4804 }
4806 /* Now convert to the result base type. If this is a non-truncating
4807 float-to-integer conversion, round. */
4810 {
4820 gnu_result
4822 }
4828 else
4831 /* Finally, do the range check if requested. Note that if the
4832 result type is a modular type, the range check is actually
4833 an overflow check. */
4841 }
4842 \f
4843 /* Return 1 if GNU_EXPR can be directly addressed. This is the case unless
4844 it is an expression involving computation or if it involves a bitfield
4845 reference. This returns the same as gnat_mark_addressable in most
4846 cases. */
4848 static int
4850 {
4852 {
4857 /* All DECLs are addressable: if they are in a register, we can force
4858 them to memory. */
4884 {
4885 /* This is addressable if we can avoid a copy. */
4899 }
4903 }
4904 }
4905 \f
4906 /* Do the processing for the declaration of a GNAT_ENTITY, a type. If
4907 a separate Freeze node exists, delay the bulk of the processing. Otherwise
4908 make a GCC type for GNAT_ENTITY and set up the correspondance. */
4910 void
4912 {
4913 tree gnu_old
4915 tree gnu_new;
4917 /* If we are to delay elaboration of this type, just do any
4918 elaborations needed for expressions within the declaration and
4919 make a dummy type entry for this node and its Full_View (if
4920 any) in case something points to it. Don't do this if it
4921 has already been done (the only way that can happen is if
4922 the private completion is also delayed). */
4928 {
4932 {
4941 }
4944 }
4946 /* If we saved away a dummy type for this node it means that this
4947 made the type that corresponds to the full type of an incomplete
4948 type. Clear that type for now and then update the type in the
4949 pointers. */
4951 {
4954 {
4955 /* If this was a withed access type, this is not an error
4956 and merely indicates we've already elaborated the type
4957 already. */
4962 }
4965 }
4967 /* Now fully elaborate the type. */
4972 /* If we have an old type and we've made pointers to this type,
4973 update those pointers. */
4978 /* If this is a record type corresponding to a task or protected type
4979 that is a completion of an incomplete type, perform a similar update
4980 on the type. */
4981 /* ??? Including protected types here is a guess. */
4986 {
4987 tree gnu_task_old
4997 }
4998 }
4999 \f
5000 /* GNAT_ASSOC is the front of the Component_Associations of an N_Aggregate.
5001 GNU_TYPE is the GCC type of the corresponding record.
5003 Return a CONSTRUCTOR to build the record. */
5005 static tree
5007 {
5010 /* We test for GNU_FIELD being empty in the case where a variant
5011 was the last thing since we don't take things off GNAT_ASSOC in
5012 that case. We check GNAT_ASSOC in case we have a variant, but it
5013 has no fields. */
5017 {
5022 /* The expander is supposed to put a single component selector name
5023 in every record component association */
5027 /* Before assigning a value in an aggregate make sure range checks
5028 are done if required. Then convert to the type of the field. */
5034 /* Add the field and expression to the list. */
5036 }
5040 /* Verify every enty in GNU_LIST was used. */
5046 }
5048 /* Builds a possibly nested constructor for array aggregates. GNAT_EXPR
5049 is the first element of an array aggregate. It may itself be an
5050 aggregate (an array or record aggregate). GNU_ARRAY_TYPE is the gnu type
5051 corresponding to the array aggregate. GNAT_COMPONENT_TYPE is the type
5052 of the array component. It is needed for range checking. */
5054 static tree
5056 tree gnu_array_type,
5057 Entity_Id gnat_component_type)
5058 {
5059 tree gnu_expr;
5063 {
5064 /* If the expression is itself an array aggregate then first build the
5065 innermost constructor if it is part of our array (multi-dimensional
5066 case). */
5073 gnat_component_type);
5074 else
5075 {
5078 /* before assigning the element to the array make sure it is
5079 in range */
5082 }
5084 gnu_expr_list
5086 gnu_expr_list);
5087 }
5090 }
5091 \f
5092 /* Subroutine of assoc_to_constructor: VALUES is a list of field associations,
5093 some of which are from RECORD_TYPE. Return a CONSTRUCTOR consisting
5094 of the associations that are from RECORD_TYPE. If we see an internal
5095 record, make a recursive call to fill it in as well. */
5097 static tree
5099 {
5104 {
5107 /* _Parent is an internal field, but may have values in the aggregate,
5108 so check for values first. */
5110 {
5113 }
5116 {
5121 }
5122 else
5123 /* If we have a record subtype, the names will match, but not the
5124 actual FIELD_DECLs. */
5127 {
5130 }
5136 }
5139 }
5140 \f
5141 /* EXP is to be treated as an array or record. Handle the cases when it is
5142 an access object and perform the required dereferences. */
5144 static tree
5146 {
5147 /* If the type is a pointer, dereference it. */
5152 /* If we got a padded type, remove it too. */
5158 }
5159 \f
5160 /* Protect EXP from multiple evaluation. This may make a SAVE_EXPR. */
5162 tree
5164 {
5167 /* If this has no side effects, we don't need to do anything. */
5171 /* If it is a conversion, protect what's inside the conversion.
5172 Similarly, if we're indirectly referencing something, we only
5173 actually need to protect the address since the data itself can't
5174 change in these situations. */
5183 /* If EXP is a fat pointer or something that can be placed into a register,
5184 just make a SAVE_EXPR. */
5188 /* Otherwise, dereference, protect the address, and re-reference. */
5189 else
5190 return
5194 exp)));
5195 }
5196 \f
5197 /* This is equivalent to stabilize_reference in GCC's tree.c, but we know
5198 how to handle our new nodes and we take an extra argument that says
5199 whether to force evaluation of everything. */
5201 tree
5203 {
5206 tree result;
5209 {
5213 /* No action is needed in this case. */
5225 result
5234 force));
5240 force),
5248 force),
5250 force));
5257 force));
5264 force));
5270 force),
5272 force));
5281 /* If arg isn't a kind of lvalue we recognize, make no change.
5282 Caller should recognize the error for an invalid lvalue. */
5288 }
5292 }
5294 /* Similar to stabilize_reference_1 in tree.c, but supports an extra
5295 arg to force a SAVE_EXPR for everything. */
5297 static tree
5299 {
5302 tree result;
5304 /* We cannot ignore const expressions because it might be a reference
5305 to a const array but whose index contains side-effects. But we can
5306 ignore things that are actual constant or that already have been
5307 handled by this function. */
5313 {
5327 /* Constants need no processing. In fact, we should never reach
5328 here. */
5332 /* Recursively stabilize each operand. */
5339 /* Recursively stabilize each operand. */
5342 force));
5347 }
5351 }
5352 \f
5353 /* GNAT_UNIT is the Defining_Identifier for some package or subprogram,
5354 either a spec or a body, BODY_P says which. If needed, make a function
5355 to be the elaboration routine for that object and perform the elaborations
5356 in GNU_ELAB_LIST.
5358 Return 1 if we didn't need an elaboration function, zero otherwise. */
5360 static int
5362 {
5363 tree gnu_decl;
5364 rtx insn;
5367 /* If we have nothing to do, return. */
5371 /* Prevent the elaboration list from being reclaimed by the GC. */
5373 gnu_elab_list);
5375 /* Set our file and line number to that of the object and set up the
5376 elaboration routine. */
5378 body_p ?
5390 /* Emit the assignments for the elaborations we have to do. If there
5391 is no destination, this is just a call to execute some statement
5392 that was placed within the declarative region. But first save a
5393 pointer so we can see if any insns were generated. */
5399 {
5402 }
5403 else
5404 {
5409 /* If LHS has a padded type, convert it to the unpadded type
5410 so the assignment is done properly. */
5419 }
5421 /* See if any non-NOTE insns were generated. */
5424 {
5427 }
5434 /* We are finished with the elaboration list it can now be discarded. */
5437 /* If there were no insns, we don't need an elab routine. It would
5438 be nice to not output this one, but there's no good way to do that. */
5440 }
5441 \f
5444 /* Determine the input_filename and the input_line from the source location
5445 (Sloc) of GNAT_NODE node. Set the global variable input_filename and
5446 input_line. If WRITE_NOTE_P is true, emit a line number note. */
5448 void
5450 {
5454 }
5456 /* Likewise, but passed a Sloc. */
5458 void
5460 {
5461 /* If node not from source code, ignore. */
5465 /* Use the identifier table to make a hashed, permanent copy of the filename,
5466 since the name table gets reallocated after Gigi returns but before all
5467 the debugging information is output. The __gnat_to_canonical_file_spec
5468 call translates filenames from pragmas Source_Reference that contain host
5469 style syntax not understood by gdb. */
5470 input_filename
5471 = IDENTIFIER_POINTER
5472 (get_identifier
5473 (__gnat_to_canonical_file_spec
5474 (Get_Name_String
5477 /* ref_filename is the reference file name as given by sinput (i.e no
5478 directory) */
5479 ref_filename
5480 = IDENTIFIER_POINTER
5481 (get_identifier
5482 (Get_Name_String
5488 }
5489 \f
5490 /* Post an error message. MSG is the error message, properly annotated.
5491 NODE is the node at which to post the error and the node to use for the
5492 "&" substitution. */
5494 void
5496 {
5497 String_Template temp;
5498 Fat_Pointer fp;
5504 }
5506 /* Similar, but NODE is the node at which to post the error and ENT
5507 is the node to use for the "&" substitution. */
5509 void
5511 {
5512 String_Template temp;
5513 Fat_Pointer fp;
5519 }
5521 /* Similar, but NODE is the node at which to post the error, ENT is the node
5522 to use for the "&" substitution, and N is the number to use for the ^. */
5524 void
5526 {
5527 String_Template temp;
5528 Fat_Pointer fp;
5536 }
5537 \f
5538 /* Similar to post_error_ne_num, but T is a GCC tree representing the
5539 number to write. If the tree represents a constant that fits within
5540 a host integer, the text inside curly brackets in MSG will be output
5541 (presumably including a '^'). Otherwise that text will not be output
5542 and the text inside square brackets will be output instead. */
5544 void
5546 {
5549 Fat_Pointer fp;
5557 #if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_INT
5558 &&
5559 compare_tree_int
5561 #endif
5562 )
5563 {
5566 }
5567 else
5571 {
5577 ;
5578 else
5580 }
5587 }
5589 /* Similar to post_error_ne_tree, except that NUM is a second
5590 integer to write in the message. */
5592 void
5594 Node_Id node,
5595 Entity_Id ent,
5596 tree t,
5598 {
5601 }
5603 /* Set the node for a second '&' in the error message. */
5605 void
5607 {
5609 }
5610 \f
5611 /* Signal abort, with "Gigi abort" as the error label, and error_gnat_node
5612 as the relevant node that provides the location info for the error */
5614 void
5616 {
5618 Fat_Pointer fp;
5624 }
5625 \f
5626 /* Initialize the table that maps GNAT codes to GCC codes for simple
5627 binary and unary operations. */
5629 void
5631 {
5657 }