| blob | 0d7e03ec6b07cf659fe42f6388f95ec387907c0c |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S 2 *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2024, 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 ****************************************************************************/
62 /* Return the base type of TYPE. */
64 tree
66 {
77 }
79 /* EXP is a GCC tree representing an address. See if we can find how strictly
80 the object at this address is aligned and, if so, return the alignment of
81 the object in bits. Otherwise return 0. */
83 unsigned int
85 {
90 {
91 CASE_CONVERT:
94 /* Conversions between pointers and integers don't change the alignment
95 of the underlying object. */
100 /* The value of a COMPOUND_EXPR is that of its second operand. */
106 /* If two addresses are added, the alignment of the result is the
107 minimum of the two alignments. */
114 /* If this is the pattern built for aligning types, decode it. */
117 {
119 return
121 }
123 /* If we don't know the alignment of the offset, we assume that
124 of the base. */
130 else
135 /* If there is a choice between two values, use the smaller one. */
142 {
144 /* The first part of this represents the lowest bit in the constant,
145 but it is originally in bytes, not bits. */
147 }
151 /* If we know the alignment of just one side, use it. Otherwise,
152 use the product of the alignments. */
160 else
165 /* A bit-and expression is as aligned as the maximum alignment of the
166 operands. We typically get here for a complex lhs and a constant
167 negative power of two on the rhs to force an explicit alignment, so
168 don't bother looking at the lhs. */
175 else
180 {
188 }
190 /* ... fall through ... */
193 /* For other pointer expressions, we assume that the pointed-to object
194 is at least as aligned as the pointed-to type. Beware that we can
195 have a dummy type here (e.g. a Taft Amendment type), for which the
196 alignment is meaningless and should be ignored. */
201 else
204 }
207 }
209 /* We have a comparison or assignment operation on two types, T1 and T2, which
210 are either both array types or both record types. T1 is assumed to be for
211 the left hand side operand, and T2 for the right hand side. Return the
212 type that both operands should be converted to for the operation, if any.
213 Otherwise return zero. */
215 static tree
217 {
218 /* ??? As of today, various constructs lead to here with types of different
219 sizes even when both constants (e.g. tagged types, packable vs regular
220 component types, padded vs unpadded types, ...). While some of these
221 would better be handled upstream (types should be made consistent before
222 calling into build_binary_op), some others are really expected and we
223 have to be careful. */
225 const bool variable_record_on_lhs
231 const bool variable_array_on_lhs
237 /* We must avoid writing more than what the target can hold if this is for
238 an assignment and the case of tagged types is handled in build_binary_op
239 so we use the lhs type if it is known to be smaller or of constant size
240 and the rhs type is not, whatever the modes. We also force t1 in case of
241 constant size equality to minimize occurrences of view conversions on the
242 lhs of an assignment, except for the case of types with a variable part
243 on the lhs but not on the rhs to make the conversion simpler. */
248 && !variable_record_on_lhs
252 /* Otherwise, if the lhs type is non-BLKmode, use it, except for the case of
253 a non-BLKmode rhs and array types with a variable part on the lhs but not
254 on the rhs to make sure the conversion is preserved during gimplification.
255 Note that we know that we will not have any alignment problems since, if
256 we did, the non-BLKmode type could not have been used. */
261 /* If the rhs type is of constant size, use it whatever the modes. At
262 this point it is known to be smaller, or of constant size and the
263 lhs type is not. */
267 /* Otherwise, if the rhs type is non-BLKmode, use it. */
271 /* In this case, both types have variable size and BLKmode. It's
272 probably best to leave the "type mismatch" because changing it
273 could cause a bad self-referential reference. */
275 }
277 /* Return an expression tree representing an equality comparison of A1 and A2,
278 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
280 Two arrays are equal in one of two ways: (1) if both have zero length in
281 some dimension (not necessarily the same dimension) or (2) if the lengths
282 in each dimension are equal and the data is equal. We perform the length
283 tests in as efficient a manner as possible. */
285 static tree
287 {
297 /* If the operands have side-effects, they need to be evaluated only once
298 in spite of the multiple references in the comparison. */
305 /* Process each dimension separately and compare the lengths. If any
306 dimension has a length known to be zero, set LENGTH_ZERO_P to true
307 in order to suppress the comparison of the data at the end. */
309 {
316 size_one_node);
321 size_one_node);
331 /* If the length of the first array is a constant and that of the second
332 array is not, swap our operands to have the constant second. */
335 {
336 tree tem;
347 }
349 /* If the length of the second array is the constant zero, we can just
350 use the original stored bounds for the first array and see whether
351 last < first holds. */
353 {
363 }
365 /* Otherwise, if the length is some other constant value, we know that
366 this dimension in the second array cannot be superflat, so we can
367 just use its length computed from the actual stored bounds. */
369 {
370 /* Note that we know that LB2 and UB2 are constant and hence
371 cannot contain a PLACEHOLDER_EXPR. */
375 comparison
381 this_a1_is_null
385 }
387 /* Otherwise, compare the computed lengths. */
388 else
389 {
393 comparison
399 this_a1_is_null
405 this_a2_is_null
407 }
409 /* Append expressions for this dimension to the final expressions. */
421 }
423 /* Unless the length of some dimension is known to be zero, compare the
424 data in the array. */
426 {
428 tree comparison;
431 {
434 }
438 result
440 }
442 /* The result is also true if both sizes are zero. */
446 result);
448 /* If the operands have side-effects, they need to be evaluated before
449 doing the tests above since the place they otherwise would end up
450 being evaluated at run time could be wrong. */
458 }
460 /* Return an expression tree representing an ordering comparison of A1 and A2,
461 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
463 A1 is less than A2 according to the following alternative:
464 - when A1's length is less than A2'length: if every element of A1 is equal
465 to its counterpart in A2 or the first differing is lesser in A1 than A2,
466 - otherwise: if not every element of A2 is equal to its counterpart in A1
467 and the first differing is lesser in A1 than A2.
469 The other 3 ordering comparisons can be easily deduced from this one. */
471 static tree
473 {
484 size_one_node);
489 size_one_node);
492 /* If the lengths are known at compile time, fold the alternative and let the
493 gimplifier optimize the case of power-of-two lengths. */
499 /* If the operands have side-effects, they need to be evaluated only once
500 in spite of the multiple references in the comparison. */
510 /* If the lengths are not known at compile time, call memcmp directly with
511 the actual lengths since a1 and a2 may have the same nominal subtype. */
516 result
523 length1),
524 integer_zero_node),
528 length2),
529 integer_zero_node));
531 /* If the operands have side-effects, they need to be evaluated before
532 doing the tests above since the place they otherwise would end up
533 being evaluated at run time could be wrong. */
541 }
543 /* Return an expression tree representing an equality comparison of P1 and P2,
544 two objects of fat pointer type. The result should be of type RESULT_TYPE.
546 Two fat pointers are equal in one of two ways: (1) if both have a null
547 pointer to the array or (2) if they contain the same couple of pointers.
548 We perform the comparison in as efficient a manner as possible. */
550 static tree
552 {
556 /* If either operand has side-effects, they have to be evaluated only once
557 in spite of the multiple references to the operand in the comparison. */
561 /* The constant folder doesn't fold fat pointer types so we do it here. */
564 else
567 p1_array_is_null
570 null_pointer_node));
574 else
577 p2_array_is_null
580 null_pointer_node));
582 /* If one of the pointers to the array is null, just compare the other. */
588 /* Otherwise, do the fully-fledged comparison. */
589 same_array
594 else
595 p1_bounds
601 else
602 p2_bounds
606 same_bounds
609 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
613 }
615 /* Try to compute the reduction of OP modulo MODULUS in PRECISION bits with a
616 division-free algorithm. Return NULL_TREE if this is not easily doable. */
618 tree
620 {
624 /* The implementation is host-dependent for the time being. */
626 {
630 tree t;
632 /* The trick is to replace the division by d with a multiply-and-shift
633 sequence parameterized by a (multiplier, shifter) pair computed from
634 d, the precision of the type and the needed precision:
636 op / d = (op * multiplier) >> shifter
638 But choose_multiplier provides a slightly different interface:
640 op / d = (op h* multiplier) >> reduced_shifter
642 that makes things easier by using a high-part multiplication. */
645 /* If the suggested multiplier is more than TYPE_PRECISION bits, we can
646 do better for even divisors, using an initial right shift. */
648 {
652 }
653 else
656 /* If the suggested multiplier is still more than TYPE_PRECISION bits,
657 or the TYPE_MODE does not have a high-part multiply, try again with
658 a larger type up to the word size. */
660 {
662 {
663 const scalar_int_mode m
671 }
674 }
676 /* This computes op - (op / modulus) * modulus with PRECISION bits. */
679 /* t = op >> pre_shift
680 t = t h* ml
681 t = t >> post_shift
682 t = t * modulus */
686 else
695 }
697 else
699 }
701 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
702 TYPE. We know that TYPE is a modular type with a nonbinary modulus. */
704 static tree
706 tree rhs)
707 {
712 /* For the logical operations, we only need PRECISION bits. For addition and
713 subtraction, we need one more, and for multiplication twice as many. */
719 /* If the type is not wide enough, make a new type of the needed precision
720 and convert modulus and operands to it. Use a type with full precision
721 for its mode since operations are ultimately performed in the mode. */
723 {
729 }
730 else
733 /* Do the operation, then we'll fix it up. */
736 /* Unconditionally add the modulus to the result for a subtraction, this gets
737 rid of all its peculiarities by cancelling out the addition of the binary
738 modulus in the case where the subtraction wraps around in OP_TYPE, and may
739 even generate better code on architectures with conditional moves. */
743 /* For a multiplication, we first try to do a modulo reduction by means of a
744 (multiplier, shifter) pair in the needed precision up to the word size, or
745 else we fall back to a standard modulo operation. But not when optimizing
746 for size, because it will be longer than a div+mul+sub sequence. */
748 {
753 else
755 }
757 /* For the other operations, subtract the modulus if we are >= it. */
758 else
759 {
766 result);
767 }
770 }
772 /* This page contains routines that implement the Ada semantics with regard
773 to atomic objects. They are fully piggybacked on the middle-end support
774 for atomic loads and stores.
776 *** Memory barriers and volatile objects ***
778 We implement the weakened form of the C.6(16) clause that was introduced
779 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
780 implementable without significant performance hits on modern platforms.
782 We also take advantage of the requirements imposed on shared variables by
783 9.10 (conditions for sequential actions) to have non-erroneous execution
784 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
785 volatile updates with regard to sequential actions, i.e. with regard to
786 reads or updates of atomic objects.
788 As such, an update of an atomic object by a task requires that all earlier
789 accesses to volatile objects have completed. Similarly, later accesses to
790 volatile objects cannot be reordered before the update of the atomic object.
791 So, memory barriers both before and after the atomic update are needed.
793 For a read of an atomic object, to avoid seeing writes of volatile objects
794 by a task earlier than by the other tasks, a memory barrier is needed before
795 the atomic read. Finally, to avoid reordering later reads or updates of
796 volatile objects to before the atomic read, a barrier is needed after the
797 atomic read.
799 So, memory barriers are needed before and after atomic reads and updates.
800 And, in order to simplify the implementation, we use full memory barriers
801 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
803 /* Return the size of TYPE, which must be a positive power of 2. */
805 unsigned int
807 {
813 /* We shouldn't reach here without having already detected that the size
814 isn't compatible with an atomic access. */
818 }
820 /* Build an atomic load for the underlying atomic object in SRC. SYNC is
821 true if the load requires synchronization. */
823 tree
825 {
826 tree ptr_type
827 = build_pointer_type
830 tree mem_model
838 /* Remove conversions to get the address of the underlying object. */
851 /* First reinterpret the loaded bits in the original type of the load,
852 then convert to the expected result type. */
855 }
857 /* Build an atomic store from SRC to the underlying atomic object in DEST.
858 SYNC is true if the store requires synchronization. */
860 tree
862 {
863 tree ptr_type
864 = build_pointer_type
867 tree mem_model
875 /* Remove conversions to get the address of the underlying object. */
886 /* First convert the bits to be stored to the original type of the store,
887 then reinterpret them in the effective type. But if the original type
888 is a padded type with the same size, convert to the inner type instead,
889 as we don't want to artificially introduce a CONSTRUCTOR here. */
893 else
899 }
901 /* Build a load-modify-store sequence from SRC to DEST. GNAT_NODE is used for
902 the location of the sequence. Note that, even though the load and the store
903 are both atomic, the sequence itself is not atomic. */
905 tree
907 {
908 /* We will be modifying DEST below so we build a copy. */
913 {
914 /* The load should already have been generated during the translation
915 of the GNAT destination tree; find it out in the GNU tree. */
917 {
920 {
925 /* Find out the loaded object. */
930 else
933 /* Drop atomic and volatile qualifiers for the temporary. */
936 /* And drop BLKmode, if need be, to put it into a register. */
938 {
943 }
945 /* Create the temporary by inserting a SAVE_EXPR. */
952 /* Build the modify of the temporary. */
956 /* Build the store to the object. */
961 }
962 }
966 }
968 /* Something went wrong earlier if we have not found the atomic load. */
970 }
972 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
973 desired for the result. Usually the operation is to be performed
974 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
975 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
976 case the type to be used will be derived from the operands.
977 Don't fold the result if NO_FOLD is true.
979 This function is very much unlike the ones for C and C++ since we
980 have already done any type conversion and matching required. All we
981 have to do here is validate the work done by SEM and handle subtypes. */
983 tree
987 {
1005 modulus = (operation_type
1011 {
1016 /* If there were integral or pointer conversions on the LHS, remove
1017 them; we'll be putting them back below if needed. Likewise for
1018 conversions between record types, except for justified modular types.
1019 But don't do this if the right operand is not BLKmode (for packed
1020 arrays) unless we are not changing the mode, or if both ooperands
1021 are view conversions to the same type. */
1037 {
1040 }
1042 /* If a class-wide type may be involved, force use of the RHS type. */
1048 /* If we are copying between padded objects with compatible types, use
1049 the padded view of the objects, this is very likely more efficient.
1050 Likewise for a padded object that is assigned a constructor, if we
1051 can convert the constructor to the inner type, to avoid putting a
1052 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
1053 actually copied anything. */
1060 && !CONTAINS_PLACEHOLDER_P
1063 {
1064 /* We make an exception for a BLKmode type padding a non-BLKmode
1065 inner type and do the conversion of the LHS right away, since
1066 unchecked_convert wouldn't do it properly. */
1070 {
1074 }
1075 else
1077 }
1079 /* If we have a call to a function that returns with variable size, use
1080 the RHS type in case we want to use the return slot optimization. */
1085 /* Find the best type to use for copying between aggregate types. */
1093 /* Otherwise use the LHS type. */
1094 else
1097 /* Ensure everything on the LHS is valid. If we have a field reference,
1098 strip anything that get_inner_reference can handle. Then remove any
1099 conversions between types having the same code and mode. And mark
1100 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
1101 either an INDIRECT_REF, a NULL_EXPR, a SAVE_EXPR or a DECL node. */
1104 {
1124 {
1127 }
1129 else
1131 }
1138 /* Convert the right operand to the operation type unless it is
1139 either already of the correct type or if the type involves a
1140 placeholder, since the RHS may not have the same record type. */
1143 {
1146 }
1148 /* If the left operand is not of the same type as the operation
1149 type, wrap it up in a VIEW_CONVERT_EXPR. */
1161 /* ... fall through ... */
1164 /* First look through conversion between type variants. Note that
1165 this changes neither the operation type nor the type domain. */
1169 {
1172 }
1174 /* For a range, make sure the element type is consistent. */
1177 {
1181 /* Declare it now since it will never be declared otherwise. This
1182 is necessary to ensure that its subtrees are properly marked. */
1185 }
1187 /* Then convert the right operand to its base type. This will prevent
1188 unneeded sign conversions when sizetype is wider than integer. */
1199 gcc_checking_assert
1212 gcc_checking_assert
1214 /* If either operand is a NULL_EXPR, just return a new one. */
1219 integer_zero_node);
1225 integer_zero_node);
1227 /* If either object is a justified modular types, get the
1228 fields from within. */
1231 {
1233 left_operand);
1236 }
1240 {
1242 right_operand);
1245 }
1247 /* If both objects are arrays, compare them specially. */
1254 {
1256 {
1257 result
1262 }
1264 else
1265 {
1266 /* Swap the operands to canonicalize to LT_EXPR or GE_EXPR. */
1268 result
1272 else
1273 result
1277 /* GE_EXPR is (not LT_EXPR) for discrete array types. */
1280 }
1283 }
1285 /* Otherwise, the base types must be the same, unless they are both (fat)
1286 pointer types or record types. In the latter case, use the best type
1287 and convert both operands to that type. */
1289 {
1292 {
1296 }
1300 {
1304 /* Anonymous access types in Ada 2005 may point to compatible
1305 object subtypes or function types in the language sense. */
1309 }
1313 {
1314 /* The only way this is permitted is if both types have the same
1315 name. In that case, one of them must not be self-referential.
1316 Use it as the best type. Even better with a fixed size. */
1329 else
1331 }
1333 else
1338 }
1339 else
1340 {
1343 }
1345 /* If both objects are fat pointers, compare them specially. */
1347 {
1348 result
1353 else
1357 }
1366 /* The RHS of a shift can be any type. Also, ignore any modulus
1367 (we used to abort, but this is needed for unchecked conversion
1368 to modular types). Otherwise, processing is the same as normal. */
1377 /* For binary modulus, if the inputs are in range, so are the
1378 outputs. */
1394 /* These always produce results lower than either operand. */
1409 else
1413 /* ... fall through ... */
1417 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1418 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1419 these types but can generate addition/subtraction for Succ/Pred. */
1427 /* ... fall through ... */
1430 common:
1431 /* The result type should be the same as the base types of the
1432 both operands (and they should be the same). Convert
1433 everything to the result type. */
1439 }
1442 {
1446 }
1447 /* If either operand is a NULL_EXPR, just return a new one. */
1453 {
1458 }
1463 else
1464 result
1468 ;
1470 {
1473 }
1480 /* If we are working with modular types, perform the MOD operation
1481 if something above hasn't eliminated the need for it. */
1483 {
1487 else
1489 }
1495 }
1497 /* Similar, but for unary operations. */
1499 tree
1501 {
1505 tree result;
1518 {
1523 else
1530 gcc_checking_assert
1533 /* When not optimizing, fold the result as invert_truthvalue_loc
1534 doesn't fold the result of comparisons. This is intended to undo
1535 the trick used for boolean rvalues in gnat_to_gnu. */
1543 {
1548 /* Make sure the type here is a pointer, not a reference.
1549 GCC wants pointer types for function addresses. */
1553 /* If the underlying object can alias everything, propagate the
1554 property since we are effectively retrieving the object. */
1557 {
1560 result_type
1566 result_type
1570 }
1579 /* Fold a compound expression if it has unconstrained array type
1580 since the middle-end cannot handle it. But we don't it in the
1581 general case because it may introduce aliasing issues if the
1582 first operand is an indirect assignment and the second operand
1583 the corresponding address, e.g. for an allocator. However do
1584 it for a return value to expose it for later recognition. */
1588 {
1594 }
1601 /* If this is for 'Address, find the address of the prefix and add
1602 the offset to the field. Otherwise, do this the normal way. */
1604 {
1605 poly_int64 bitsize;
1606 poly_int64 bitpos;
1608 machine_mode mode;
1615 /* If INNER is a padding type whose field has a self-referential
1616 size, convert to that inner type. We know the offset is zero
1617 and we need to have that type visible. */
1620 inner);
1622 /* Compute the offset as a byte offset from INNER. */
1626 offset
1630 /* Take the address of INNER, convert it to a pointer to our type
1631 and add the offset. */
1634 inner);
1638 }
1642 /* If this is just a constructor for a padded record, we can
1643 just take the address of the single field and convert it to
1644 a pointer to our type. */
1646 {
1647 result
1652 }
1661 /* ... fallthru ... */
1664 /* If this just a variant conversion or if the conversion doesn't
1665 change the mode, get the result type from this type and go down.
1666 This is needed for conversions of CONST_DECLs, to eventually get
1667 to the address of their CORRESPONDING_VARs. */
1682 /* ... fall through ... */
1685 common:
1687 /* If we are taking the address of a padded record whose field
1688 contains a template, take the address of the field. */
1692 {
1695 }
1699 }
1707 {
1711 /* If TYPE is a thin pointer, either first retrieve the base if this
1712 is an expression with an offset built for the initialization of an
1713 object with an unconstrained nominal subtype, or else convert to
1714 the fat pointer. */
1716 {
1723 {
1726 }
1728 {
1729 operand
1731 operand);
1733 }
1734 }
1736 /* If we want to refer to an unconstrained array, use the appropriate
1737 expression. But this will never survive down to the back-end. */
1739 {
1744 }
1746 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1750 /* Otherwise, build and fold the indirect reference. */
1751 else
1752 {
1755 }
1758 {
1762 }
1770 }
1774 {
1775 tree modulus = ((operation_type
1781 /* If this is a modular type, there are various possibilities
1782 depending on the operation and whether the modulus is a
1783 power of two or not. */
1786 {
1790 /* The fastest in the negate case for binary modulus is
1791 the straightforward code; the TRUNC_MOD_EXPR below
1792 is an AND operation. */
1796 operand),
1797 modulus);
1799 /* For nonbinary negate case, return zero for zero operand,
1800 else return the modulus minus the operand. If the modulus
1801 is a power of two minus one, we can do the subtraction
1802 as an XOR since it is equivalent and faster on most machines. */
1804 {
1806 modulus,
1811 else
1817 boolean_type_node,
1818 operand,
1819 build_int_cst
1822 }
1823 else
1824 {
1825 /* For the NOT cases, we need a constant equal to
1826 the modulus minus one. For a binary modulus, we
1827 XOR against the constant and subtract the operand from
1828 that constant for nonbinary modulus. */
1836 else
1839 }
1842 }
1843 }
1845 /* ... fall through ... */
1851 }
1857 }
1859 /* Similar, but for COND_EXPR. */
1861 tree
1864 {
1866 tree result;
1868 /* The front-end verified that result, true and false operands have
1869 same base type. Convert everything to the result type. */
1873 /* If the result type is unconstrained or variable-sized, take the address
1874 of the operands and then dereference the result. Likewise if the result
1875 type is passed by reference, because creating a temporary of this type is
1876 not allowed. */
1881 {
1886 }
1891 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1892 in both arms, make sure it gets evaluated by moving it ahead of the
1893 conditional expression. This is necessary because it is evaluated
1894 in only one place at run time and would otherwise be uninitialized
1895 in one of the arms. */
1906 }
1908 /* Similar, but for COMPOUND_EXPR. */
1910 tree
1912 {
1914 tree result;
1916 /* If the result type is unconstrained, take the address of the operand and
1917 then dereference the result. Likewise if the result type is passed by
1918 reference, but this is natively handled in the gimplifier. */
1921 {
1925 }
1928 expr_operand);
1934 }
1936 /* Conveniently construct a function call expression. FNDECL names the
1937 function to be called, N is the number of arguments, and the "..."
1938 parameters are the argument expressions. Unlike build_call_expr
1939 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1941 tree
1943 {
1952 }
1954 /* Build a goto to LABEL for a raise, with an optional call to Local_Raise.
1955 MSG gives the exception's identity for the call to Local_Raise, if any. */
1957 static tree
1959 {
1964 /* If Local_Raise is present, build Local_Raise (Exception'Identity). */
1966 {
1967 tree gnu_local_raise
1969 tree gnu_exception_entity
1971 tree gnu_call
1974 gnu_exception_entity));
1975 gnu_result
1977 }
1981 }
1983 /* Expand the SLOC of GNAT_NODE, if present, into tree location information
1984 pointed to by FILENAME, LINE and COL. Fall back to the current location
1985 if GNAT_NODE is absent or has no SLOC. */
1987 static void
1989 {
1994 {
1998 }
2000 {
2001 str = Get_Name_String
2005 }
2006 else
2007 {
2011 }
2020 }
2022 /* Build a call to a function that raises an exception and passes file name
2023 and line number, if requested. MSG says which exception function to call.
2024 GNAT_NODE is the node conveying the source location for which the error
2025 should be signaled, or Empty in which case the error is signaled for the
2026 current location. KIND says which kind of exception node this is for,
2027 among N_Raise_{Constraint,Storage,Program}_Error. */
2029 tree
2031 {
2036 /* If this is to be done as a goto, handle that case. */
2042 return
2046 filename),
2047 line);
2048 }
2050 /* Similar to build_call_raise, with extra information about the column
2051 where the check failed. */
2053 tree
2055 {
2060 /* If this is to be done as a goto, handle that case. */
2066 return
2070 filename),
2072 }
2074 /* Similar to build_call_raise_column, for an index or range check exception ,
2075 with extra information of the form "INDEX out of range FIRST..LAST". */
2077 tree
2080 {
2085 /* If this is to be done as a goto, handle that case. */
2091 return
2095 filename),
2100 }
2102 /* qsort comparer for the bit positions of two constructor elements
2103 for record components. */
2105 static int
2107 {
2112 const int ret
2116 }
2118 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
2120 tree
2122 {
2129 /* Scan the elements to see if they are all constant or if any has side
2130 effects, to let us set global flags on the resulting constructor. Count
2131 the elements along the way for possible sorting purposes below. */
2133 {
2134 /* The predicate must be in keeping with output_constructor and, unlike
2135 initializer_constant_valid_p, we accept "&{...}" because we'll put
2136 the CONSTRUCTOR into the constant pool during gimplification. */
2154 }
2156 /* For record types with constant components only, sort field list
2157 by increasing bit position. This is necessary to ensure the
2158 constructor can be output as static data. */
2168 }
2170 /* Return a COMPONENT_REF to access FIELD in RECORD, or NULL_TREE if the field
2171 is not found in the record. Don't fold the result if NO_FOLD is true. */
2173 static tree
2175 {
2177 tree ref;
2179 /* The failure of this assertion will very likely come from a missing
2180 insertion of an explicit dereference. */
2183 /* The type must be frozen at this point. */
2186 /* Try to fold a conversion from another record or union type unless the type
2187 contains a placeholder as it might be needed for a later substitution. */
2191 {
2194 /* If this is an unpadding operation, convert the underlying object to
2195 the unpadded type directly. */
2199 /* Otherwise try to access FIELD directly in the underlying type, but
2200 make sure that the form of the reference doesn't change too much;
2201 this can happen for an unconstrained bit-packed array type whose
2202 constrained form can be an integer type. */
2206 }
2208 /* If this field is not in the specified record, see if we can find a field
2209 in the specified record whose original field is the same as this one. */
2211 {
2212 tree new_field;
2214 /* First loop through normal components. */
2216 new_field;
2221 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
2222 component in the first search. Doing this search in two steps is
2223 required to avoid hidden homonymous fields in the _Parent field. */
2226 new_field;
2230 {
2231 tree field_ref
2236 }
2239 }
2244 /* If the field's offset has overflowed, do not try to access it, as doing
2245 so may trigger sanity checks deeper in the back-end. Note that we don't
2246 need to warn since this will be done on trying to declare the object. */
2251 N_Raise_Storage_Error));
2268 /* The generic folder may punt in this case because the inner array type
2269 can be self-referential, but folding is in fact not problematic. */
2272 {
2280 }
2283 }
2285 /* Likewise, but return NULL_EXPR and generate a Program_Error if the
2286 field is not found in the record. */
2288 tree
2290 {
2295 /* The missing field should have been detected in the front-end. */
2298 /* Assume this is an invalid user field so raise Program_Error. */
2301 N_Raise_Program_Error));
2302 }
2304 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2305 identically. Process the case where a GNAT_PROC to call is provided. */
2310 {
2314 tree gnu_call;
2316 /* A storage pool's underlying type is a record type for both predefined
2317 storage pools and GNAT simple storage pools. The return and secondary
2318 stacks use the same mechanism, but their pool object is an integer. */
2320 {
2321 /* The size is the third parameter; the alignment is the
2322 same type. */
2323 Entity_Id gnat_size_type
2333 /* The first arg is always the address of the storage pool; next
2334 comes the address of the object, for a deallocator, then the
2335 size and alignment. */
2339 else
2342 }
2344 else
2345 {
2346 /* The size is the second parameter. */
2347 Entity_Id gnat_size_type
2351 /* Deallocation is not supported for return and secondary stacks. */
2359 {
2360 /* This must be a function that returns by invisible reference. */
2363 tree gnu_ret_size;
2367 /* The allocation has already been done by the caller so we check that
2368 we are not going to overflow the return slot. */
2370 gnu_ret_size
2371 = TYPE_SIZE_UNIT
2373 else
2376 gnu_call
2380 gnu_ret_size),
2381 gnu_call,
2383 N_Raise_Program_Error));
2384 }
2386 else
2388 }
2391 }
2393 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2394 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2395 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2396 latter offers. */
2400 {
2401 /* When the DATA_TYPE alignment is stricter than what malloc offers
2402 (super-aligned case), we allocate an "aligning" wrapper type and return
2403 the address of its single data field with the malloc's return value
2404 stored just in front. */
2407 unsigned int system_allocator_alignment
2410 tree aligning_type
2413 system_allocator_alignment,
2415 gnat_node)
2418 tree size_to_malloc
2426 {
2427 /* Latch malloc's return value and get a pointer to the aligning field
2428 first. */
2431 tree aligning_record_addr
2434 tree aligning_record
2437 tree aligning_field
2441 tree aligning_field_addr
2444 /* Then arrange to store the allocator's return value ahead
2445 and return. */
2446 tree storage_ptr_slot_addr
2452 tree storage_ptr_slot
2455 storage_ptr_slot_addr));
2457 return
2461 aligning_field_addr);
2462 }
2463 else
2465 }
2467 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2468 designated by DATA_PTR using the __gnat_free entry point. */
2472 {
2473 /* In the regular alignment case, we pass the data pointer straight to free.
2474 In the superaligned case, we need to retrieve the initial allocator
2475 return value, stored in front of the data block at allocation time. */
2478 unsigned int system_allocator_alignment
2481 tree free_ptr;
2486 {
2487 /* DATA_FRONT_PTR (void *)
2488 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2489 tree data_front_ptr
2490 = build_binary_op
2495 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2496 free_ptr
2497 = build_unary_op
2500 }
2501 else
2505 }
2507 /* Build a GCC tree to call an allocation or deallocation function.
2508 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2509 generate an allocation.
2511 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2512 object type, used to determine the to-be-honored address alignment.
2513 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2514 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2515 to provide an error location for restriction violation messages. */
2517 tree
2520 Node_Id gnat_node)
2521 {
2522 /* Explicit proc to call ? This one is assumed to deal with the type
2523 alignment constraints. */
2528 /* Otherwise, object to "free" or "malloc" with possible special processing
2529 for alignments stricter than what the default allocator honors. */
2532 else
2533 {
2534 /* Assert that we no longer can be called with this special pool. */
2537 /* Check that we aren't violating the associated restriction. */
2539 {
2545 }
2547 }
2548 }
2550 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2551 initial value is INIT, if INIT is nonzero. Convert the expression to
2552 RESULT_TYPE, which must be some pointer type, and return the result.
2554 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2555 the storage pool to use. GNAT_NODE is used to provide an error
2556 location for restriction violation messages. If IGNORE_INIT_TYPE is
2557 true, ignore the type of INIT for the purpose of determining the size;
2558 this will cause the maximum size to be allocated if TYPE is of
2559 self-referential size. */
2561 tree
2564 {
2565 const bool pool_is_storage_model
2571 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2575 /* If we are just annotating types, also return a NULL_EXPR. */
2579 N_Raise_Constraint_Error));
2581 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2586 ignore_init_type),
2589 ignore_init_type));
2591 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2592 sizes of the object and its template. Allocate the whole thing and
2593 fill in the parts that are known. */
2595 {
2596 tree storage_type
2606 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2616 /* If there is an initializing expression, then make a constructor for
2617 the entire object including the bounds and copy it into the object.
2618 If there is no initializing expression, just set the bounds. Note
2619 that, if we have a storage model, we need to copy the initializing
2620 expression separately from the bounds. */
2622 {
2629 init);
2633 }
2634 else
2635 {
2639 }
2642 {
2645 {
2648 lhs
2658 }
2659 }
2660 else
2665 }
2669 /* If we have an initializing expression, see if its size is simpler
2670 than the size from the type. */
2676 /* If the size is still self-referential, reference the initializing
2677 expression, if it is present. If not, this must have been a call
2678 to allocate a library-level object, in which case we just use the
2679 maximum size. */
2685 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2692 gnat_node));
2694 /* If we have an initial value, protect the new address, assign the value
2695 and return the address with a COMPOUND_EXPR. */
2697 {
2702 storage_init
2704 else
2705 storage_init
2708 }
2711 }
2713 /* Build a call to a copy procedure of a storage model given by an object.
2714 DEST, SRC and SIZE are as for a call to memcpy. GNAT_SMO is the entity
2715 for the storage model object and COPY_TO says which procedure to use. */
2717 static tree
2720 {
2721 const Entity_Id gnat_copy_proc
2722 = copy_to
2730 tree t4
2733 return
2740 }
2742 /* Build a load of SRC using the storage model of GNAT_SMO. */
2744 tree
2746 {
2749 /* Unconstrained array references have no size so we need to store the
2750 storage object model for future processing by the machinery. */
2753 else
2757 }
2759 /* Build a load of SRC into DEST using the storage model of GNAT_SMO.
2760 If SIZE is specified, use it, otherwise use the size of SRC. */
2762 tree
2764 {
2768 {
2772 }
2775 }
2777 /* Build a store of SRC into DEST using the storage model of GNAT_SMO.
2778 If SIZE is specified, use it, otherwise use the size of DEST. */
2780 tree
2782 {
2786 {
2790 }
2793 }
2795 /* Given a tree EXP, instantiate occurrences of LOAD_EXPR in it and associate
2796 them with the storage model of GNAT_SMO. */
2798 tree
2800 {
2804 tree new_tree;
2806 /* We handle TREE_LIST and COMPONENT_REF separately. */
2808 {
2815 }
2817 {
2818 /* The field. */
2821 /* If it is a discriminant or equivalent, a LOAD_EXPR is needed. */
2830 }
2831 else
2833 {
2842 /* Fall through. */
2850 {
2902 }
2906 {
2921 }
2925 }
2933 }
2935 /* Given an array or slice reference, instantiate occurrences of LOAD_EXPR in
2936 it and associate them with the storage model of GNAT_SMO. */
2938 void
2940 {
2952 ref),
2956 }
2958 /* Indicate that we need to take the address of T and that it therefore
2959 should not be allocated in a register. Return true if successful. */
2961 bool
2963 {
2966 {
2975 CASE_CONVERT:
3003 }
3004 }
3006 /* Return true if EXP is a stable expression for the purpose of the functions
3007 below and, therefore, can be returned unmodified by them. We accept things
3008 that are actual constants or that have already been handled. */
3010 static bool
3012 {
3015 }
3017 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.cc
3018 but we know how to handle our own nodes. */
3020 tree
3022 {
3030 {
3034 }
3036 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
3037 This may be more efficient, but will also allow us to more easily find
3038 the match for the PLACEHOLDER_EXPR. */
3045 }
3047 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
3048 is optimized under the assumption that EXP's value doesn't change before
3049 its subsequent reuse(s) except potentially through its reevaluation.
3051 gnat_protect_expr guarantees that multiple evaluations of the expression
3052 will not generate multiple side effects, whereas gnat_save_expr further
3053 guarantees that all evaluations will yield the same result. */
3055 tree
3057 {
3064 /* If EXP has no side effects, we theoretically don't need to do anything.
3065 However, we may be recursively passed more and more complex expressions
3066 involving checks which will be reused multiple times and eventually be
3067 unshared for gimplification; in order to avoid a complexity explosion
3068 at that point, we protect any expressions more complex than a simple
3069 arithmetic expression. */
3071 {
3075 }
3077 /* If this is a conversion, protect what's inside the conversion. */
3083 /* If we're indirectly referencing something, we only need to protect the
3084 address since the data itself can't change in these situations. */
3086 {
3090 }
3092 /* Likewise if we're indirectly referencing part of something. */
3098 /* An atomic load is an INDIRECT_REF of its first argument, so apply the
3099 same transformation as in the INDIRECT_REF case above. */
3105 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
3106 This may be more efficient, but will also allow us to more easily find
3107 the match for the PLACEHOLDER_EXPR. */
3113 /* If this is a fat pointer or a scalar, just make a SAVE_EXPR. Likewise
3114 for a CALL_EXPR as large objects are returned via invisible reference
3115 in most ABIs so the temporary will directly be filled by the callee. */
3121 /* Otherwise reference, protect the address and dereference. */
3122 return
3125 }
3127 /* This is equivalent to stabilize_reference_1 in tree.cc but we take an extra
3128 argument to force evaluation of everything. */
3130 static tree
3132 {
3136 tree result;
3142 {
3149 /* If this is a COMPONENT_REF of a fat pointer, save the entire
3150 fat pointer. This may be more efficient, but will also allow
3151 us to more easily find the match for the PLACEHOLDER_EXPR. */
3154 result
3158 /* If the expression has side-effects, then encase it in a SAVE_EXPR
3159 so that it will only be evaluated once. */
3160 /* The tcc_reference and tcc_comparison classes could be handled as
3161 below, but it is generally faster to only evaluate them once. */
3164 else
3169 /* Recursively stabilize each operand. */
3170 result
3177 /* Recursively stabilize each operand. */
3178 result
3185 }
3187 /* See gnat_rewrite_reference below for the rationale. */
3195 }
3197 /* This is equivalent to stabilize_reference in tree.cc but we know how to
3198 handle our own nodes and we take extra arguments. FORCE says whether to
3199 force evaluation of everything in REF. INIT is set to the first arm of
3200 a COMPOUND_EXPR present in REF, if any. */
3202 tree
3204 {
3205 return
3207 }
3209 /* Rewrite reference REF and call FUNC on each expression within REF in the
3210 process. DATA is passed unmodified to FUNC. INIT is set to the first
3211 arm of a COMPOUND_EXPR present in REF, if any. */
3213 tree
3215 {
3218 tree result;
3221 {
3226 /* No action is needed in this case. */
3229 CASE_CONVERT:
3235 result
3238 init));
3263 result
3266 init),
3274 /* We expect only the pattern built in Call_to_gnu. */
3281 {
3282 /* This can only be an atomic load. */
3285 /* An atomic load is an INDIRECT_REF of its first argument. */
3292 init));
3293 else
3299 }
3308 }
3310 /* TREE_READONLY and TREE_THIS_VOLATILE set on the initial expression may
3311 not be sustained across some paths, such as the one for INDIRECT_REF.
3313 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
3314 paths introduce side-effects where there was none initially (e.g. if a
3315 SAVE_EXPR is built) and we also want to keep track of that. */
3329 }
3331 /* This is equivalent to get_inner_reference in expr.cc but it returns the
3332 ultimate containing object only if the reference (lvalue) is constant,
3333 i.e. if it doesn't depend on the context in which it is evaluated. */
3335 tree
3337 {
3339 {
3341 {
3352 {
3358 }
3368 }
3371 }
3373 done:
3375 }
3377 /* Return true if EXPR is the addition or the subtraction of a constant and,
3378 if so, set *ADD to the addend, *CST to the constant and *MINUS_P to true
3379 if this is a subtraction. */
3381 bool
3383 {
3384 /* Skip overflow checks. */
3393 {
3395 {
3400 }
3402 {
3407 }
3408 }
3410 {
3412 {
3417 }
3418 }
3421 }
3423 /* If EXPR is an expression that is invariant in the current function, in the
3424 sense that it can be evaluated anywhere in the function and any number of
3425 times, return EXPR or an equivalent expression. Otherwise return NULL. */
3427 tree
3429 {
3436 /* Look through temporaries created to capture values. */
3441 {
3443 /* Look into CONSTRUCTORs built to initialize padded types. */
3446 }
3448 /* We are only interested in scalar types at the moment and, even if we may
3449 have gone through padding types in the above loop, we must be back to a
3450 scalar value at this point. */
3457 /* Deal with aligning patterns. */
3460 {
3464 else
3466 }
3468 /* Deal with addition or subtraction of constants. */
3470 {
3473 return
3476 else
3478 }
3484 {
3486 {
3493 {
3499 }
3506 CASE_CONVERT:
3517 }
3520 }
3522 object:
3543 }