| blob | 1296a4996119801f11518dc333b4ece126369769 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S 2 *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2014, 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 ****************************************************************************/
54 /* Return the base type of TYPE. */
56 tree
58 {
69 }
70 \f
71 /* EXP is a GCC tree representing an address. See if we can find how
72 strictly the object at that address is aligned. Return that alignment
73 in bits. If we don't know anything about the alignment, return 0. */
75 unsigned int
77 {
82 {
83 CASE_CONVERT:
86 /* Conversions between pointers and integers don't change the alignment
87 of the underlying object. */
92 /* The value of a COMPOUND_EXPR is that of it's second operand. */
98 /* If two address are added, the alignment of the result is the
99 minimum of the two alignments. */
108 /* If we don't know the alignment of the offset, we assume that
109 of the base. */
112 else
117 /* If there is a choice between two values, use the smallest one. */
124 {
126 /* The first part of this represents the lowest bit in the constant,
127 but it is originally in bytes, not bits. */
129 }
133 /* If we know the alignment of just one side, use it. Otherwise,
134 use the product of the alignments. */
142 else
147 /* A bit-and expression is as aligned as the maximum alignment of the
148 operands. We typically get here for a complex lhs and a constant
149 negative power of two on the rhs to force an explicit alignment, so
150 don't bother looking at the lhs. */
159 {
163 }
165 /* Fall through... */
168 /* For other pointer expressions, we assume that the pointed-to object
169 is at least as aligned as the pointed-to type. Beware that we can
170 have a dummy type here (e.g. a Taft Amendment type), for which the
171 alignment is meaningless and should be ignored. */
175 else
178 }
181 }
182 \f
183 /* We have a comparison or assignment operation on two types, T1 and T2, which
184 are either both array types or both record types. T1 is assumed to be for
185 the left hand side operand, and T2 for the right hand side. Return the
186 type that both operands should be converted to for the operation, if any.
187 Otherwise return zero. */
189 static tree
191 {
192 /* ??? As of today, various constructs lead to here with types of different
193 sizes even when both constants (e.g. tagged types, packable vs regular
194 component types, padded vs unpadded types, ...). While some of these
195 would better be handled upstream (types should be made consistent before
196 calling into build_binary_op), some others are really expected and we
197 have to be careful. */
199 /* We must avoid writing more than what the target can hold if this is for
200 an assignment and the case of tagged types is handled in build_binary_op
201 so we use the lhs type if it is known to be smaller or of constant size
202 and the rhs type is not, whatever the modes. We also force t1 in case of
203 constant size equality to minimize occurrences of view conversions on the
204 lhs of an assignment, except for the case of record types with a variant
205 part on the lhs but not on the rhs to make the conversion simpler. */
216 /* Otherwise, if the lhs type is non-BLKmode, use it. Note that we know
217 that we will not have any alignment problems since, if we did, the
218 non-BLKmode type could not have been used. */
222 /* If the rhs type is of constant size, use it whatever the modes. At
223 this point it is known to be smaller, or of constant size and the
224 lhs type is not. */
228 /* Otherwise, if the rhs type is non-BLKmode, use it. */
232 /* In this case, both types have variable size and BLKmode. It's
233 probably best to leave the "type mismatch" because changing it
234 could cause a bad self-referential reference. */
236 }
237 \f
238 /* Return an expression tree representing an equality comparison of A1 and A2,
239 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
241 Two arrays are equal in one of two ways: (1) if both have zero length in
242 some dimension (not necessarily the same dimension) or (2) if the lengths
243 in each dimension are equal and the data is equal. We perform the length
244 tests in as efficient a manner as possible. */
246 static tree
248 {
258 /* If either operand has side-effects, they have to be evaluated only once
259 in spite of the multiple references to the operand in the comparison. */
266 /* Process each dimension separately and compare the lengths. If any
267 dimension has a length known to be zero, set LENGTH_ZERO_P to true
268 in order to suppress the comparison of the data at the end. */
270 {
276 size_one_node);
278 size_one_node);
281 /* If the length of the first array is a constant, swap our operands
282 unless the length of the second array is the constant zero. */
284 {
285 tree tem;
296 }
298 /* If the length of the second array is the constant zero, we can just
299 use the original stored bounds for the first array and see whether
300 last < first holds. */
302 {
307 ub1
309 lb1
319 }
321 /* Otherwise, if the length is some other constant value, we know that
322 this dimension in the second array cannot be superflat, so we can
323 just use its length computed from the actual stored bounds. */
325 {
328 ub1
330 lb1
332 /* Note that we know that UB2 and LB2 are constant and hence
333 cannot contain a PLACEHOLDER_EXPR. */
334 ub2
336 lb2
339 comparison
347 this_a1_is_null
351 }
353 /* Otherwise, compare the computed lengths. */
354 else
355 {
359 comparison
362 /* If the length expression is of the form (cond ? val : 0), assume
363 that cond is equivalent to (length != 0). That's guaranteed by
364 construction of the array types in gnat_to_gnu_entity. */
367 this_a1_is_null
369 else
373 /* Likewise for the second array. */
376 this_a2_is_null
378 else
381 }
383 /* Append expressions for this dimension to the final expressions. */
395 }
397 /* Unless the length of some dimension is known to be zero, compare the
398 data in the array. */
400 {
402 tree comparison;
405 {
408 }
412 result
414 }
416 /* The result is also true if both sizes are zero. */
420 result);
422 /* If either operand has side-effects, they have to be evaluated before
423 starting the comparison above since the place they would be otherwise
424 evaluated could be wrong. */
432 }
434 /* Return an expression tree representing an equality comparison of P1 and P2,
435 two objects of fat pointer type. The result should be of type RESULT_TYPE.
437 Two fat pointers are equal in one of two ways: (1) if both have a null
438 pointer to the array or (2) if they contain the same couple of pointers.
439 We perform the comparison in as efficient a manner as possible. */
441 static tree
443 {
447 /* If either operand has side-effects, they have to be evaluated only once
448 in spite of the multiple references to the operand in the comparison. */
452 /* The constant folder doesn't fold fat pointer types so we do it here. */
455 else
459 p1_array_is_null
462 null_pointer_node));
466 else
470 p2_array_is_null
473 null_pointer_node));
475 /* If one of the pointers to the array is null, just compare the other. */
481 /* Otherwise, do the fully-fledged comparison. */
482 same_array
487 else
488 p1_bounds
494 else
495 p2_bounds
499 same_bounds
502 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
506 }
507 \f
508 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
509 type TYPE. We know that TYPE is a modular type with a nonbinary
510 modulus. */
512 static tree
514 tree rhs)
515 {
521 tree result;
523 /* If this is an addition of a constant, convert it to a subtraction
524 of a constant since we can do that faster. */
526 {
529 }
531 /* For the logical operations, we only need PRECISION bits. For
532 addition and subtraction, we need one more and for multiplication we
533 need twice as many. But we never want to make a size smaller than
534 our size. */
542 /* Unsigned will do for everything but subtraction. */
546 /* If our type is the wrong signedness or isn't wide enough, make a new
547 type and convert both our operands to it. */
550 {
551 /* Copy the node so we ensure it can be modified to make it modular. */
558 }
560 /* Do the operation, then we'll fix it up. */
563 /* For multiplication, we have no choice but to do a full modulus
564 operation. However, we want to do this in the narrowest
565 possible size. */
567 {
575 }
577 /* For subtraction, add the modulus back if we are negative. */
579 {
585 result);
586 }
588 /* For the other operations, subtract the modulus if we are >= it. */
589 else
590 {
597 result);
598 }
601 }
602 \f
603 /* This page contains routines that implement the Ada semantics with regard
604 to atomic objects. They are fully piggybacked on the middle-end support
605 for atomic loads and stores.
607 *** Memory barriers and volatile objects ***
609 We implement the weakened form of the C.6(16) clause that was introduced
610 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
611 implementable without significant performance hits on modern platforms.
613 We also take advantage of the requirements imposed on shared variables by
614 9.10 (conditions for sequential actions) to have non-erroneous execution
615 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
616 volatile updates with regard to sequential actions, i.e. with regard to
617 reads or updates of atomic objects.
619 As such, an update of an atomic object by a task requires that all earlier
620 accesses to volatile objects have completed. Similarly, later accesses to
621 volatile objects cannot be reordered before the update of the atomic object.
622 So, memory barriers both before and after the atomic update are needed.
624 For a read of an atomic object, to avoid seeing writes of volatile objects
625 by a task earlier than by the other tasks, a memory barrier is needed before
626 the atomic read. Finally, to avoid reordering later reads or updates of
627 volatile objects to before the atomic read, a barrier is needed after the
628 atomic read.
630 So, memory barriers are needed before and after atomic reads and updates.
631 And, in order to simplify the implementation, we use full memory barriers
632 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
634 /* Return the size of TYPE, which must be a positive power of 2. */
636 static unsigned int
638 {
644 /* We shouldn't reach here without having already detected that the size
645 isn't compatible with an atomic access. */
649 }
651 /* Build an atomic load for the underlying atomic object in SRC. */
653 tree
655 {
656 tree ptr_type
657 = build_pointer_type
665 /* Remove conversions to get the address of the underlying object. */
677 /* First reinterpret the loaded bits in the original type of the load,
678 then convert to the expected result type. */
681 }
683 /* Build an atomic store from SRC to the underlying atomic object in DEST. */
685 tree
687 {
688 tree ptr_type
689 = build_pointer_type
697 /* Remove conversions to get the address of the underlying object. */
707 /* First convert the bits to be stored to the original type of the store,
708 then reinterpret them in the effective type. But if the original type
709 is a padded type with the same size, convert to the inner type instead,
710 as we don't want to artificially introduce a CONSTRUCTOR here. */
715 else
721 }
722 \f
723 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
724 desired for the result. Usually the operation is to be performed
725 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
726 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
727 case the type to be used will be derived from the operands.
729 This function is very much unlike the ones for C and C++ since we
730 have already done any type conversion and matching required. All we
731 have to do here is validate the work done by SEM and handle subtypes. */
733 tree
736 {
756 modulus = (operation_type
762 {
765 #ifdef ENABLE_CHECKING
767 #endif
768 /* If there were integral or pointer conversions on the LHS, remove
769 them; we'll be putting them back below if needed. Likewise for
770 conversions between array and record types, except for justified
771 modular types. But don't do this if the right operand is not
772 BLKmode (for packed arrays) unless we are not changing the mode. */
793 (TREE_OPERAND
795 {
798 }
800 /* If a class-wide type may be involved, force use of the RHS type. */
806 /* If we are copying between padded objects with compatible types, use
807 the padded view of the objects, this is very likely more efficient.
808 Likewise for a padded object that is assigned a constructor, if we
809 can convert the constructor to the inner type, to avoid putting a
810 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
811 actually copied anything. */
816 == TYPE_MAIN_VARIANT
819 && !CONTAINS_PLACEHOLDER_P
822 {
823 /* We make an exception for a BLKmode type padding a non-BLKmode
824 inner type and do the conversion of the LHS right away, since
825 unchecked_convert wouldn't do it properly. */
829 {
833 }
834 else
836 }
838 /* If we have a call to a function that returns an unconstrained type
839 with default discriminant on the RHS, use the RHS type (which is
840 padded) as we cannot compute the size of the actual assignment. */
843 && CONTAINS_PLACEHOLDER_P
847 /* Find the best type to use for copying between aggregate types. */
855 /* Otherwise use the LHS type. */
856 else
859 /* Ensure everything on the LHS is valid. If we have a field reference,
860 strip anything that get_inner_reference can handle. Then remove any
861 conversions between types having the same code and mode. And mark
862 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
863 either an INDIRECT_REF, a NULL_EXPR or a DECL node. */
866 {
886 {
889 }
890 else
892 }
898 /* Convert the right operand to the operation type unless it is
899 either already of the correct type or if the type involves a
900 placeholder, since the RHS may not have the same record type. */
903 {
906 }
908 /* If the left operand is not of the same type as the operation
909 type, wrap it up in a VIEW_CONVERT_EXPR. */
921 /* ... fall through ... */
924 /* First look through conversion between type variants. Note that
925 this changes neither the operation type nor the type domain. */
929 {
932 }
934 /* For a range, make sure the element type is consistent. */
940 /* Then convert the right operand to its base type. This will prevent
941 unneeded sign conversions when sizetype is wider than integer. */
952 #ifdef ENABLE_CHECKING
954 #endif
966 #ifdef ENABLE_CHECKING
968 #endif
969 /* If either operand is a NULL_EXPR, just return a new one. */
974 integer_zero_node);
980 integer_zero_node);
982 /* If either object is a justified modular types, get the
983 fields from within. */
986 {
988 left_operand);
991 }
995 {
997 right_operand);
1000 }
1002 /* If both objects are arrays, compare them specially. */
1009 {
1014 else
1018 }
1020 /* Otherwise, the base types must be the same, unless they are both fat
1021 pointer types or record types. In the latter case, use the best type
1022 and convert both operands to that type. */
1024 {
1027 {
1031 }
1035 {
1036 /* The only way this is permitted is if both types have the same
1037 name. In that case, one of them must not be self-referential.
1038 Use it as the best type. Even better with a fixed size. */
1051 else
1053 }
1055 else
1060 }
1061 else
1062 {
1065 }
1067 /* If both objects are fat pointers, compare them specially. */
1069 {
1070 result
1075 else
1079 }
1088 /* The RHS of a shift can be any type. Also, ignore any modulus
1089 (we used to abort, but this is needed for unchecked conversion
1090 to modular types). Otherwise, processing is the same as normal. */
1099 /* For binary modulus, if the inputs are in range, so are the
1100 outputs. */
1116 /* These always produce results lower than either operand. */
1131 else
1135 /* ... fall through ... */
1139 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1140 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1141 these types but can generate addition/subtraction for Succ/Pred. */
1149 /* ... fall through ... */
1152 common:
1153 /* The result type should be the same as the base types of the
1154 both operands (and they should be the same). Convert
1155 everything to the result type. */
1161 }
1164 {
1168 }
1169 /* If either operand is a NULL_EXPR, just return a new one. */
1179 else
1180 result
1184 ;
1186 {
1189 }
1190 else
1196 /* If we are working with modular types, perform the MOD operation
1197 if something above hasn't eliminated the need for it. */
1206 }
1207 \f
1208 /* Similar, but for unary operations. */
1210 tree
1212 {
1216 tree result;
1229 {
1234 else
1241 #ifdef ENABLE_CHECKING
1243 #endif
1245 /* When not optimizing, fold the result as invert_truthvalue_loc
1246 doesn't fold the result of comparisons. This is intended to undo
1247 the trick used for boolean rvalues in gnat_to_gnu. */
1255 {
1260 /* Make sure the type here is a pointer, not a reference.
1261 GCC wants pointer types for function addresses. */
1265 /* If the underlying object can alias everything, propagate the
1266 property since we are effectively retrieving the object. */
1269 {
1272 result_type
1278 result_type
1282 }
1291 /* Fold a compound expression if it has unconstrained array type
1292 since the middle-end cannot handle it. But we don't it in the
1293 general case because it may introduce aliasing issues if the
1294 first operand is an indirect assignment and the second operand
1295 the corresponding address, e.g. for an allocator. */
1297 {
1303 }
1310 /* If this is for 'Address, find the address of the prefix and add
1311 the offset to the field. Otherwise, do this the normal way. */
1313 {
1314 HOST_WIDE_INT bitsize;
1315 HOST_WIDE_INT bitpos;
1317 machine_mode mode;
1324 /* If INNER is a padding type whose field has a self-referential
1325 size, convert to that inner type. We know the offset is zero
1326 and we need to have that type visible. */
1328 && CONTAINS_PLACEHOLDER_P
1332 inner);
1334 /* Compute the offset as a byte offset from INNER. */
1341 /* Take the address of INNER, convert the offset to void *, and
1342 add then. It will later be converted to the desired result
1343 type, if any. */
1349 result);
1351 }
1355 /* If this is just a constructor for a padded record, we can
1356 just take the address of the single field and convert it to
1357 a pointer to our type. */
1359 {
1364 }
1374 /* ... fallthru ... */
1377 /* If this just a variant conversion or if the conversion doesn't
1378 change the mode, get the result type from this type and go down.
1379 This is needed for conversions of CONST_DECLs, to eventually get
1380 to the address of their CORRESPONDING_VARs. */
1395 /* ... fall through ... */
1398 common:
1400 /* If we are taking the address of a padded record whose field
1401 contains a template, take the address of the field. */
1405 {
1408 }
1412 }
1418 {
1422 /* If TYPE is a thin pointer, either first retrieve the base if this
1423 is an expression with an offset built for the initialization of an
1424 object with an unconstrained nominal subtype, or else convert to
1425 the fat pointer. */
1427 {
1434 {
1437 }
1439 {
1440 operand
1442 operand);
1444 }
1445 }
1447 /* If we want to refer to an unconstrained array, use the appropriate
1448 expression. But this will never survive down to the back-end. */
1450 {
1455 }
1457 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1461 /* Otherwise, build and fold the indirect reference. */
1462 else
1463 {
1466 }
1469 {
1473 }
1481 }
1485 {
1486 tree modulus = ((operation_type
1492 /* If this is a modular type, there are various possibilities
1493 depending on the operation and whether the modulus is a
1494 power of two or not. */
1497 {
1501 /* The fastest in the negate case for binary modulus is
1502 the straightforward code; the TRUNC_MOD_EXPR below
1503 is an AND operation. */
1507 operand),
1508 modulus);
1510 /* For nonbinary negate case, return zero for zero operand,
1511 else return the modulus minus the operand. If the modulus
1512 is a power of two minus one, we can do the subtraction
1513 as an XOR since it is equivalent and faster on most machines. */
1515 {
1517 modulus,
1519 integer_one_node))))
1522 else
1528 boolean_type_node,
1529 operand,
1530 convert
1532 integer_zero_node)),
1534 }
1535 else
1536 {
1537 /* For the NOT cases, we need a constant equal to
1538 the modulus minus one. For a binary modulus, we
1539 XOR against the constant and subtract the operand from
1540 that constant for nonbinary modulus. */
1544 integer_one_node));
1549 else
1552 }
1555 }
1556 }
1558 /* ... fall through ... */
1564 }
1570 }
1571 \f
1572 /* Similar, but for COND_EXPR. */
1574 tree
1577 {
1579 tree result;
1581 /* The front-end verified that result, true and false operands have
1582 same base type. Convert everything to the result type. */
1586 /* If the result type is unconstrained, take the address of the operands and
1587 then dereference the result. Likewise if the result type is passed by
1588 reference, because creating a temporary of this type is not allowed. */
1592 {
1597 }
1602 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1603 in both arms, make sure it gets evaluated by moving it ahead of the
1604 conditional expression. This is necessary because it is evaluated
1605 in only one place at run time and would otherwise be uninitialized
1606 in one of the arms. */
1617 }
1619 /* Similar, but for COMPOUND_EXPR. */
1621 tree
1623 {
1625 tree result;
1627 /* If the result type is unconstrained, take the address of the operand and
1628 then dereference the result. Likewise if the result type is passed by
1629 reference, but this is natively handled in the gimplifier. */
1632 {
1636 }
1639 expr_operand);
1645 }
1646 \f
1647 /* Conveniently construct a function call expression. FNDECL names the
1648 function to be called, N is the number of arguments, and the "..."
1649 parameters are the argument expressions. Unlike build_call_expr
1650 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1652 tree
1654 {
1663 }
1664 \f
1665 /* Call a function that raises an exception and pass the line number and file
1666 name, if requested. MSG says which exception function to call.
1668 GNAT_NODE is the gnat node conveying the source location for which the
1669 error should be signaled, or Empty in which case the error is signaled on
1670 the current ref_file_name/input_line.
1672 KIND says which kind of exception this is for
1673 (N_Raise_{Constraint,Storage,Program}_Error). */
1675 tree
1677 {
1680 tree filename;
1685 /* If this is to be done as a goto, handle that case. */
1687 {
1691 /* If Local_Raise is present, generate
1692 Local_Raise (exception'Identity); */
1694 {
1695 tree gnu_local_raise
1697 tree gnu_exception_entity
1699 tree gnu_call
1702 gnu_exception_entity));
1708 }
1710 str
1714 ? IDENTIFIER_POINTER
1716 (Debug_Source_Name
1722 line_number
1730 return
1734 filename),
1736 }
1738 /* Similar to build_call_raise, for an index or range check exception as
1739 determined by MSG, with extra information generated of the form
1740 "INDEX out of range FIRST..LAST". */
1742 tree
1745 {
1747 tree filename;
1752 str
1756 ? IDENTIFIER_POINTER
1758 (Debug_Source_Name
1765 {
1768 }
1769 else
1770 {
1773 }
1778 return
1782 filename),
1788 }
1790 /* Similar to build_call_raise, with extra information about the column
1791 where the check failed. */
1793 tree
1795 {
1797 tree filename;
1802 str
1806 ? IDENTIFIER_POINTER
1808 (Debug_Source_Name
1815 {
1818 }
1819 else
1820 {
1823 }
1828 return
1832 filename),
1835 }
1836 \f
1837 /* qsort comparer for the bit positions of two constructor elements
1838 for record components. */
1840 static int
1842 {
1847 const int ret
1851 }
1853 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
1855 tree
1857 {
1864 /* Scan the elements to see if they are all constant or if any has side
1865 effects, to let us set global flags on the resulting constructor. Count
1866 the elements along the way for possible sorting purposes below. */
1868 {
1869 /* The predicate must be in keeping with output_constructor. */
1882 }
1884 /* For record types with constant components only, sort field list
1885 by increasing bit position. This is necessary to ensure the
1886 constructor can be output as static data. */
1896 }
1897 \f
1898 /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
1899 an IDENTIFIER_NODE giving the name of the field, or FIELD, a FIELD_DECL,
1900 for the field. Don't fold the result if NO_FOLD_P is true.
1902 We also handle the fact that we might have been passed a pointer to the
1903 actual record and know how to look for fields in variant parts. */
1905 static tree
1908 {
1916 /* If no field was specified, look for a field with the specified name in
1917 the current record only. */
1920 field;
1928 /* If this field is not in the specified record, see if we can find a field
1929 in the specified record whose original field is the same as this one. */
1931 {
1932 tree new_field;
1934 /* First loop through normal components. */
1936 new_field;
1941 /* Next, see if we're looking for an inherited component in an extension.
1942 If so, look through the extension directly, unless the type contains
1943 a placeholder, as it might be needed for a later substitution. */
1949 == RECORD_TYPE
1951 {
1956 }
1958 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
1959 component in the first search. Doing this search in two steps is
1960 required to avoid hidden homonymous fields in the _Parent field. */
1963 new_field;
1966 {
1967 tree field_ref
1971 no_fold_p);
1974 }
1977 }
1982 /* If the field's offset has overflowed, do not try to access it, as doing
1983 so may trigger sanity checks deeper in the back-end. Note that we don't
1984 need to warn since this will be done on trying to declare the object. */
1989 /* We have found a suitable field. Before building the COMPONENT_REF, get
1990 the base object of the record variable if possible. */
1994 {
1998 /* Look through a conversion between type variants. This is transparent
1999 as far as the field is concerned. */
2003 /* Look through a conversion between original and packable version, but
2004 the field needs to be adjusted in this case. */
2007 {
2008 tree new_field;
2011 new_field;
2016 {
2019 }
2020 }
2021 }
2038 /* The generic folder may punt in this case because the inner array type
2039 can be self-referential, but folding is in fact not problematic. */
2042 {
2050 }
2053 }
2054 \f
2055 /* Likewise, but generate a Constraint_Error if the reference could not be
2056 found. */
2058 tree
2061 {
2063 no_fold_p);
2067 /* If FIELD was specified, assume this is an invalid user field so raise
2068 Constraint_Error. Otherwise, we have no type to return so abort. */
2072 N_Raise_Constraint_Error));
2073 }
2074 \f
2075 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2076 identically. Process the case where a GNAT_PROC to call is provided. */
2081 {
2083 tree gnu_call;
2085 /* A storage pool's underlying type is a record type (for both predefined
2086 storage pools and GNAT simple storage pools). The secondary stack uses
2087 the same mechanism, but its pool object (SS_Pool) is an integer. */
2089 {
2090 /* The size is the third parameter; the alignment is the
2091 same type. */
2092 Entity_Id gnat_size_type
2103 /* The first arg is always the address of the storage pool; next
2104 comes the address of the object, for a deallocator, then the
2105 size and alignment. */
2109 else
2112 }
2114 /* Secondary stack case. */
2115 else
2116 {
2117 /* The size is the second parameter. */
2118 Entity_Id gnat_size_type
2124 /* The first arg is the address of the object, for a deallocator,
2125 then the size. */
2128 else
2130 }
2133 }
2135 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2136 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2137 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2138 latter offers. */
2142 {
2143 /* When the DATA_TYPE alignment is stricter than what malloc offers
2144 (super-aligned case), we allocate an "aligning" wrapper type and return
2145 the address of its single data field with the malloc's return value
2146 stored just in front. */
2149 unsigned int system_allocator_alignment
2152 tree aligning_type
2155 system_allocator_alignment,
2157 gnat_node)
2160 tree size_to_malloc
2166 {
2167 /* Latch malloc's return value and get a pointer to the aligning field
2168 first. */
2171 tree aligning_record_addr
2174 tree aligning_record
2177 tree aligning_field
2181 tree aligning_field_addr
2184 /* Then arrange to store the allocator's return value ahead
2185 and return. */
2186 tree storage_ptr_slot_addr
2192 tree storage_ptr_slot
2195 storage_ptr_slot_addr));
2197 return
2201 aligning_field_addr);
2202 }
2203 else
2205 }
2207 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2208 designated by DATA_PTR using the __gnat_free entry point. */
2212 {
2213 /* In the regular alignment case, we pass the data pointer straight to free.
2214 In the superaligned case, we need to retrieve the initial allocator
2215 return value, stored in front of the data block at allocation time. */
2218 unsigned int system_allocator_alignment
2221 tree free_ptr;
2224 {
2225 /* DATA_FRONT_PTR (void *)
2226 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2227 tree data_front_ptr
2228 = build_binary_op
2233 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2234 free_ptr
2235 = build_unary_op
2238 }
2239 else
2243 }
2245 /* Build a GCC tree to call an allocation or deallocation function.
2246 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2247 generate an allocator.
2249 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2250 object type, used to determine the to-be-honored address alignment.
2251 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2252 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2253 to provide an error location for restriction violation messages. */
2255 tree
2258 Node_Id gnat_node)
2259 {
2262 /* Explicit proc to call ? This one is assumed to deal with the type
2263 alignment constraints. */
2268 /* Otherwise, object to "free" or "malloc" with possible special processing
2269 for alignments stricter than what the default allocator honors. */
2272 else
2273 {
2274 /* Assert that we no longer can be called with this special pool. */
2277 /* Check that we aren't violating the associated restriction. */
2282 }
2283 }
2284 \f
2285 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2286 initial value is INIT, if INIT is nonzero. Convert the expression to
2287 RESULT_TYPE, which must be some pointer type, and return the result.
2289 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2290 the storage pool to use. GNAT_NODE is used to provide an error
2291 location for restriction violation messages. If IGNORE_INIT_TYPE is
2292 true, ignore the type of INIT for the purpose of determining the size;
2293 this will cause the maximum size to be allocated if TYPE is of
2294 self-referential size. */
2296 tree
2299 {
2302 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2306 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2311 ignore_init_type),
2314 ignore_init_type));
2316 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2317 sizes of the object and its template. Allocate the whole thing and
2318 fill in the parts that are known. */
2320 {
2321 tree storage_type
2328 init);
2330 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2340 /* If there is an initializing expression, then make a constructor for
2341 the entire object including the bounds and copy it into the object.
2342 If there is no initializing expression, just set the bounds. */
2344 {
2351 init);
2352 storage_init
2355 }
2356 else
2357 storage_init
2366 }
2370 /* If we have an initializing expression, see if its size is simpler
2371 than the size from the type. */
2377 /* If the size is still self-referential, reference the initializing
2378 expression, if it is present. If not, this must have been a
2379 call to allocate a library-level object, in which case we use
2380 the maximum size. */
2382 {
2385 else
2387 }
2389 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2396 gnat_node));
2398 /* If we have an initial value, protect the new address, assign the value
2399 and return the address with a COMPOUND_EXPR. */
2401 {
2405 storage_init
2408 }
2411 }
2412 \f
2413 /* Indicate that we need to take the address of T and that it therefore
2414 should not be allocated in a register. Returns true if successful. */
2416 bool
2418 {
2421 {
2430 CASE_CONVERT:
2458 }
2459 }
2460 \f
2461 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
2462 but we know how to handle our own nodes. */
2464 tree
2466 {
2474 {
2478 }
2480 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2481 This may be more efficient, but will also allow us to more easily find
2482 the match for the PLACEHOLDER_EXPR. */
2489 }
2491 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
2492 is optimized under the assumption that EXP's value doesn't change before
2493 its subsequent reuse(s) except through its potential reevaluation. */
2495 tree
2497 {
2504 /* If EXP has no side effects, we theoretically don't need to do anything.
2505 However, we may be recursively passed more and more complex expressions
2506 involving checks which will be reused multiple times and eventually be
2507 unshared for gimplification; in order to avoid a complexity explosion
2508 at that point, we protect any expressions more complex than a simple
2509 arithmetic expression. */
2511 {
2515 }
2517 /* If this is a conversion, protect what's inside the conversion. */
2523 /* If we're indirectly referencing something, we only need to protect the
2524 address since the data itself can't change in these situations. */
2526 {
2530 }
2532 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2533 This may be more efficient, but will also allow us to more easily find
2534 the match for the PLACEHOLDER_EXPR. */
2540 /* If this is a fat pointer or something that can be placed in a register,
2541 just make a SAVE_EXPR. Likewise for a CALL_EXPR as large objects are
2542 returned via invisible reference in most ABIs so the temporary will
2543 directly be filled by the callee. */
2549 /* Otherwise reference, protect the address and dereference. */
2550 return
2554 exp)));
2555 }
2557 /* This is equivalent to stabilize_reference_1 in tree.c but we take an extra
2558 argument to force evaluation of everything. */
2560 static tree
2562 {
2565 tree result;
2567 /* We cannot ignore const expressions because it might be a reference
2568 to a const array but whose index contains side-effects. But we can
2569 ignore things that are actual constant or that already have been
2570 handled by this function. */
2575 {
2582 /* If this is a COMPONENT_REF of a fat pointer, save the entire
2583 fat pointer. This may be more efficient, but will also allow
2584 us to more easily find the match for the PLACEHOLDER_EXPR. */
2587 result
2591 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2592 so that it will only be evaluated once. */
2593 /* The tcc_reference and tcc_comparison classes could be handled as
2594 below, but it is generally faster to only evaluate them once. */
2597 else
2602 /* Recursively stabilize each operand. */
2603 result
2610 /* Recursively stabilize each operand. */
2611 result
2618 }
2620 /* See similar handling in gnat_stabilize_reference. */
2632 }
2634 /* This is equivalent to stabilize_reference in tree.c but we know how to
2635 handle our own nodes and we take extra arguments. FORCE says whether to
2636 force evaluation of everything. We set SUCCESS to true unless we walk
2637 through something we don't know how to stabilize. */
2639 tree
2641 {
2644 tree result;
2646 /* Assume we'll success unless proven otherwise. */
2651 {
2656 /* No action is needed in this case. */
2660 CASE_CONVERT:
2664 result
2667 success));
2674 force));
2680 success),
2687 success),
2695 success),
2697 force),
2708 success),
2710 success));
2714 /* Constructors with 1 element are used extensively to formally
2715 convert objects to special wrapping types. */
2718 {
2721 result
2724 force));
2725 }
2726 else
2727 {
2731 }
2737 /* ... fall through to failure ... */
2739 /* If arg isn't a kind of lvalue we recognize, make no change.
2740 Caller should recognize the error for an invalid lvalue. */
2745 }
2747 /* TREE_THIS_VOLATILE and TREE_SIDE_EFFECTS set on the initial expression
2748 may not be sustained across some paths, such as the way via build1 for
2749 INDIRECT_REF. We reset those flags here in the general case, which is
2750 consistent with the GCC version of this routine.
2752 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
2753 paths introduce side-effects where there was none initially (e.g. if a
2754 SAVE_EXPR is built) and we also want to keep track of that. */
2766 }
2768 /* If EXPR is an expression that is invariant in the current function, in the
2769 sense that it can be evaluated anywhere in the function and any number of
2770 times, return EXPR or an equivalent expression. Otherwise return NULL. */
2772 tree
2774 {
2783 {
2785 /* Look into CONSTRUCTORs built to initialize padded types. */
2789 }
2797 {
2799 {
2828 }
2831 }
2833 object:
2854 }