| blob | d5dd436d48e5a8091207ba46f40992bdcaf8e88d |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S 2 *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2016, 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 ****************************************************************************/
58 /* Return the base type of TYPE. */
60 tree
62 {
73 }
74 \f
75 /* EXP is a GCC tree representing an address. See if we can find how strictly
76 the object at this address is aligned and, if so, return the alignment of
77 the object in bits. Otherwise return 0. */
79 unsigned int
81 {
86 {
87 CASE_CONVERT:
90 /* Conversions between pointers and integers don't change the alignment
91 of the underlying object. */
96 /* The value of a COMPOUND_EXPR is that of its second operand. */
102 /* If two addresses are added, the alignment of the result is the
103 minimum of the two alignments. */
110 /* If this is the pattern built for aligning types, decode it. */
113 {
115 return
117 }
119 /* If we don't know the alignment of the offset, we assume that
120 of the base. */
126 else
131 /* If there is a choice between two values, use the smaller one. */
138 {
140 /* The first part of this represents the lowest bit in the constant,
141 but it is originally in bytes, not bits. */
143 }
147 /* If we know the alignment of just one side, use it. Otherwise,
148 use the product of the alignments. */
156 else
161 /* A bit-and expression is as aligned as the maximum alignment of the
162 operands. We typically get here for a complex lhs and a constant
163 negative power of two on the rhs to force an explicit alignment, so
164 don't bother looking at the lhs. */
173 {
177 }
179 /* ... fall through ... */
182 /* For other pointer expressions, we assume that the pointed-to object
183 is at least as aligned as the pointed-to type. Beware that we can
184 have a dummy type here (e.g. a Taft Amendment type), for which the
185 alignment is meaningless and should be ignored. */
189 else
192 }
195 }
196 \f
197 /* We have a comparison or assignment operation on two types, T1 and T2, which
198 are either both array types or both record types. T1 is assumed to be for
199 the left hand side operand, and T2 for the right hand side. Return the
200 type that both operands should be converted to for the operation, if any.
201 Otherwise return zero. */
203 static tree
205 {
206 /* ??? As of today, various constructs lead to here with types of different
207 sizes even when both constants (e.g. tagged types, packable vs regular
208 component types, padded vs unpadded types, ...). While some of these
209 would better be handled upstream (types should be made consistent before
210 calling into build_binary_op), some others are really expected and we
211 have to be careful. */
213 /* We must avoid writing more than what the target can hold if this is for
214 an assignment and the case of tagged types is handled in build_binary_op
215 so we use the lhs type if it is known to be smaller or of constant size
216 and the rhs type is not, whatever the modes. We also force t1 in case of
217 constant size equality to minimize occurrences of view conversions on the
218 lhs of an assignment, except for the case of record types with a variant
219 part on the lhs but not on the rhs to make the conversion simpler. */
230 /* Otherwise, if the lhs type is non-BLKmode, use it. Note that we know
231 that we will not have any alignment problems since, if we did, the
232 non-BLKmode type could not have been used. */
236 /* If the rhs type is of constant size, use it whatever the modes. At
237 this point it is known to be smaller, or of constant size and the
238 lhs type is not. */
242 /* Otherwise, if the rhs type is non-BLKmode, use it. */
246 /* In this case, both types have variable size and BLKmode. It's
247 probably best to leave the "type mismatch" because changing it
248 could cause a bad self-referential reference. */
250 }
251 \f
252 /* Return an expression tree representing an equality comparison of A1 and A2,
253 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
255 Two arrays are equal in one of two ways: (1) if both have zero length in
256 some dimension (not necessarily the same dimension) or (2) if the lengths
257 in each dimension are equal and the data is equal. We perform the length
258 tests in as efficient a manner as possible. */
260 static tree
262 {
272 /* If the operands have side-effects, they need to be evaluated only once
273 in spite of the multiple references in the comparison. */
280 /* Process each dimension separately and compare the lengths. If any
281 dimension has a length known to be zero, set LENGTH_ZERO_P to true
282 in order to suppress the comparison of the data at the end. */
284 {
290 size_one_node);
292 size_one_node);
295 /* If the length of the first array is a constant, swap our operands
296 unless the length of the second array is the constant zero. */
298 {
299 tree tem;
310 }
312 /* If the length of the second array is the constant zero, we can just
313 use the original stored bounds for the first array and see whether
314 last < first holds. */
316 {
321 ub1
323 lb1
333 }
335 /* Otherwise, if the length is some other constant value, we know that
336 this dimension in the second array cannot be superflat, so we can
337 just use its length computed from the actual stored bounds. */
339 {
342 ub1
344 lb1
346 /* Note that we know that UB2 and LB2 are constant and hence
347 cannot contain a PLACEHOLDER_EXPR. */
348 ub2
350 lb2
353 comparison
361 this_a1_is_null
365 }
367 /* Otherwise, compare the computed lengths. */
368 else
369 {
373 comparison
376 /* If the length expression is of the form (cond ? val : 0), assume
377 that cond is equivalent to (length != 0). That's guaranteed by
378 construction of the array types in gnat_to_gnu_entity. */
381 this_a1_is_null
383 else
387 /* Likewise for the second array. */
390 this_a2_is_null
392 else
395 }
397 /* Append expressions for this dimension to the final expressions. */
409 }
411 /* Unless the length of some dimension is known to be zero, compare the
412 data in the array. */
414 {
416 tree comparison;
419 {
422 }
426 result
428 }
430 /* The result is also true if both sizes are zero. */
434 result);
436 /* If the operands have side-effects, they need to be evaluated before
437 doing the tests above since the place they otherwise would end up
438 being evaluated at run time could be wrong. */
446 }
448 /* Return an expression tree representing an equality comparison of P1 and P2,
449 two objects of fat pointer type. The result should be of type RESULT_TYPE.
451 Two fat pointers are equal in one of two ways: (1) if both have a null
452 pointer to the array or (2) if they contain the same couple of pointers.
453 We perform the comparison in as efficient a manner as possible. */
455 static tree
457 {
461 /* If either operand has side-effects, they have to be evaluated only once
462 in spite of the multiple references to the operand in the comparison. */
466 /* The constant folder doesn't fold fat pointer types so we do it here. */
469 else
472 p1_array_is_null
475 null_pointer_node));
479 else
482 p2_array_is_null
485 null_pointer_node));
487 /* If one of the pointers to the array is null, just compare the other. */
493 /* Otherwise, do the fully-fledged comparison. */
494 same_array
499 else
500 p1_bounds
506 else
507 p2_bounds
511 same_bounds
514 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
518 }
519 \f
520 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
521 type TYPE. We know that TYPE is a modular type with a nonbinary
522 modulus. */
524 static tree
526 tree rhs)
527 {
533 tree result;
535 /* If this is an addition of a constant, convert it to a subtraction
536 of a constant since we can do that faster. */
538 {
541 }
543 /* For the logical operations, we only need PRECISION bits. For
544 addition and subtraction, we need one more and for multiplication we
545 need twice as many. But we never want to make a size smaller than
546 our size. */
554 /* Unsigned will do for everything but subtraction. */
558 /* If our type is the wrong signedness or isn't wide enough, make a new
559 type and convert both our operands to it. */
562 {
563 /* Copy the type so we ensure it can be modified to make it modular. */
570 }
572 /* Do the operation, then we'll fix it up. */
575 /* For multiplication, we have no choice but to do a full modulus
576 operation. However, we want to do this in the narrowest
577 possible size. */
579 {
580 /* Copy the type so we ensure it can be modified to make it modular. */
588 }
590 /* For subtraction, add the modulus back if we are negative. */
592 {
598 result);
599 }
601 /* For the other operations, subtract the modulus if we are >= it. */
602 else
603 {
610 result);
611 }
614 }
615 \f
616 /* This page contains routines that implement the Ada semantics with regard
617 to atomic objects. They are fully piggybacked on the middle-end support
618 for atomic loads and stores.
620 *** Memory barriers and volatile objects ***
622 We implement the weakened form of the C.6(16) clause that was introduced
623 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
624 implementable without significant performance hits on modern platforms.
626 We also take advantage of the requirements imposed on shared variables by
627 9.10 (conditions for sequential actions) to have non-erroneous execution
628 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
629 volatile updates with regard to sequential actions, i.e. with regard to
630 reads or updates of atomic objects.
632 As such, an update of an atomic object by a task requires that all earlier
633 accesses to volatile objects have completed. Similarly, later accesses to
634 volatile objects cannot be reordered before the update of the atomic object.
635 So, memory barriers both before and after the atomic update are needed.
637 For a read of an atomic object, to avoid seeing writes of volatile objects
638 by a task earlier than by the other tasks, a memory barrier is needed before
639 the atomic read. Finally, to avoid reordering later reads or updates of
640 volatile objects to before the atomic read, a barrier is needed after the
641 atomic read.
643 So, memory barriers are needed before and after atomic reads and updates.
644 And, in order to simplify the implementation, we use full memory barriers
645 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
647 /* Return the size of TYPE, which must be a positive power of 2. */
649 static unsigned int
651 {
657 /* We shouldn't reach here without having already detected that the size
658 isn't compatible with an atomic access. */
662 }
664 /* Build an atomic load for the underlying atomic object in SRC. SYNC is
665 true if the load requires synchronization. */
667 tree
669 {
670 tree ptr_type
671 = build_pointer_type
674 tree mem_model
682 /* Remove conversions to get the address of the underlying object. */
694 /* First reinterpret the loaded bits in the original type of the load,
695 then convert to the expected result type. */
698 }
700 /* Build an atomic store from SRC to the underlying atomic object in DEST.
701 SYNC is true if the store requires synchronization. */
703 tree
705 {
706 tree ptr_type
707 = build_pointer_type
710 tree mem_model
718 /* Remove conversions to get the address of the underlying object. */
728 /* First convert the bits to be stored to the original type of the store,
729 then reinterpret them in the effective type. But if the original type
730 is a padded type with the same size, convert to the inner type instead,
731 as we don't want to artificially introduce a CONSTRUCTOR here. */
736 else
742 }
744 /* Build a load-modify-store sequence from SRC to DEST. GNAT_NODE is used for
745 the location of the sequence. Note that, even though the load and the store
746 are both atomic, the sequence itself is not atomic. */
748 tree
750 {
751 /* We will be modifying DEST below so we build a copy. */
756 {
757 /* The load should already have been generated during the translation
758 of the GNAT destination tree; find it out in the GNU tree. */
760 {
763 {
768 /* Find out the loaded object. */
773 else
776 /* Drop atomic and volatile qualifiers for the temporary. */
779 /* And drop BLKmode, if need be, to put it into a register. */
781 {
785 }
787 /* Create the temporary by inserting a SAVE_EXPR. */
794 /* Build the modify of the temporary. */
798 /* Build the store to the object. */
803 }
804 }
808 }
810 /* Something went wrong earlier if we have not found the atomic load. */
812 }
813 \f
814 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
815 desired for the result. Usually the operation is to be performed
816 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
817 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
818 case the type to be used will be derived from the operands.
820 This function is very much unlike the ones for C and C++ since we
821 have already done any type conversion and matching required. All we
822 have to do here is validate the work done by SEM and handle subtypes. */
824 tree
827 {
847 modulus = (operation_type
853 {
858 /* If there were integral or pointer conversions on the LHS, remove
859 them; we'll be putting them back below if needed. Likewise for
860 conversions between array and record types, except for justified
861 modular types. But don't do this if the right operand is not
862 BLKmode (for packed arrays) unless we are not changing the mode. */
883 (TREE_OPERAND
885 {
888 }
890 /* If a class-wide type may be involved, force use of the RHS type. */
896 /* If we are copying between padded objects with compatible types, use
897 the padded view of the objects, this is very likely more efficient.
898 Likewise for a padded object that is assigned a constructor, if we
899 can convert the constructor to the inner type, to avoid putting a
900 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
901 actually copied anything. */
906 == TYPE_MAIN_VARIANT
909 && !CONTAINS_PLACEHOLDER_P
912 {
913 /* We make an exception for a BLKmode type padding a non-BLKmode
914 inner type and do the conversion of the LHS right away, since
915 unchecked_convert wouldn't do it properly. */
919 {
923 }
924 else
926 }
928 /* If we have a call to a function that returns with variable size, use
929 the RHS type in case we want to use the return slot optimization. */
934 /* Find the best type to use for copying between aggregate types. */
942 /* Otherwise use the LHS type. */
943 else
946 /* Ensure everything on the LHS is valid. If we have a field reference,
947 strip anything that get_inner_reference can handle. Then remove any
948 conversions between types having the same code and mode. And mark
949 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
950 either an INDIRECT_REF, a NULL_EXPR, a SAVE_EXPR or a DECL node. */
953 {
973 {
976 }
977 else
979 }
986 /* Convert the right operand to the operation type unless it is
987 either already of the correct type or if the type involves a
988 placeholder, since the RHS may not have the same record type. */
991 {
994 }
996 /* If the left operand is not of the same type as the operation
997 type, wrap it up in a VIEW_CONVERT_EXPR. */
1009 /* ... fall through ... */
1012 /* First look through conversion between type variants. Note that
1013 this changes neither the operation type nor the type domain. */
1017 {
1020 }
1022 /* For a range, make sure the element type is consistent. */
1028 /* Then convert the right operand to its base type. This will prevent
1029 unneeded sign conversions when sizetype is wider than integer. */
1040 gcc_checking_assert
1053 gcc_checking_assert
1055 /* If either operand is a NULL_EXPR, just return a new one. */
1060 integer_zero_node);
1066 integer_zero_node);
1068 /* If either object is a justified modular types, get the
1069 fields from within. */
1072 {
1074 left_operand);
1077 }
1081 {
1083 right_operand);
1086 }
1088 /* If both objects are arrays, compare them specially. */
1095 {
1100 else
1104 }
1106 /* Otherwise, the base types must be the same, unless they are both fat
1107 pointer types or record types. In the latter case, use the best type
1108 and convert both operands to that type. */
1110 {
1113 {
1117 }
1121 {
1122 /* The only way this is permitted is if both types have the same
1123 name. In that case, one of them must not be self-referential.
1124 Use it as the best type. Even better with a fixed size. */
1137 else
1139 }
1143 {
1147 }
1148 else
1153 }
1154 else
1155 {
1158 }
1160 /* If both objects are fat pointers, compare them specially. */
1162 {
1163 result
1168 else
1172 }
1181 /* The RHS of a shift can be any type. Also, ignore any modulus
1182 (we used to abort, but this is needed for unchecked conversion
1183 to modular types). Otherwise, processing is the same as normal. */
1192 /* For binary modulus, if the inputs are in range, so are the
1193 outputs. */
1209 /* These always produce results lower than either operand. */
1224 else
1228 /* ... fall through ... */
1232 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1233 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1234 these types but can generate addition/subtraction for Succ/Pred. */
1242 /* ... fall through ... */
1245 common:
1246 /* The result type should be the same as the base types of the
1247 both operands (and they should be the same). Convert
1248 everything to the result type. */
1254 }
1257 {
1261 }
1262 /* If either operand is a NULL_EXPR, just return a new one. */
1272 else
1273 result
1277 ;
1279 {
1282 }
1283 else
1289 /* If we are working with modular types, perform the MOD operation
1290 if something above hasn't eliminated the need for it. */
1299 }
1300 \f
1301 /* Similar, but for unary operations. */
1303 tree
1305 {
1309 tree result;
1322 {
1327 else
1334 gcc_checking_assert
1337 /* When not optimizing, fold the result as invert_truthvalue_loc
1338 doesn't fold the result of comparisons. This is intended to undo
1339 the trick used for boolean rvalues in gnat_to_gnu. */
1347 {
1352 /* Make sure the type here is a pointer, not a reference.
1353 GCC wants pointer types for function addresses. */
1357 /* If the underlying object can alias everything, propagate the
1358 property since we are effectively retrieving the object. */
1361 {
1364 result_type
1370 result_type
1374 }
1383 /* Fold a compound expression if it has unconstrained array type
1384 since the middle-end cannot handle it. But we don't it in the
1385 general case because it may introduce aliasing issues if the
1386 first operand is an indirect assignment and the second operand
1387 the corresponding address, e.g. for an allocator. However do
1388 it for a return value to expose it for later recognition. */
1392 {
1398 }
1405 /* If this is for 'Address, find the address of the prefix and add
1406 the offset to the field. Otherwise, do this the normal way. */
1408 {
1409 HOST_WIDE_INT bitsize;
1410 HOST_WIDE_INT bitpos;
1412 machine_mode mode;
1419 /* If INNER is a padding type whose field has a self-referential
1420 size, convert to that inner type. We know the offset is zero
1421 and we need to have that type visible. */
1424 inner);
1426 /* Compute the offset as a byte offset from INNER. */
1433 /* Take the address of INNER, convert it to a pointer to our type
1434 and add the offset. */
1437 inner);
1441 }
1445 /* If this is just a constructor for a padded record, we can
1446 just take the address of the single field and convert it to
1447 a pointer to our type. */
1449 {
1450 result
1455 }
1464 /* ... fallthru ... */
1467 /* If this just a variant conversion or if the conversion doesn't
1468 change the mode, get the result type from this type and go down.
1469 This is needed for conversions of CONST_DECLs, to eventually get
1470 to the address of their CORRESPONDING_VARs. */
1485 /* ... fall through ... */
1488 common:
1490 /* If we are taking the address of a padded record whose field
1491 contains a template, take the address of the field. */
1495 {
1498 }
1502 }
1508 {
1512 /* If TYPE is a thin pointer, either first retrieve the base if this
1513 is an expression with an offset built for the initialization of an
1514 object with an unconstrained nominal subtype, or else convert to
1515 the fat pointer. */
1517 {
1524 {
1527 }
1529 {
1530 operand
1532 operand);
1534 }
1535 }
1537 /* If we want to refer to an unconstrained array, use the appropriate
1538 expression. But this will never survive down to the back-end. */
1540 {
1545 }
1547 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1551 /* Otherwise, build and fold the indirect reference. */
1552 else
1553 {
1556 }
1559 {
1563 }
1571 }
1575 {
1576 tree modulus = ((operation_type
1582 /* If this is a modular type, there are various possibilities
1583 depending on the operation and whether the modulus is a
1584 power of two or not. */
1587 {
1591 /* The fastest in the negate case for binary modulus is
1592 the straightforward code; the TRUNC_MOD_EXPR below
1593 is an AND operation. */
1597 operand),
1598 modulus);
1600 /* For nonbinary negate case, return zero for zero operand,
1601 else return the modulus minus the operand. If the modulus
1602 is a power of two minus one, we can do the subtraction
1603 as an XOR since it is equivalent and faster on most machines. */
1605 {
1607 modulus,
1612 else
1618 boolean_type_node,
1619 operand,
1620 build_int_cst
1623 }
1624 else
1625 {
1626 /* For the NOT cases, we need a constant equal to
1627 the modulus minus one. For a binary modulus, we
1628 XOR against the constant and subtract the operand from
1629 that constant for nonbinary modulus. */
1637 else
1640 }
1643 }
1644 }
1646 /* ... fall through ... */
1652 }
1658 }
1659 \f
1660 /* Similar, but for COND_EXPR. */
1662 tree
1665 {
1667 tree result;
1669 /* The front-end verified that result, true and false operands have
1670 same base type. Convert everything to the result type. */
1674 /* If the result type is unconstrained, take the address of the operands and
1675 then dereference the result. Likewise if the result type is passed by
1676 reference, because creating a temporary of this type is not allowed. */
1680 {
1685 }
1690 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1691 in both arms, make sure it gets evaluated by moving it ahead of the
1692 conditional expression. This is necessary because it is evaluated
1693 in only one place at run time and would otherwise be uninitialized
1694 in one of the arms. */
1705 }
1707 /* Similar, but for COMPOUND_EXPR. */
1709 tree
1711 {
1713 tree result;
1715 /* If the result type is unconstrained, take the address of the operand and
1716 then dereference the result. Likewise if the result type is passed by
1717 reference, but this is natively handled in the gimplifier. */
1720 {
1724 }
1727 expr_operand);
1733 }
1734 \f
1735 /* Conveniently construct a function call expression. FNDECL names the
1736 function to be called, N is the number of arguments, and the "..."
1737 parameters are the argument expressions. Unlike build_call_expr
1738 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1740 tree
1742 {
1751 }
1752 \f
1753 /* Build a goto to LABEL for a raise, with an optional call to Local_Raise.
1754 MSG gives the exception's identity for the call to Local_Raise, if any. */
1756 static tree
1758 {
1762 /* If Local_Raise is present, build Local_Raise (Exception'Identity). */
1764 {
1765 tree gnu_local_raise
1767 tree gnu_exception_entity
1769 tree gnu_call
1772 gnu_exception_entity));
1773 gnu_result
1775 }
1778 }
1780 /* Expand the SLOC of GNAT_NODE, if present, into tree location information
1781 pointed to by FILENAME, LINE and COL. Fall back to the current location
1782 if GNAT_NODE is absent or has no SLOC. */
1784 static void
1786 {
1791 {
1795 }
1797 {
1798 str = Get_Name_String
1802 }
1803 else
1804 {
1808 }
1817 }
1819 /* Build a call to a function that raises an exception and passes file name
1820 and line number, if requested. MSG says which exception function to call.
1821 GNAT_NODE is the node conveying the source location for which the error
1822 should be signaled, or Empty in which case the error is signaled for the
1823 current location. KIND says which kind of exception node this is for,
1824 among N_Raise_{Constraint,Storage,Program}_Error. */
1826 tree
1828 {
1833 /* If this is to be done as a goto, handle that case. */
1839 return
1843 filename),
1844 line);
1845 }
1847 /* Similar to build_call_raise, with extra information about the column
1848 where the check failed. */
1850 tree
1852 {
1857 /* If this is to be done as a goto, handle that case. */
1863 return
1867 filename),
1869 }
1871 /* Similar to build_call_raise_column, for an index or range check exception ,
1872 with extra information of the form "INDEX out of range FIRST..LAST". */
1874 tree
1877 {
1882 /* If this is to be done as a goto, handle that case. */
1888 return
1892 filename),
1897 }
1898 \f
1899 /* qsort comparer for the bit positions of two constructor elements
1900 for record components. */
1902 static int
1904 {
1909 const int ret
1913 }
1915 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
1917 tree
1919 {
1926 /* Scan the elements to see if they are all constant or if any has side
1927 effects, to let us set global flags on the resulting constructor. Count
1928 the elements along the way for possible sorting purposes below. */
1930 {
1931 /* The predicate must be in keeping with output_constructor. */
1946 }
1948 /* For record types with constant components only, sort field list
1949 by increasing bit position. This is necessary to ensure the
1950 constructor can be output as static data. */
1960 }
1961 \f
1962 /* Return a COMPONENT_REF to access FIELD in RECORD, or NULL_TREE if the field
1963 is not found in the record. Don't fold the result if NO_FOLD is true. */
1965 static tree
1967 {
1969 tree ref;
1973 /* Try to fold a conversion from another record or union type unless the type
1974 contains a placeholder as it might be needed for a later substitution. */
1978 {
1981 /* If this is an unpadding operation, convert the underlying object to
1982 the unpadded type directly. */
1986 /* Otherwise try to access FIELD directly in the underlying type, but
1987 make sure that the form of the reference doesn't change too much;
1988 this can happen for an unconstrained bit-packed array type whose
1989 constrained form can be an integer type. */
1993 }
1995 /* If this field is not in the specified record, see if we can find a field
1996 in the specified record whose original field is the same as this one. */
1998 {
1999 tree new_field;
2001 /* First loop through normal components. */
2003 new_field;
2008 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
2009 component in the first search. Doing this search in two steps is
2010 required to avoid hidden homonymous fields in the _Parent field. */
2013 new_field;
2017 {
2018 tree field_ref
2023 }
2026 }
2031 /* If the field's offset has overflowed, do not try to access it, as doing
2032 so may trigger sanity checks deeper in the back-end. Note that we don't
2033 need to warn since this will be done on trying to declare the object. */
2053 /* The generic folder may punt in this case because the inner array type
2054 can be self-referential, but folding is in fact not problematic. */
2057 {
2065 }
2068 }
2070 /* Likewise, but return NULL_EXPR and generate a Constraint_Error if the
2071 field is not found in the record. */
2073 tree
2075 {
2080 /* Assume this is an invalid user field so raise Constraint_Error. */
2083 N_Raise_Constraint_Error));
2084 }
2085 \f
2086 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2087 identically. Process the case where a GNAT_PROC to call is provided. */
2092 {
2094 tree gnu_call;
2096 /* A storage pool's underlying type is a record type (for both predefined
2097 storage pools and GNAT simple storage pools). The secondary stack uses
2098 the same mechanism, but its pool object (SS_Pool) is an integer. */
2100 {
2101 /* The size is the third parameter; the alignment is the
2102 same type. */
2103 Entity_Id gnat_size_type
2114 /* The first arg is always the address of the storage pool; next
2115 comes the address of the object, for a deallocator, then the
2116 size and alignment. */
2120 else
2123 }
2125 /* Secondary stack case. */
2126 else
2127 {
2128 /* The size is the second parameter. */
2129 Entity_Id gnat_size_type
2135 /* The first arg is the address of the object, for a deallocator,
2136 then the size. */
2139 else
2141 }
2144 }
2146 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2147 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2148 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2149 latter offers. */
2153 {
2154 /* When the DATA_TYPE alignment is stricter than what malloc offers
2155 (super-aligned case), we allocate an "aligning" wrapper type and return
2156 the address of its single data field with the malloc's return value
2157 stored just in front. */
2160 unsigned int system_allocator_alignment
2163 tree aligning_type
2166 system_allocator_alignment,
2168 gnat_node)
2171 tree size_to_malloc
2177 {
2178 /* Latch malloc's return value and get a pointer to the aligning field
2179 first. */
2182 tree aligning_record_addr
2185 tree aligning_record
2188 tree aligning_field
2192 tree aligning_field_addr
2195 /* Then arrange to store the allocator's return value ahead
2196 and return. */
2197 tree storage_ptr_slot_addr
2203 tree storage_ptr_slot
2206 storage_ptr_slot_addr));
2208 return
2212 aligning_field_addr);
2213 }
2214 else
2216 }
2218 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2219 designated by DATA_PTR using the __gnat_free entry point. */
2223 {
2224 /* In the regular alignment case, we pass the data pointer straight to free.
2225 In the superaligned case, we need to retrieve the initial allocator
2226 return value, stored in front of the data block at allocation time. */
2229 unsigned int system_allocator_alignment
2232 tree free_ptr;
2235 {
2236 /* DATA_FRONT_PTR (void *)
2237 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2238 tree data_front_ptr
2239 = build_binary_op
2244 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2245 free_ptr
2246 = build_unary_op
2249 }
2250 else
2254 }
2256 /* Build a GCC tree to call an allocation or deallocation function.
2257 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2258 generate an allocator.
2260 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2261 object type, used to determine the to-be-honored address alignment.
2262 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2263 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2264 to provide an error location for restriction violation messages. */
2266 tree
2269 Node_Id gnat_node)
2270 {
2273 /* Explicit proc to call ? This one is assumed to deal with the type
2274 alignment constraints. */
2279 /* Otherwise, object to "free" or "malloc" with possible special processing
2280 for alignments stricter than what the default allocator honors. */
2283 else
2284 {
2285 /* Assert that we no longer can be called with this special pool. */
2288 /* Check that we aren't violating the associated restriction. */
2290 {
2296 }
2298 }
2299 }
2300 \f
2301 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2302 initial value is INIT, if INIT is nonzero. Convert the expression to
2303 RESULT_TYPE, which must be some pointer type, and return the result.
2305 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2306 the storage pool to use. GNAT_NODE is used to provide an error
2307 location for restriction violation messages. If IGNORE_INIT_TYPE is
2308 true, ignore the type of INIT for the purpose of determining the size;
2309 this will cause the maximum size to be allocated if TYPE is of
2310 self-referential size. */
2312 tree
2315 {
2318 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2322 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2327 ignore_init_type),
2330 ignore_init_type));
2332 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2333 sizes of the object and its template. Allocate the whole thing and
2334 fill in the parts that are known. */
2336 {
2337 tree storage_type
2344 init);
2346 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2356 /* If there is an initializing expression, then make a constructor for
2357 the entire object including the bounds and copy it into the object.
2358 If there is no initializing expression, just set the bounds. */
2360 {
2367 init);
2368 storage_init
2371 }
2372 else
2373 storage_init
2382 }
2386 /* If we have an initializing expression, see if its size is simpler
2387 than the size from the type. */
2393 /* If the size is still self-referential, reference the initializing
2394 expression, if it is present. If not, this must have been a
2395 call to allocate a library-level object, in which case we use
2396 the maximum size. */
2398 {
2401 else
2403 }
2405 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2412 gnat_node));
2414 /* If we have an initial value, protect the new address, assign the value
2415 and return the address with a COMPOUND_EXPR. */
2417 {
2421 storage_init
2424 }
2427 }
2428 \f
2429 /* Indicate that we need to take the address of T and that it therefore
2430 should not be allocated in a register. Return true if successful. */
2432 bool
2434 {
2437 {
2446 CASE_CONVERT:
2474 }
2475 }
2476 \f
2477 /* Return true if EXP is a stable expression for the purpose of the functions
2478 below and, therefore, can be returned unmodified by them. We accept things
2479 that are actual constants or that have already been handled. */
2481 static bool
2483 {
2486 }
2488 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
2489 but we know how to handle our own nodes. */
2491 tree
2493 {
2501 {
2505 }
2507 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2508 This may be more efficient, but will also allow us to more easily find
2509 the match for the PLACEHOLDER_EXPR. */
2516 }
2518 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
2519 is optimized under the assumption that EXP's value doesn't change before
2520 its subsequent reuse(s) except through its potential reevaluation. */
2522 tree
2524 {
2531 /* If EXP has no side effects, we theoretically don't need to do anything.
2532 However, we may be recursively passed more and more complex expressions
2533 involving checks which will be reused multiple times and eventually be
2534 unshared for gimplification; in order to avoid a complexity explosion
2535 at that point, we protect any expressions more complex than a simple
2536 arithmetic expression. */
2538 {
2542 }
2544 /* If this is a conversion, protect what's inside the conversion. */
2550 /* If we're indirectly referencing something, we only need to protect the
2551 address since the data itself can't change in these situations. */
2553 {
2557 }
2559 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2560 This may be more efficient, but will also allow us to more easily find
2561 the match for the PLACEHOLDER_EXPR. */
2567 /* If this is a fat pointer or a scalar, just make a SAVE_EXPR. Likewise
2568 for a CALL_EXPR as large objects are returned via invisible reference
2569 in most ABIs so the temporary will directly be filled by the callee. */
2575 /* Otherwise reference, protect the address and dereference. */
2576 return
2580 exp)));
2581 }
2583 /* This is equivalent to stabilize_reference_1 in tree.c but we take an extra
2584 argument to force evaluation of everything. */
2586 static tree
2588 {
2592 tree result;
2598 {
2605 /* If this is a COMPONENT_REF of a fat pointer, save the entire
2606 fat pointer. This may be more efficient, but will also allow
2607 us to more easily find the match for the PLACEHOLDER_EXPR. */
2610 result
2614 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2615 so that it will only be evaluated once. */
2616 /* The tcc_reference and tcc_comparison classes could be handled as
2617 below, but it is generally faster to only evaluate them once. */
2620 else
2625 /* Recursively stabilize each operand. */
2626 result
2633 /* Recursively stabilize each operand. */
2634 result
2641 }
2648 }
2650 /* This is equivalent to stabilize_reference in tree.c but we know how to
2651 handle our own nodes and we take extra arguments. FORCE says whether to
2652 force evaluation of everything in REF. INIT is set to the first arm of
2653 a COMPOUND_EXPR present in REF, if any. */
2655 tree
2657 {
2658 return
2660 }
2662 /* Rewrite reference REF and call FUNC on each expression within REF in the
2663 process. DATA is passed unmodified to FUNC. INIT is set to the first
2664 arm of a COMPOUND_EXPR present in REF, if any. */
2666 tree
2668 {
2671 tree result;
2674 {
2679 /* No action is needed in this case. */
2682 CASE_CONVERT:
2688 result
2691 init));
2716 result
2719 init),
2727 /* We expect only the pattern built in Call_to_gnu. */
2734 {
2735 /* This can only be an atomic load. */
2738 /* An atomic load is an INDIRECT_REF of its first argument. */
2745 init));
2746 else
2752 }
2761 }
2763 /* TREE_THIS_VOLATILE and TREE_SIDE_EFFECTS set on the initial expression
2764 may not be sustained across some paths, such as the way via build1 for
2765 INDIRECT_REF. We reset those flags here in the general case, which is
2766 consistent with the GCC version of this routine.
2768 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
2769 paths introduce side-effects where there was none initially (e.g. if a
2770 SAVE_EXPR is built) and we also want to keep track of that. */
2782 }
2784 /* This is equivalent to get_inner_reference in expr.c but it returns the
2785 ultimate containing object only if the reference (lvalue) is constant,
2786 i.e. if it doesn't depend on the context in which it is evaluated. */
2788 tree
2790 {
2792 {
2794 {
2808 {
2817 }
2827 }
2830 }
2832 done:
2834 }
2836 /* Return true if EXPR is the addition or the subtraction of a constant and,
2837 if so, set *ADD to the addend, *CST to the constant and *MINUS_P to true
2838 if this is a subtraction. */
2840 bool
2842 {
2843 /* Skip overflow checks. */
2852 {
2854 {
2859 }
2861 {
2866 }
2867 }
2869 {
2871 {
2876 }
2877 }
2880 }
2882 /* If EXPR is an expression that is invariant in the current function, in the
2883 sense that it can be evaluated anywhere in the function and any number of
2884 times, return EXPR or an equivalent expression. Otherwise return NULL. */
2886 tree
2888 {
2895 /* Look through temporaries created to capture values. */
2900 {
2902 /* Look into CONSTRUCTORs built to initialize padded types. */
2906 }
2908 /* We are only interested in scalar types at the moment and, even if we may
2909 have gone through padding types in the above loop, we must be back to a
2910 scalar value at this point. */
2917 /* Deal with addition or subtraction of constants. */
2919 {
2922 return
2925 else
2927 }
2933 {
2935 {
2954 CASE_CONVERT:
2965 }
2968 }
2970 object:
2991 }