| blob | 7f7f6af034ae9cc3886020f518b3b8fa7bf6b5a0 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S 2 *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2013, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
20 * *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
23 * *
24 ****************************************************************************/
51 /* Return the base type of TYPE. */
53 tree
55 {
66 }
67 \f
68 /* EXP is a GCC tree representing an address. See if we can find how
69 strictly the object at that address is aligned. Return that alignment
70 in bits. If we don't know anything about the alignment, return 0. */
72 unsigned int
74 {
79 {
80 CASE_CONVERT:
83 /* Conversions between pointers and integers don't change the alignment
84 of the underlying object. */
89 /* The value of a COMPOUND_EXPR is that of it's second operand. */
95 /* If two address are added, the alignment of the result is the
96 minimum of the two alignments. */
105 /* If we don't know the alignment of the offset, we assume that
106 of the base. */
109 else
114 /* If there is a choice between two values, use the smallest one. */
121 {
123 /* The first part of this represents the lowest bit in the constant,
124 but it is originally in bytes, not bits. */
126 }
130 /* If we know the alignment of just one side, use it. Otherwise,
131 use the product of the alignments. */
139 else
144 /* A bit-and expression is as aligned as the maximum alignment of the
145 operands. We typically get here for a complex lhs and a constant
146 negative power of two on the rhs to force an explicit alignment, so
147 don't bother looking at the lhs. */
156 {
160 }
162 /* Fall through... */
165 /* For other pointer expressions, we assume that the pointed-to object
166 is at least as aligned as the pointed-to type. Beware that we can
167 have a dummy type here (e.g. a Taft Amendment type), for which the
168 alignment is meaningless and should be ignored. */
172 else
175 }
178 }
179 \f
180 /* We have a comparison or assignment operation on two types, T1 and T2, which
181 are either both array types or both record types. T1 is assumed to be for
182 the left hand side operand, and T2 for the right hand side. Return the
183 type that both operands should be converted to for the operation, if any.
184 Otherwise return zero. */
186 static tree
188 {
189 /* ??? As of today, various constructs lead to here with types of different
190 sizes even when both constants (e.g. tagged types, packable vs regular
191 component types, padded vs unpadded types, ...). While some of these
192 would better be handled upstream (types should be made consistent before
193 calling into build_binary_op), some others are really expected and we
194 have to be careful. */
196 /* We must avoid writing more than what the target can hold if this is for
197 an assignment and the case of tagged types is handled in build_binary_op
198 so we use the lhs type if it is known to be smaller or of constant size
199 and the rhs type is not, whatever the modes. We also force t1 in case of
200 constant size equality to minimize occurrences of view conversions on the
201 lhs of an assignment, except for the case of record types with a variant
202 part on the lhs but not on the rhs to make the conversion simpler. */
213 /* Otherwise, if the lhs type is non-BLKmode, use it. Note that we know
214 that we will not have any alignment problems since, if we did, the
215 non-BLKmode type could not have been used. */
219 /* If the rhs type is of constant size, use it whatever the modes. At
220 this point it is known to be smaller, or of constant size and the
221 lhs type is not. */
225 /* Otherwise, if the rhs type is non-BLKmode, use it. */
229 /* In this case, both types have variable size and BLKmode. It's
230 probably best to leave the "type mismatch" because changing it
231 could cause a bad self-referential reference. */
233 }
234 \f
235 /* Return an expression tree representing an equality comparison of A1 and A2,
236 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
238 Two arrays are equal in one of two ways: (1) if both have zero length in
239 some dimension (not necessarily the same dimension) or (2) if the lengths
240 in each dimension are equal and the data is equal. We perform the length
241 tests in as efficient a manner as possible. */
243 static tree
245 {
255 /* If either operand has side-effects, they have to be evaluated only once
256 in spite of the multiple references to the operand in the comparison. */
263 /* Process each dimension separately and compare the lengths. If any
264 dimension has a length known to be zero, set LENGTH_ZERO_P to true
265 in order to suppress the comparison of the data at the end. */
267 {
273 size_one_node);
275 size_one_node);
278 /* If the length of the first array is a constant, swap our operands
279 unless the length of the second array is the constant zero. */
281 {
282 tree tem;
293 }
295 /* If the length of the second array is the constant zero, we can just
296 use the original stored bounds for the first array and see whether
297 last < first holds. */
299 {
312 }
314 /* Otherwise, if the length is some other constant value, we know that
315 this dimension in the second array cannot be superflat, so we can
316 just use its length computed from the actual stored bounds. */
318 {
319 tree bt;
323 /* Note that we know that UB2 and LB2 are constant and hence
324 cannot contain a PLACEHOLDER_EXPR. */
329 comparison
337 this_a1_is_null
341 }
343 /* Otherwise, compare the computed lengths. */
344 else
345 {
349 comparison
352 /* If the length expression is of the form (cond ? val : 0), assume
353 that cond is equivalent to (length != 0). That's guaranteed by
354 construction of the array types in gnat_to_gnu_entity. */
357 this_a1_is_null
359 else
363 /* Likewise for the second array. */
366 this_a2_is_null
368 else
371 }
373 /* Append expressions for this dimension to the final expressions. */
385 }
387 /* Unless the length of some dimension is known to be zero, compare the
388 data in the array. */
390 {
392 tree comparison;
395 {
398 }
402 result
404 }
406 /* The result is also true if both sizes are zero. */
410 result);
412 /* If either operand has side-effects, they have to be evaluated before
413 starting the comparison above since the place they would be otherwise
414 evaluated could be wrong. */
422 }
424 /* Return an expression tree representing an equality comparison of P1 and P2,
425 two objects of fat pointer type. The result should be of type RESULT_TYPE.
427 Two fat pointers are equal in one of two ways: (1) if both have a null
428 pointer to the array or (2) if they contain the same couple of pointers.
429 We perform the comparison in as efficient a manner as possible. */
431 static tree
433 {
437 /* If either operand has side-effects, they have to be evaluated only once
438 in spite of the multiple references to the operand in the comparison. */
442 /* The constant folder doesn't fold fat pointer types so we do it here. */
445 else
449 p1_array_is_null
452 null_pointer_node));
456 else
460 p2_array_is_null
463 null_pointer_node));
465 /* If one of the pointers to the array is null, just compare the other. */
471 /* Otherwise, do the fully-fledged comparison. */
472 same_array
477 else
478 p1_bounds
484 else
485 p2_bounds
489 same_bounds
492 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
496 }
497 \f
498 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
499 type TYPE. We know that TYPE is a modular type with a nonbinary
500 modulus. */
502 static tree
504 tree rhs)
505 {
511 tree result;
513 /* If this is an addition of a constant, convert it to a subtraction
514 of a constant since we can do that faster. */
516 {
519 }
521 /* For the logical operations, we only need PRECISION bits. For
522 addition and subtraction, we need one more and for multiplication we
523 need twice as many. But we never want to make a size smaller than
524 our size. */
532 /* Unsigned will do for everything but subtraction. */
536 /* If our type is the wrong signedness or isn't wide enough, make a new
537 type and convert both our operands to it. */
540 {
541 /* Copy the node so we ensure it can be modified to make it modular. */
548 }
550 /* Do the operation, then we'll fix it up. */
553 /* For multiplication, we have no choice but to do a full modulus
554 operation. However, we want to do this in the narrowest
555 possible size. */
557 {
565 }
567 /* For subtraction, add the modulus back if we are negative. */
569 {
575 result);
576 }
578 /* For the other operations, subtract the modulus if we are >= it. */
579 else
580 {
587 result);
588 }
591 }
592 \f
593 /* This page contains routines that implement the Ada semantics with regard
594 to atomic objects. They are fully piggybacked on the middle-end support
595 for atomic loads and stores.
597 *** Memory barriers and volatile objects ***
599 We implement the weakened form of the C.6(16) clause that was introduced
600 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
601 implementable without significant performance hits on modern platforms.
603 We also take advantage of the requirements imposed on shared variables by
604 9.10 (conditions for sequential actions) to have non-erroneous execution
605 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
606 volatile updates with regard to sequential actions, i.e. with regard to
607 reads or updates of atomic objects.
609 As such, an update of an atomic object by a task requires that all earlier
610 accesses to volatile objects have completed. Similarly, later accesses to
611 volatile objects cannot be reordered before the update of the atomic object.
612 So, memory barriers both before and after the atomic update are needed.
614 For a read of an atomic object, to avoid seeing writes of volatile objects
615 by a task earlier than by the other tasks, a memory barrier is needed before
616 the atomic read. Finally, to avoid reordering later reads or updates of
617 volatile objects to before the atomic read, a barrier is needed after the
618 atomic read.
620 So, memory barriers are needed before and after atomic reads and updates.
621 And, in order to simplify the implementation, we use full memory barriers
622 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
624 /* Return the size of TYPE, which must be a positive power of 2. */
626 static unsigned int
628 {
634 /* We shouldn't reach here without having already detected that the size
635 isn't compatible with an atomic access. */
639 }
641 /* Build an atomic load for the underlying atomic object in SRC. */
643 tree
645 {
646 tree ptr_type
647 = build_pointer_type
668 }
670 /* Build an atomic store from SRC to the underlying atomic object in DEST. */
672 tree
674 {
675 tree ptr_type
676 = build_pointer_type
697 }
698 \f
699 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
700 desired for the result. Usually the operation is to be performed
701 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
702 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
703 case the type to be used will be derived from the operands.
705 This function is very much unlike the ones for C and C++ since we
706 have already done any type conversion and matching required. All we
707 have to do here is validate the work done by SEM and handle subtypes. */
709 tree
712 {
732 modulus = (operation_type
738 {
741 #ifdef ENABLE_CHECKING
743 #endif
744 /* If there were integral or pointer conversions on the LHS, remove
745 them; we'll be putting them back below if needed. Likewise for
746 conversions between array and record types, except for justified
747 modular types. But don't do this if the right operand is not
748 BLKmode (for packed arrays) unless we are not changing the mode. */
769 (TREE_OPERAND
771 {
774 }
776 /* If a class-wide type may be involved, force use of the RHS type. */
782 /* If we are copying between padded objects with compatible types, use
783 the padded view of the objects, this is very likely more efficient.
784 Likewise for a padded object that is assigned a constructor, if we
785 can convert the constructor to the inner type, to avoid putting a
786 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
787 actually copied anything. */
792 == TYPE_MAIN_VARIANT
795 && !CONTAINS_PLACEHOLDER_P
798 {
799 /* We make an exception for a BLKmode type padding a non-BLKmode
800 inner type and do the conversion of the LHS right away, since
801 unchecked_convert wouldn't do it properly. */
805 {
809 }
810 else
812 }
814 /* If we have a call to a function that returns an unconstrained type
815 with default discriminant on the RHS, use the RHS type (which is
816 padded) as we cannot compute the size of the actual assignment. */
819 && CONTAINS_PLACEHOLDER_P
823 /* Find the best type to use for copying between aggregate types. */
831 /* Otherwise use the LHS type. */
832 else
835 /* Ensure everything on the LHS is valid. If we have a field reference,
836 strip anything that get_inner_reference can handle. Then remove any
837 conversions between types having the same code and mode. And mark
838 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
839 either an INDIRECT_REF, a NULL_EXPR or a DECL node. */
842 {
862 {
865 }
866 else
868 }
874 /* Convert the right operand to the operation type unless it is
875 either already of the correct type or if the type involves a
876 placeholder, since the RHS may not have the same record type. */
879 {
882 }
884 /* If the left operand is not of the same type as the operation
885 type, wrap it up in a VIEW_CONVERT_EXPR. */
897 /* ... fall through ... */
900 /* First look through conversion between type variants. Note that
901 this changes neither the operation type nor the type domain. */
905 {
908 }
910 /* For a range, make sure the element type is consistent. */
916 /* Then convert the right operand to its base type. This will prevent
917 unneeded sign conversions when sizetype is wider than integer. */
928 #ifdef ENABLE_CHECKING
930 #endif
942 #ifdef ENABLE_CHECKING
944 #endif
945 /* If either operand is a NULL_EXPR, just return a new one. */
950 integer_zero_node);
956 integer_zero_node);
958 /* If either object is a justified modular types, get the
959 fields from within. */
962 {
964 left_operand);
967 }
971 {
973 right_operand);
976 }
978 /* If both objects are arrays, compare them specially. */
985 {
990 else
994 }
996 /* Otherwise, the base types must be the same, unless they are both fat
997 pointer types or record types. In the latter case, use the best type
998 and convert both operands to that type. */
1000 {
1003 {
1007 }
1011 {
1012 /* The only way this is permitted is if both types have the same
1013 name. In that case, one of them must not be self-referential.
1014 Use it as the best type. Even better with a fixed size. */
1027 else
1029 }
1031 else
1036 }
1037 else
1038 {
1041 }
1043 /* If both objects are fat pointers, compare them specially. */
1045 {
1046 result
1051 else
1055 }
1064 /* The RHS of a shift can be any type. Also, ignore any modulus
1065 (we used to abort, but this is needed for unchecked conversion
1066 to modular types). Otherwise, processing is the same as normal. */
1075 /* For binary modulus, if the inputs are in range, so are the
1076 outputs. */
1092 /* These always produce results lower than either operand. */
1107 else
1111 /* ... fall through ... */
1115 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1116 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1117 these types but can generate addition/subtraction for Succ/Pred. */
1125 /* ... fall through ... */
1128 common:
1129 /* The result type should be the same as the base types of the
1130 both operands (and they should be the same). Convert
1131 everything to the result type. */
1137 }
1140 {
1144 }
1145 /* If either operand is a NULL_EXPR, just return a new one. */
1155 else
1156 result
1160 ;
1162 {
1166 }
1167 else
1173 /* If we are working with modular types, perform the MOD operation
1174 if something above hasn't eliminated the need for it. */
1183 }
1184 \f
1185 /* Similar, but for unary operations. */
1187 tree
1189 {
1193 tree result;
1206 {
1211 else
1218 #ifdef ENABLE_CHECKING
1220 #endif
1222 /* When not optimizing, fold the result as invert_truthvalue_loc
1223 doesn't fold the result of comparisons. This is intended to undo
1224 the trick used for boolean rvalues in gnat_to_gnu. */
1232 {
1237 /* Make sure the type here is a pointer, not a reference.
1238 GCC wants pointer types for function addresses. */
1242 /* If the underlying object can alias everything, propagate the
1243 property since we are effectively retrieving the object. */
1246 {
1249 result_type
1255 result_type
1259 }
1268 /* Fold a compound expression if it has unconstrained array type
1269 since the middle-end cannot handle it. But we don't it in the
1270 general case because it may introduce aliasing issues if the
1271 first operand is an indirect assignment and the second operand
1272 the corresponding address, e.g. for an allocator. */
1274 {
1280 }
1287 /* If this is for 'Address, find the address of the prefix and add
1288 the offset to the field. Otherwise, do this the normal way. */
1290 {
1291 HOST_WIDE_INT bitsize;
1292 HOST_WIDE_INT bitpos;
1301 /* If INNER is a padding type whose field has a self-referential
1302 size, convert to that inner type. We know the offset is zero
1303 and we need to have that type visible. */
1305 && CONTAINS_PLACEHOLDER_P
1309 inner);
1311 /* Compute the offset as a byte offset from INNER. */
1318 /* Take the address of INNER, convert the offset to void *, and
1319 add then. It will later be converted to the desired result
1320 type, if any. */
1326 result);
1328 }
1332 /* If this is just a constructor for a padded record, we can
1333 just take the address of the single field and convert it to
1334 a pointer to our type. */
1336 {
1341 }
1351 /* ... fallthru ... */
1354 /* If this just a variant conversion or if the conversion doesn't
1355 change the mode, get the result type from this type and go down.
1356 This is needed for conversions of CONST_DECLs, to eventually get
1357 to the address of their CORRESPONDING_VARs. */
1372 /* ... fall through ... */
1375 common:
1377 /* If we are taking the address of a padded record whose field
1378 contains a template, take the address of the field. */
1382 {
1385 }
1389 }
1395 {
1399 /* If TYPE is a thin pointer, either first retrieve the base if this
1400 is an expression with an offset built for the initialization of an
1401 object with an unconstrained nominal subtype, or else convert to
1402 the fat pointer. */
1404 {
1411 {
1414 }
1416 {
1417 operand
1419 operand);
1421 }
1422 }
1424 /* If we want to refer to an unconstrained array, use the appropriate
1425 expression. But this will never survive down to the back-end. */
1427 {
1432 }
1434 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1438 /* Otherwise, build and fold the indirect reference. */
1439 else
1440 {
1443 }
1446 {
1450 }
1458 }
1462 {
1463 tree modulus = ((operation_type
1469 /* If this is a modular type, there are various possibilities
1470 depending on the operation and whether the modulus is a
1471 power of two or not. */
1474 {
1478 /* The fastest in the negate case for binary modulus is
1479 the straightforward code; the TRUNC_MOD_EXPR below
1480 is an AND operation. */
1484 operand),
1485 modulus);
1487 /* For nonbinary negate case, return zero for zero operand,
1488 else return the modulus minus the operand. If the modulus
1489 is a power of two minus one, we can do the subtraction
1490 as an XOR since it is equivalent and faster on most machines. */
1492 {
1494 modulus,
1496 integer_one_node))))
1499 else
1505 boolean_type_node,
1506 operand,
1507 convert
1509 integer_zero_node)),
1511 }
1512 else
1513 {
1514 /* For the NOT cases, we need a constant equal to
1515 the modulus minus one. For a binary modulus, we
1516 XOR against the constant and subtract the operand from
1517 that constant for nonbinary modulus. */
1521 integer_one_node));
1526 else
1529 }
1532 }
1533 }
1535 /* ... fall through ... */
1541 }
1547 }
1548 \f
1549 /* Similar, but for COND_EXPR. */
1551 tree
1554 {
1556 tree result;
1558 /* The front-end verified that result, true and false operands have
1559 same base type. Convert everything to the result type. */
1563 /* If the result type is unconstrained, take the address of the operands and
1564 then dereference the result. Likewise if the result type is passed by
1565 reference, because creating a temporary of this type is not allowed. */
1569 {
1574 }
1579 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1580 in both arms, make sure it gets evaluated by moving it ahead of the
1581 conditional expression. This is necessary because it is evaluated
1582 in only one place at run time and would otherwise be uninitialized
1583 in one of the arms. */
1594 }
1596 /* Similar, but for COMPOUND_EXPR. */
1598 tree
1600 {
1602 tree result;
1604 /* If the result type is unconstrained, take the address of the operand and
1605 then dereference the result. Likewise if the result type is passed by
1606 reference, but this is natively handled in the gimplifier. */
1609 {
1613 }
1616 expr_operand);
1622 }
1623 \f
1624 /* Conveniently construct a function call expression. FNDECL names the
1625 function to be called, N is the number of arguments, and the "..."
1626 parameters are the argument expressions. Unlike build_call_expr
1627 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1629 tree
1631 {
1640 }
1641 \f
1642 /* Call a function that raises an exception and pass the line number and file
1643 name, if requested. MSG says which exception function to call.
1645 GNAT_NODE is the gnat node conveying the source location for which the
1646 error should be signaled, or Empty in which case the error is signaled on
1647 the current ref_file_name/input_line.
1649 KIND says which kind of exception this is for
1650 (N_Raise_{Constraint,Storage,Program}_Error). */
1652 tree
1654 {
1657 tree filename;
1662 /* If this is to be done as a goto, handle that case. */
1664 {
1668 /* If Local_Raise is present, generate
1669 Local_Raise (exception'Identity); */
1671 {
1672 tree gnu_local_raise
1674 tree gnu_exception_entity
1676 tree gnu_call
1679 gnu_exception_entity));
1685 }
1687 str
1691 ? IDENTIFIER_POINTER
1693 (Debug_Source_Name
1699 line_number
1706 return
1710 filename),
1712 }
1714 /* Similar to build_call_raise, for an index or range check exception as
1715 determined by MSG, with extra information generated of the form
1716 "INDEX out of range FIRST..LAST". */
1718 tree
1721 {
1723 tree filename;
1728 str
1732 ? IDENTIFIER_POINTER
1734 (Debug_Source_Name
1741 {
1744 }
1745 else
1746 {
1749 }
1754 return
1758 filename),
1764 }
1766 /* Similar to build_call_raise, with extra information about the column
1767 where the check failed. */
1769 tree
1771 {
1773 tree filename;
1778 str
1782 ? IDENTIFIER_POINTER
1784 (Debug_Source_Name
1791 {
1794 }
1795 else
1796 {
1799 }
1804 return
1808 filename),
1811 }
1812 \f
1813 /* qsort comparer for the bit positions of two constructor elements
1814 for record components. */
1816 static int
1818 {
1823 const int ret
1827 }
1829 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
1831 tree
1833 {
1839 /* Scan the elements to see if they are all constant or if any has side
1840 effects, to let us set global flags on the resulting constructor. Count
1841 the elements along the way for possible sorting purposes below. */
1843 {
1844 /* The predicate must be in keeping with output_constructor. */
1854 }
1856 /* For record types with constant components only, sort field list
1857 by increasing bit position. This is necessary to ensure the
1858 constructor can be output as static data. */
1867 }
1868 \f
1869 /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
1870 an IDENTIFIER_NODE giving the name of the field, or FIELD, a FIELD_DECL,
1871 for the field. Don't fold the result if NO_FOLD_P is true.
1873 We also handle the fact that we might have been passed a pointer to the
1874 actual record and know how to look for fields in variant parts. */
1876 static tree
1879 {
1887 /* If no field was specified, look for a field with the specified name in
1888 the current record only. */
1891 field;
1899 /* If this field is not in the specified record, see if we can find a field
1900 in the specified record whose original field is the same as this one. */
1902 {
1903 tree new_field;
1905 /* First loop through normal components. */
1907 new_field;
1912 /* Next, see if we're looking for an inherited component in an extension.
1913 If so, look through the extension directly, but not if the type contains
1914 a placeholder, as it might be needed for a later substitution. */
1920 == RECORD_TYPE
1922 {
1927 }
1929 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
1930 component in the first search. Doing this search in two steps is
1931 required to avoid hidden homonymous fields in the _Parent field. */
1934 new_field;
1937 {
1938 tree field_ref
1942 no_fold_p);
1945 }
1948 }
1953 /* If the field's offset has overflowed, do not try to access it, as doing
1954 so may trigger sanity checks deeper in the back-end. Note that we don't
1955 need to warn since this will be done on trying to declare the object. */
1960 /* Look through conversion between type variants. This is transparent as
1961 far as the field is concerned. */
1966 else
1970 NULL_TREE);
1985 /* The generic folder may punt in this case because the inner array type
1986 can be self-referential, but folding is in fact not problematic. */
1989 {
1997 }
2000 }
2001 \f
2002 /* Like build_simple_component_ref, except that we give an error if the
2003 reference could not be found. */
2005 tree
2008 {
2010 no_fold_p);
2015 /* If FIELD was specified, assume this is an invalid user field so raise
2016 Constraint_Error. Otherwise, we have no type to return so abort. */
2020 N_Raise_Constraint_Error));
2021 }
2022 \f
2023 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2024 identically. Process the case where a GNAT_PROC to call is provided. */
2029 {
2031 tree gnu_call;
2033 /* A storage pool's underlying type is a record type (for both predefined
2034 storage pools and GNAT simple storage pools). The secondary stack uses
2035 the same mechanism, but its pool object (SS_Pool) is an integer. */
2037 {
2038 /* The size is the third parameter; the alignment is the
2039 same type. */
2040 Entity_Id gnat_size_type
2051 /* The first arg is always the address of the storage pool; next
2052 comes the address of the object, for a deallocator, then the
2053 size and alignment. */
2057 else
2060 }
2062 /* Secondary stack case. */
2063 else
2064 {
2065 /* The size is the second parameter. */
2066 Entity_Id gnat_size_type
2072 /* The first arg is the address of the object, for a deallocator,
2073 then the size. */
2076 else
2078 }
2081 }
2083 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2084 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2085 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2086 latter offers. */
2090 {
2091 /* When the DATA_TYPE alignment is stricter than what malloc offers
2092 (super-aligned case), we allocate an "aligning" wrapper type and return
2093 the address of its single data field with the malloc's return value
2094 stored just in front. */
2097 unsigned int system_allocator_alignment
2100 tree aligning_type
2103 system_allocator_alignment,
2105 gnat_node)
2108 tree size_to_malloc
2111 tree malloc_ptr;
2113 /* On VMS, if pointers are 64-bit and the allocator size is 32-bit or
2114 Convention C, allocate 32-bit memory. */
2121 else
2125 {
2126 /* Latch malloc's return value and get a pointer to the aligning field
2127 first. */
2130 tree aligning_record_addr
2133 tree aligning_record
2136 tree aligning_field
2140 tree aligning_field_addr
2143 /* Then arrange to store the allocator's return value ahead
2144 and return. */
2145 tree storage_ptr_slot_addr
2151 tree storage_ptr_slot
2154 storage_ptr_slot_addr));
2156 return
2160 aligning_field_addr);
2161 }
2162 else
2164 }
2166 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2167 designated by DATA_PTR using the __gnat_free entry point. */
2171 {
2172 /* In the regular alignment case, we pass the data pointer straight to free.
2173 In the superaligned case, we need to retrieve the initial allocator
2174 return value, stored in front of the data block at allocation time. */
2177 unsigned int system_allocator_alignment
2180 tree free_ptr;
2183 {
2184 /* DATA_FRONT_PTR (void *)
2185 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2186 tree data_front_ptr
2187 = build_binary_op
2192 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2193 free_ptr
2194 = build_unary_op
2197 }
2198 else
2202 }
2204 /* Build a GCC tree to call an allocation or deallocation function.
2205 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2206 generate an allocator.
2208 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2209 object type, used to determine the to-be-honored address alignment.
2210 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2211 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2212 to provide an error location for restriction violation messages. */
2214 tree
2217 Node_Id gnat_node)
2218 {
2221 /* Explicit proc to call ? This one is assumed to deal with the type
2222 alignment constraints. */
2227 /* Otherwise, object to "free" or "malloc" with possible special processing
2228 for alignments stricter than what the default allocator honors. */
2231 else
2232 {
2233 /* Assert that we no longer can be called with this special pool. */
2236 /* Check that we aren't violating the associated restriction. */
2241 }
2242 }
2243 \f
2244 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2245 initial value is INIT, if INIT is nonzero. Convert the expression to
2246 RESULT_TYPE, which must be some pointer type, and return the result.
2248 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2249 the storage pool to use. GNAT_NODE is used to provide an error
2250 location for restriction violation messages. If IGNORE_INIT_TYPE is
2251 true, ignore the type of INIT for the purpose of determining the size;
2252 this will cause the maximum size to be allocated if TYPE is of
2253 self-referential size. */
2255 tree
2258 {
2261 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2265 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2270 ignore_init_type),
2273 ignore_init_type));
2275 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2276 sizes of the object and its template. Allocate the whole thing and
2277 fill in the parts that are known. */
2279 {
2280 tree storage_type
2287 init);
2289 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2299 /* If there is an initializing expression, then make a constructor for
2300 the entire object including the bounds and copy it into the object.
2301 If there is no initializing expression, just set the bounds. */
2303 {
2310 init);
2311 storage_init
2314 }
2315 else
2316 storage_init
2325 }
2329 /* If we have an initializing expression, see if its size is simpler
2330 than the size from the type. */
2336 /* If the size is still self-referential, reference the initializing
2337 expression, if it is present. If not, this must have been a
2338 call to allocate a library-level object, in which case we use
2339 the maximum size. */
2341 {
2344 else
2346 }
2348 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2355 gnat_node));
2357 /* If we have an initial value, protect the new address, assign the value
2358 and return the address with a COMPOUND_EXPR. */
2360 {
2364 storage_init
2367 }
2370 }
2371 \f
2372 /* Indicate that we need to take the address of T and that it therefore
2373 should not be allocated in a register. Returns true if successful. */
2375 bool
2377 {
2380 {
2389 CASE_CONVERT:
2417 }
2418 }
2419 \f
2420 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
2421 but we know how to handle our own nodes. */
2423 tree
2425 {
2433 {
2437 }
2439 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2440 This may be more efficient, but will also allow us to more easily find
2441 the match for the PLACEHOLDER_EXPR. */
2448 }
2450 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
2451 is optimized under the assumption that EXP's value doesn't change before
2452 its subsequent reuse(s) except through its potential reevaluation. */
2454 tree
2456 {
2463 /* If EXP has no side effects, we theoretically don't need to do anything.
2464 However, we may be recursively passed more and more complex expressions
2465 involving checks which will be reused multiple times and eventually be
2466 unshared for gimplification; in order to avoid a complexity explosion
2467 at that point, we protect any expressions more complex than a simple
2468 arithmetic expression. */
2470 {
2474 }
2476 /* If this is a conversion, protect what's inside the conversion. */
2482 /* If we're indirectly referencing something, we only need to protect the
2483 address since the data itself can't change in these situations. */
2485 {
2489 }
2491 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2492 This may be more efficient, but will also allow us to more easily find
2493 the match for the PLACEHOLDER_EXPR. */
2499 /* If this is a fat pointer or something that can be placed in a register,
2500 just make a SAVE_EXPR. Likewise for a CALL_EXPR as large objects are
2501 returned via invisible reference in most ABIs so the temporary will
2502 directly be filled by the callee. */
2508 /* Otherwise reference, protect the address and dereference. */
2509 return
2513 exp)));
2514 }
2516 /* This is equivalent to stabilize_reference_1 in tree.c but we take an extra
2517 argument to force evaluation of everything. */
2519 static tree
2521 {
2524 tree result;
2526 /* We cannot ignore const expressions because it might be a reference
2527 to a const array but whose index contains side-effects. But we can
2528 ignore things that are actual constant or that already have been
2529 handled by this function. */
2534 {
2541 /* If this is a COMPONENT_REF of a fat pointer, save the entire
2542 fat pointer. This may be more efficient, but will also allow
2543 us to more easily find the match for the PLACEHOLDER_EXPR. */
2546 result
2550 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2551 so that it will only be evaluated once. */
2552 /* The tcc_reference and tcc_comparison classes could be handled as
2553 below, but it is generally faster to only evaluate them once. */
2556 else
2561 /* Recursively stabilize each operand. */
2562 result
2569 /* Recursively stabilize each operand. */
2570 result
2577 }
2579 /* See similar handling in gnat_stabilize_reference. */
2591 }
2593 /* This is equivalent to stabilize_reference in tree.c but we know how to
2594 handle our own nodes and we take extra arguments. FORCE says whether to
2595 force evaluation of everything. We set SUCCESS to true unless we walk
2596 through something we don't know how to stabilize. */
2598 tree
2600 {
2603 tree result;
2605 /* Assume we'll success unless proven otherwise. */
2610 {
2615 /* No action is needed in this case. */
2619 CASE_CONVERT:
2623 result
2626 success));
2633 force));
2639 success),
2646 success),
2654 success),
2656 force),
2667 success),
2669 success));
2673 /* Constructors with 1 element are used extensively to formally
2674 convert objects to special wrapping types. */
2677 {
2680 result
2683 force));
2684 }
2685 else
2686 {
2690 }
2696 /* ... fall through to failure ... */
2698 /* If arg isn't a kind of lvalue we recognize, make no change.
2699 Caller should recognize the error for an invalid lvalue. */
2704 }
2706 /* TREE_THIS_VOLATILE and TREE_SIDE_EFFECTS set on the initial expression
2707 may not be sustained across some paths, such as the way via build1 for
2708 INDIRECT_REF. We reset those flags here in the general case, which is
2709 consistent with the GCC version of this routine.
2711 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
2712 paths introduce side-effects where there was none initially (e.g. if a
2713 SAVE_EXPR is built) and we also want to keep track of that. */
2725 }
2727 /* If EXPR is an expression that is invariant in the current function, in the
2728 sense that it can be evaluated anywhere in the function and any number of
2729 times, return EXPR or an equivalent expression. Otherwise return NULL. */
2731 tree
2733 {
2750 {
2752 {
2781 }
2784 }
2786 object:
2807 }