| blob | 9410b4083bf25ae23fb2402e523601d5eb3fe8a9 |
1 /****************************************************************************
2 * *
3 * GNAT COMPILER COMPONENTS *
4 * *
5 * U T I L S 2 *
6 * *
7 * C Implementation File *
8 * *
9 * Copyright (C) 1992-2013, Free Software Foundation, Inc. *
10 * *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
20 * *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
23 * *
24 ****************************************************************************/
51 /* Return the base type of TYPE. */
53 tree
55 {
66 }
67 \f
68 /* EXP is a GCC tree representing an address. See if we can find how
69 strictly the object at that address is aligned. Return that alignment
70 in bits. If we don't know anything about the alignment, return 0. */
72 unsigned int
74 {
79 {
80 CASE_CONVERT:
83 /* Conversions between pointers and integers don't change the alignment
84 of the underlying object. */
89 /* The value of a COMPOUND_EXPR is that of it's second operand. */
95 /* If two address are added, the alignment of the result is the
96 minimum of the two alignments. */
105 /* If we don't know the alignment of the offset, we assume that
106 of the base. */
109 else
114 /* If there is a choice between two values, use the smallest one. */
121 {
123 /* The first part of this represents the lowest bit in the constant,
124 but it is originally in bytes, not bits. */
126 }
130 /* If we know the alignment of just one side, use it. Otherwise,
131 use the product of the alignments. */
139 else
144 /* A bit-and expression is as aligned as the maximum alignment of the
145 operands. We typically get here for a complex lhs and a constant
146 negative power of two on the rhs to force an explicit alignment, so
147 don't bother looking at the lhs. */
156 {
160 }
162 /* Fall through... */
165 /* For other pointer expressions, we assume that the pointed-to object
166 is at least as aligned as the pointed-to type. Beware that we can
167 have a dummy type here (e.g. a Taft Amendment type), for which the
168 alignment is meaningless and should be ignored. */
172 else
175 }
178 }
179 \f
180 /* We have a comparison or assignment operation on two types, T1 and T2, which
181 are either both array types or both record types. T1 is assumed to be for
182 the left hand side operand, and T2 for the right hand side. Return the
183 type that both operands should be converted to for the operation, if any.
184 Otherwise return zero. */
186 static tree
188 {
189 /* ??? As of today, various constructs lead to here with types of different
190 sizes even when both constants (e.g. tagged types, packable vs regular
191 component types, padded vs unpadded types, ...). While some of these
192 would better be handled upstream (types should be made consistent before
193 calling into build_binary_op), some others are really expected and we
194 have to be careful. */
196 /* We must avoid writing more than what the target can hold if this is for
197 an assignment and the case of tagged types is handled in build_binary_op
198 so we use the lhs type if it is known to be smaller or of constant size
199 and the rhs type is not, whatever the modes. We also force t1 in case of
200 constant size equality to minimize occurrences of view conversions on the
201 lhs of an assignment, except for the case of record types with a variant
202 part on the lhs but not on the rhs to make the conversion simpler. */
213 /* Otherwise, if the lhs type is non-BLKmode, use it. Note that we know
214 that we will not have any alignment problems since, if we did, the
215 non-BLKmode type could not have been used. */
219 /* If the rhs type is of constant size, use it whatever the modes. At
220 this point it is known to be smaller, or of constant size and the
221 lhs type is not. */
225 /* Otherwise, if the rhs type is non-BLKmode, use it. */
229 /* In this case, both types have variable size and BLKmode. It's
230 probably best to leave the "type mismatch" because changing it
231 could cause a bad self-referential reference. */
233 }
234 \f
235 /* Return an expression tree representing an equality comparison of A1 and A2,
236 two objects of type ARRAY_TYPE. The result should be of type RESULT_TYPE.
238 Two arrays are equal in one of two ways: (1) if both have zero length in
239 some dimension (not necessarily the same dimension) or (2) if the lengths
240 in each dimension are equal and the data is equal. We perform the length
241 tests in as efficient a manner as possible. */
243 static tree
245 {
255 /* If either operand has side-effects, they have to be evaluated only once
256 in spite of the multiple references to the operand in the comparison. */
263 /* Process each dimension separately and compare the lengths. If any
264 dimension has a length known to be zero, set LENGTH_ZERO_P to true
265 in order to suppress the comparison of the data at the end. */
267 {
273 size_one_node);
275 size_one_node);
278 /* If the length of the first array is a constant, swap our operands
279 unless the length of the second array is the constant zero. */
281 {
282 tree tem;
293 }
295 /* If the length of the second array is the constant zero, we can just
296 use the original stored bounds for the first array and see whether
297 last < first holds. */
299 {
312 }
314 /* Otherwise, if the length is some other constant value, we know that
315 this dimension in the second array cannot be superflat, so we can
316 just use its length computed from the actual stored bounds. */
318 {
319 tree bt;
323 /* Note that we know that UB2 and LB2 are constant and hence
324 cannot contain a PLACEHOLDER_EXPR. */
329 comparison
337 this_a1_is_null
341 }
343 /* Otherwise, compare the computed lengths. */
344 else
345 {
349 comparison
352 /* If the length expression is of the form (cond ? val : 0), assume
353 that cond is equivalent to (length != 0). That's guaranteed by
354 construction of the array types in gnat_to_gnu_entity. */
357 this_a1_is_null
359 else
363 /* Likewise for the second array. */
366 this_a2_is_null
368 else
371 }
373 /* Append expressions for this dimension to the final expressions. */
385 }
387 /* Unless the length of some dimension is known to be zero, compare the
388 data in the array. */
390 {
392 tree comparison;
395 {
398 }
402 result
404 }
406 /* The result is also true if both sizes are zero. */
410 result);
412 /* If either operand has side-effects, they have to be evaluated before
413 starting the comparison above since the place they would be otherwise
414 evaluated could be wrong. */
422 }
424 /* Return an expression tree representing an equality comparison of P1 and P2,
425 two objects of fat pointer type. The result should be of type RESULT_TYPE.
427 Two fat pointers are equal in one of two ways: (1) if both have a null
428 pointer to the array or (2) if they contain the same couple of pointers.
429 We perform the comparison in as efficient a manner as possible. */
431 static tree
433 {
437 /* If either operand has side-effects, they have to be evaluated only once
438 in spite of the multiple references to the operand in the comparison. */
442 /* The constant folder doesn't fold fat pointer types so we do it here. */
445 else
449 p1_array_is_null
452 null_pointer_node));
456 else
460 p2_array_is_null
463 null_pointer_node));
465 /* If one of the pointers to the array is null, just compare the other. */
471 /* Otherwise, do the fully-fledged comparison. */
472 same_array
477 else
478 p1_bounds
484 else
485 p2_bounds
489 same_bounds
492 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
496 }
497 \f
498 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
499 type TYPE. We know that TYPE is a modular type with a nonbinary
500 modulus. */
502 static tree
504 tree rhs)
505 {
511 tree result;
513 /* If this is an addition of a constant, convert it to a subtraction
514 of a constant since we can do that faster. */
516 {
519 }
521 /* For the logical operations, we only need PRECISION bits. For
522 addition and subtraction, we need one more and for multiplication we
523 need twice as many. But we never want to make a size smaller than
524 our size. */
532 /* Unsigned will do for everything but subtraction. */
536 /* If our type is the wrong signedness or isn't wide enough, make a new
537 type and convert both our operands to it. */
540 {
541 /* Copy the node so we ensure it can be modified to make it modular. */
548 }
550 /* Do the operation, then we'll fix it up. */
553 /* For multiplication, we have no choice but to do a full modulus
554 operation. However, we want to do this in the narrowest
555 possible size. */
557 {
565 }
567 /* For subtraction, add the modulus back if we are negative. */
569 {
575 result);
576 }
578 /* For the other operations, subtract the modulus if we are >= it. */
579 else
580 {
587 result);
588 }
591 }
592 \f
593 /* This page contains routines that implement the Ada semantics with regard
594 to atomic objects. They are fully piggybacked on the middle-end support
595 for atomic loads and stores.
597 *** Memory barriers and volatile objects ***
599 We implement the weakened form of the C.6(16) clause that was introduced
600 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
601 implementable without significant performance hits on modern platforms.
603 We also take advantage of the requirements imposed on shared variables by
604 9.10 (conditions for sequential actions) to have non-erroneous execution
605 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
606 volatile updates with regard to sequential actions, i.e. with regard to
607 reads or updates of atomic objects.
609 As such, an update of an atomic object by a task requires that all earlier
610 accesses to volatile objects have completed. Similarly, later accesses to
611 volatile objects cannot be reordered before the update of the atomic object.
612 So, memory barriers both before and after the atomic update are needed.
614 For a read of an atomic object, to avoid seeing writes of volatile objects
615 by a task earlier than by the other tasks, a memory barrier is needed before
616 the atomic read. Finally, to avoid reordering later reads or updates of
617 volatile objects to before the atomic read, a barrier is needed after the
618 atomic read.
620 So, memory barriers are needed before and after atomic reads and updates.
621 And, in order to simplify the implementation, we use full memory barriers
622 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
624 /* Return the size of TYPE, which must be a positive power of 2. */
626 static unsigned int
628 {
634 /* We shouldn't reach here without having already detected that the size
635 isn't compatible with an atomic access. */
639 }
641 /* Build an atomic load for the underlying atomic object in SRC. */
643 tree
645 {
646 tree ptr_type
647 = build_pointer_type
655 /* Remove conversions to get the address of the underlying object. */
667 /* First reinterpret the loaded bits in the original type of the load,
668 then convert to the expected result type. */
671 }
673 /* Build an atomic store from SRC to the underlying atomic object in DEST. */
675 tree
677 {
678 tree ptr_type
679 = build_pointer_type
687 /* Remove conversions to get the address of the underlying object. */
697 /* First convert the bits to be stored to the original type of the store,
698 then reinterpret them in the effective type. But if the original type
699 is a padded type with the same size, convert to the inner type instead,
700 as we don't want to artificially introduce a CONSTRUCTOR here. */
705 else
711 }
712 \f
713 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
714 desired for the result. Usually the operation is to be performed
715 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
716 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
717 case the type to be used will be derived from the operands.
719 This function is very much unlike the ones for C and C++ since we
720 have already done any type conversion and matching required. All we
721 have to do here is validate the work done by SEM and handle subtypes. */
723 tree
726 {
746 modulus = (operation_type
752 {
755 #ifdef ENABLE_CHECKING
757 #endif
758 /* If there were integral or pointer conversions on the LHS, remove
759 them; we'll be putting them back below if needed. Likewise for
760 conversions between array and record types, except for justified
761 modular types. But don't do this if the right operand is not
762 BLKmode (for packed arrays) unless we are not changing the mode. */
783 (TREE_OPERAND
785 {
788 }
790 /* If a class-wide type may be involved, force use of the RHS type. */
796 /* If we are copying between padded objects with compatible types, use
797 the padded view of the objects, this is very likely more efficient.
798 Likewise for a padded object that is assigned a constructor, if we
799 can convert the constructor to the inner type, to avoid putting a
800 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
801 actually copied anything. */
806 == TYPE_MAIN_VARIANT
809 && !CONTAINS_PLACEHOLDER_P
812 {
813 /* We make an exception for a BLKmode type padding a non-BLKmode
814 inner type and do the conversion of the LHS right away, since
815 unchecked_convert wouldn't do it properly. */
819 {
823 }
824 else
826 }
828 /* If we have a call to a function that returns an unconstrained type
829 with default discriminant on the RHS, use the RHS type (which is
830 padded) as we cannot compute the size of the actual assignment. */
833 && CONTAINS_PLACEHOLDER_P
837 /* Find the best type to use for copying between aggregate types. */
845 /* Otherwise use the LHS type. */
846 else
849 /* Ensure everything on the LHS is valid. If we have a field reference,
850 strip anything that get_inner_reference can handle. Then remove any
851 conversions between types having the same code and mode. And mark
852 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
853 either an INDIRECT_REF, a NULL_EXPR or a DECL node. */
856 {
876 {
879 }
880 else
882 }
888 /* Convert the right operand to the operation type unless it is
889 either already of the correct type or if the type involves a
890 placeholder, since the RHS may not have the same record type. */
893 {
896 }
898 /* If the left operand is not of the same type as the operation
899 type, wrap it up in a VIEW_CONVERT_EXPR. */
911 /* ... fall through ... */
914 /* First look through conversion between type variants. Note that
915 this changes neither the operation type nor the type domain. */
919 {
922 }
924 /* For a range, make sure the element type is consistent. */
930 /* Then convert the right operand to its base type. This will prevent
931 unneeded sign conversions when sizetype is wider than integer. */
942 #ifdef ENABLE_CHECKING
944 #endif
956 #ifdef ENABLE_CHECKING
958 #endif
959 /* If either operand is a NULL_EXPR, just return a new one. */
964 integer_zero_node);
970 integer_zero_node);
972 /* If either object is a justified modular types, get the
973 fields from within. */
976 {
978 left_operand);
981 }
985 {
987 right_operand);
990 }
992 /* If both objects are arrays, compare them specially. */
999 {
1004 else
1008 }
1010 /* Otherwise, the base types must be the same, unless they are both fat
1011 pointer types or record types. In the latter case, use the best type
1012 and convert both operands to that type. */
1014 {
1017 {
1021 }
1025 {
1026 /* The only way this is permitted is if both types have the same
1027 name. In that case, one of them must not be self-referential.
1028 Use it as the best type. Even better with a fixed size. */
1041 else
1043 }
1045 else
1050 }
1051 else
1052 {
1055 }
1057 /* If both objects are fat pointers, compare them specially. */
1059 {
1060 result
1065 else
1069 }
1078 /* The RHS of a shift can be any type. Also, ignore any modulus
1079 (we used to abort, but this is needed for unchecked conversion
1080 to modular types). Otherwise, processing is the same as normal. */
1089 /* For binary modulus, if the inputs are in range, so are the
1090 outputs. */
1106 /* These always produce results lower than either operand. */
1121 else
1125 /* ... fall through ... */
1129 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1130 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1131 these types but can generate addition/subtraction for Succ/Pred. */
1139 /* ... fall through ... */
1142 common:
1143 /* The result type should be the same as the base types of the
1144 both operands (and they should be the same). Convert
1145 everything to the result type. */
1151 }
1154 {
1158 }
1159 /* If either operand is a NULL_EXPR, just return a new one. */
1169 else
1170 result
1174 ;
1176 {
1180 }
1181 else
1187 /* If we are working with modular types, perform the MOD operation
1188 if something above hasn't eliminated the need for it. */
1197 }
1198 \f
1199 /* Similar, but for unary operations. */
1201 tree
1203 {
1207 tree result;
1220 {
1225 else
1232 #ifdef ENABLE_CHECKING
1234 #endif
1236 /* When not optimizing, fold the result as invert_truthvalue_loc
1237 doesn't fold the result of comparisons. This is intended to undo
1238 the trick used for boolean rvalues in gnat_to_gnu. */
1246 {
1251 /* Make sure the type here is a pointer, not a reference.
1252 GCC wants pointer types for function addresses. */
1256 /* If the underlying object can alias everything, propagate the
1257 property since we are effectively retrieving the object. */
1260 {
1263 result_type
1269 result_type
1273 }
1282 /* Fold a compound expression if it has unconstrained array type
1283 since the middle-end cannot handle it. But we don't it in the
1284 general case because it may introduce aliasing issues if the
1285 first operand is an indirect assignment and the second operand
1286 the corresponding address, e.g. for an allocator. */
1288 {
1294 }
1301 /* If this is for 'Address, find the address of the prefix and add
1302 the offset to the field. Otherwise, do this the normal way. */
1304 {
1305 HOST_WIDE_INT bitsize;
1306 HOST_WIDE_INT bitpos;
1315 /* If INNER is a padding type whose field has a self-referential
1316 size, convert to that inner type. We know the offset is zero
1317 and we need to have that type visible. */
1319 && CONTAINS_PLACEHOLDER_P
1323 inner);
1325 /* Compute the offset as a byte offset from INNER. */
1332 /* Take the address of INNER, convert the offset to void *, and
1333 add then. It will later be converted to the desired result
1334 type, if any. */
1340 result);
1342 }
1346 /* If this is just a constructor for a padded record, we can
1347 just take the address of the single field and convert it to
1348 a pointer to our type. */
1350 {
1355 }
1365 /* ... fallthru ... */
1368 /* If this just a variant conversion or if the conversion doesn't
1369 change the mode, get the result type from this type and go down.
1370 This is needed for conversions of CONST_DECLs, to eventually get
1371 to the address of their CORRESPONDING_VARs. */
1386 /* ... fall through ... */
1389 common:
1391 /* If we are taking the address of a padded record whose field
1392 contains a template, take the address of the field. */
1396 {
1399 }
1403 }
1409 {
1413 /* If TYPE is a thin pointer, either first retrieve the base if this
1414 is an expression with an offset built for the initialization of an
1415 object with an unconstrained nominal subtype, or else convert to
1416 the fat pointer. */
1418 {
1425 {
1428 }
1430 {
1431 operand
1433 operand);
1435 }
1436 }
1438 /* If we want to refer to an unconstrained array, use the appropriate
1439 expression. But this will never survive down to the back-end. */
1441 {
1446 }
1448 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1452 /* Otherwise, build and fold the indirect reference. */
1453 else
1454 {
1457 }
1460 {
1464 }
1472 }
1476 {
1477 tree modulus = ((operation_type
1483 /* If this is a modular type, there are various possibilities
1484 depending on the operation and whether the modulus is a
1485 power of two or not. */
1488 {
1492 /* The fastest in the negate case for binary modulus is
1493 the straightforward code; the TRUNC_MOD_EXPR below
1494 is an AND operation. */
1498 operand),
1499 modulus);
1501 /* For nonbinary negate case, return zero for zero operand,
1502 else return the modulus minus the operand. If the modulus
1503 is a power of two minus one, we can do the subtraction
1504 as an XOR since it is equivalent and faster on most machines. */
1506 {
1508 modulus,
1510 integer_one_node))))
1513 else
1519 boolean_type_node,
1520 operand,
1521 convert
1523 integer_zero_node)),
1525 }
1526 else
1527 {
1528 /* For the NOT cases, we need a constant equal to
1529 the modulus minus one. For a binary modulus, we
1530 XOR against the constant and subtract the operand from
1531 that constant for nonbinary modulus. */
1535 integer_one_node));
1540 else
1543 }
1546 }
1547 }
1549 /* ... fall through ... */
1555 }
1561 }
1562 \f
1563 /* Similar, but for COND_EXPR. */
1565 tree
1568 {
1570 tree result;
1572 /* The front-end verified that result, true and false operands have
1573 same base type. Convert everything to the result type. */
1577 /* If the result type is unconstrained, take the address of the operands and
1578 then dereference the result. Likewise if the result type is passed by
1579 reference, because creating a temporary of this type is not allowed. */
1583 {
1588 }
1593 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1594 in both arms, make sure it gets evaluated by moving it ahead of the
1595 conditional expression. This is necessary because it is evaluated
1596 in only one place at run time and would otherwise be uninitialized
1597 in one of the arms. */
1608 }
1610 /* Similar, but for COMPOUND_EXPR. */
1612 tree
1614 {
1616 tree result;
1618 /* If the result type is unconstrained, take the address of the operand and
1619 then dereference the result. Likewise if the result type is passed by
1620 reference, but this is natively handled in the gimplifier. */
1623 {
1627 }
1630 expr_operand);
1636 }
1637 \f
1638 /* Conveniently construct a function call expression. FNDECL names the
1639 function to be called, N is the number of arguments, and the "..."
1640 parameters are the argument expressions. Unlike build_call_expr
1641 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1643 tree
1645 {
1654 }
1655 \f
1656 /* Call a function that raises an exception and pass the line number and file
1657 name, if requested. MSG says which exception function to call.
1659 GNAT_NODE is the gnat node conveying the source location for which the
1660 error should be signaled, or Empty in which case the error is signaled on
1661 the current ref_file_name/input_line.
1663 KIND says which kind of exception this is for
1664 (N_Raise_{Constraint,Storage,Program}_Error). */
1666 tree
1668 {
1671 tree filename;
1676 /* If this is to be done as a goto, handle that case. */
1678 {
1682 /* If Local_Raise is present, generate
1683 Local_Raise (exception'Identity); */
1685 {
1686 tree gnu_local_raise
1688 tree gnu_exception_entity
1690 tree gnu_call
1693 gnu_exception_entity));
1699 }
1701 str
1705 ? IDENTIFIER_POINTER
1707 (Debug_Source_Name
1713 line_number
1720 return
1724 filename),
1726 }
1728 /* Similar to build_call_raise, for an index or range check exception as
1729 determined by MSG, with extra information generated of the form
1730 "INDEX out of range FIRST..LAST". */
1732 tree
1735 {
1737 tree filename;
1742 str
1746 ? IDENTIFIER_POINTER
1748 (Debug_Source_Name
1755 {
1758 }
1759 else
1760 {
1763 }
1768 return
1772 filename),
1778 }
1780 /* Similar to build_call_raise, with extra information about the column
1781 where the check failed. */
1783 tree
1785 {
1787 tree filename;
1792 str
1796 ? IDENTIFIER_POINTER
1798 (Debug_Source_Name
1805 {
1808 }
1809 else
1810 {
1813 }
1818 return
1822 filename),
1825 }
1826 \f
1827 /* qsort comparer for the bit positions of two constructor elements
1828 for record components. */
1830 static int
1832 {
1837 const int ret
1841 }
1843 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
1845 tree
1847 {
1853 /* Scan the elements to see if they are all constant or if any has side
1854 effects, to let us set global flags on the resulting constructor. Count
1855 the elements along the way for possible sorting purposes below. */
1857 {
1858 /* The predicate must be in keeping with output_constructor. */
1868 }
1870 /* For record types with constant components only, sort field list
1871 by increasing bit position. This is necessary to ensure the
1872 constructor can be output as static data. */
1882 }
1883 \f
1884 /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
1885 an IDENTIFIER_NODE giving the name of the field, or FIELD, a FIELD_DECL,
1886 for the field. Don't fold the result if NO_FOLD_P is true.
1888 We also handle the fact that we might have been passed a pointer to the
1889 actual record and know how to look for fields in variant parts. */
1891 static tree
1894 {
1902 /* If no field was specified, look for a field with the specified name in
1903 the current record only. */
1906 field;
1914 /* If this field is not in the specified record, see if we can find a field
1915 in the specified record whose original field is the same as this one. */
1917 {
1918 tree new_field;
1920 /* First loop through normal components. */
1922 new_field;
1927 /* Next, see if we're looking for an inherited component in an extension.
1928 If so, look through the extension directly, but not if the type contains
1929 a placeholder, as it might be needed for a later substitution. */
1935 == RECORD_TYPE
1937 {
1942 }
1944 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
1945 component in the first search. Doing this search in two steps is
1946 required to avoid hidden homonymous fields in the _Parent field. */
1949 new_field;
1952 {
1953 tree field_ref
1957 no_fold_p);
1960 }
1963 }
1968 /* If the field's offset has overflowed, do not try to access it, as doing
1969 so may trigger sanity checks deeper in the back-end. Note that we don't
1970 need to warn since this will be done on trying to declare the object. */
1975 /* Look through conversion between type variants. This is transparent as
1976 far as the field is concerned. */
1981 else
1985 NULL_TREE);
2000 /* The generic folder may punt in this case because the inner array type
2001 can be self-referential, but folding is in fact not problematic. */
2004 {
2012 }
2015 }
2016 \f
2017 /* Like build_simple_component_ref, except that we give an error if the
2018 reference could not be found. */
2020 tree
2023 {
2025 no_fold_p);
2030 /* If FIELD was specified, assume this is an invalid user field so raise
2031 Constraint_Error. Otherwise, we have no type to return so abort. */
2035 N_Raise_Constraint_Error));
2036 }
2037 \f
2038 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2039 identically. Process the case where a GNAT_PROC to call is provided. */
2044 {
2046 tree gnu_call;
2048 /* A storage pool's underlying type is a record type (for both predefined
2049 storage pools and GNAT simple storage pools). The secondary stack uses
2050 the same mechanism, but its pool object (SS_Pool) is an integer. */
2052 {
2053 /* The size is the third parameter; the alignment is the
2054 same type. */
2055 Entity_Id gnat_size_type
2066 /* The first arg is always the address of the storage pool; next
2067 comes the address of the object, for a deallocator, then the
2068 size and alignment. */
2072 else
2075 }
2077 /* Secondary stack case. */
2078 else
2079 {
2080 /* The size is the second parameter. */
2081 Entity_Id gnat_size_type
2087 /* The first arg is the address of the object, for a deallocator,
2088 then the size. */
2091 else
2093 }
2096 }
2098 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2099 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2100 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2101 latter offers. */
2105 {
2106 /* When the DATA_TYPE alignment is stricter than what malloc offers
2107 (super-aligned case), we allocate an "aligning" wrapper type and return
2108 the address of its single data field with the malloc's return value
2109 stored just in front. */
2112 unsigned int system_allocator_alignment
2115 tree aligning_type
2118 system_allocator_alignment,
2120 gnat_node)
2123 tree size_to_malloc
2126 tree malloc_ptr;
2128 /* On VMS, if pointers are 64-bit and the allocator size is 32-bit or
2129 Convention C, allocate 32-bit memory. */
2136 else
2140 {
2141 /* Latch malloc's return value and get a pointer to the aligning field
2142 first. */
2145 tree aligning_record_addr
2148 tree aligning_record
2151 tree aligning_field
2155 tree aligning_field_addr
2158 /* Then arrange to store the allocator's return value ahead
2159 and return. */
2160 tree storage_ptr_slot_addr
2166 tree storage_ptr_slot
2169 storage_ptr_slot_addr));
2171 return
2175 aligning_field_addr);
2176 }
2177 else
2179 }
2181 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2182 designated by DATA_PTR using the __gnat_free entry point. */
2186 {
2187 /* In the regular alignment case, we pass the data pointer straight to free.
2188 In the superaligned case, we need to retrieve the initial allocator
2189 return value, stored in front of the data block at allocation time. */
2192 unsigned int system_allocator_alignment
2195 tree free_ptr;
2198 {
2199 /* DATA_FRONT_PTR (void *)
2200 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2201 tree data_front_ptr
2202 = build_binary_op
2207 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2208 free_ptr
2209 = build_unary_op
2212 }
2213 else
2217 }
2219 /* Build a GCC tree to call an allocation or deallocation function.
2220 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2221 generate an allocator.
2223 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2224 object type, used to determine the to-be-honored address alignment.
2225 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2226 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2227 to provide an error location for restriction violation messages. */
2229 tree
2232 Node_Id gnat_node)
2233 {
2236 /* Explicit proc to call ? This one is assumed to deal with the type
2237 alignment constraints. */
2242 /* Otherwise, object to "free" or "malloc" with possible special processing
2243 for alignments stricter than what the default allocator honors. */
2246 else
2247 {
2248 /* Assert that we no longer can be called with this special pool. */
2251 /* Check that we aren't violating the associated restriction. */
2256 }
2257 }
2258 \f
2259 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2260 initial value is INIT, if INIT is nonzero. Convert the expression to
2261 RESULT_TYPE, which must be some pointer type, and return the result.
2263 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2264 the storage pool to use. GNAT_NODE is used to provide an error
2265 location for restriction violation messages. If IGNORE_INIT_TYPE is
2266 true, ignore the type of INIT for the purpose of determining the size;
2267 this will cause the maximum size to be allocated if TYPE is of
2268 self-referential size. */
2270 tree
2273 {
2276 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2280 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2285 ignore_init_type),
2288 ignore_init_type));
2290 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2291 sizes of the object and its template. Allocate the whole thing and
2292 fill in the parts that are known. */
2294 {
2295 tree storage_type
2302 init);
2304 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2314 /* If there is an initializing expression, then make a constructor for
2315 the entire object including the bounds and copy it into the object.
2316 If there is no initializing expression, just set the bounds. */
2318 {
2325 init);
2326 storage_init
2329 }
2330 else
2331 storage_init
2340 }
2344 /* If we have an initializing expression, see if its size is simpler
2345 than the size from the type. */
2351 /* If the size is still self-referential, reference the initializing
2352 expression, if it is present. If not, this must have been a
2353 call to allocate a library-level object, in which case we use
2354 the maximum size. */
2356 {
2359 else
2361 }
2363 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2370 gnat_node));
2372 /* If we have an initial value, protect the new address, assign the value
2373 and return the address with a COMPOUND_EXPR. */
2375 {
2379 storage_init
2382 }
2385 }
2386 \f
2387 /* Indicate that we need to take the address of T and that it therefore
2388 should not be allocated in a register. Returns true if successful. */
2390 bool
2392 {
2395 {
2404 CASE_CONVERT:
2432 }
2433 }
2434 \f
2435 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
2436 but we know how to handle our own nodes. */
2438 tree
2440 {
2448 {
2452 }
2454 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2455 This may be more efficient, but will also allow us to more easily find
2456 the match for the PLACEHOLDER_EXPR. */
2463 }
2465 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
2466 is optimized under the assumption that EXP's value doesn't change before
2467 its subsequent reuse(s) except through its potential reevaluation. */
2469 tree
2471 {
2478 /* If EXP has no side effects, we theoretically don't need to do anything.
2479 However, we may be recursively passed more and more complex expressions
2480 involving checks which will be reused multiple times and eventually be
2481 unshared for gimplification; in order to avoid a complexity explosion
2482 at that point, we protect any expressions more complex than a simple
2483 arithmetic expression. */
2485 {
2489 }
2491 /* If this is a conversion, protect what's inside the conversion. */
2497 /* If we're indirectly referencing something, we only need to protect the
2498 address since the data itself can't change in these situations. */
2500 {
2504 }
2506 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2507 This may be more efficient, but will also allow us to more easily find
2508 the match for the PLACEHOLDER_EXPR. */
2514 /* If this is a fat pointer or something that can be placed in a register,
2515 just make a SAVE_EXPR. Likewise for a CALL_EXPR as large objects are
2516 returned via invisible reference in most ABIs so the temporary will
2517 directly be filled by the callee. */
2523 /* Otherwise reference, protect the address and dereference. */
2524 return
2528 exp)));
2529 }
2531 /* This is equivalent to stabilize_reference_1 in tree.c but we take an extra
2532 argument to force evaluation of everything. */
2534 static tree
2536 {
2539 tree result;
2541 /* We cannot ignore const expressions because it might be a reference
2542 to a const array but whose index contains side-effects. But we can
2543 ignore things that are actual constant or that already have been
2544 handled by this function. */
2549 {
2556 /* If this is a COMPONENT_REF of a fat pointer, save the entire
2557 fat pointer. This may be more efficient, but will also allow
2558 us to more easily find the match for the PLACEHOLDER_EXPR. */
2561 result
2565 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2566 so that it will only be evaluated once. */
2567 /* The tcc_reference and tcc_comparison classes could be handled as
2568 below, but it is generally faster to only evaluate them once. */
2571 else
2576 /* Recursively stabilize each operand. */
2577 result
2584 /* Recursively stabilize each operand. */
2585 result
2592 }
2594 /* See similar handling in gnat_stabilize_reference. */
2606 }
2608 /* This is equivalent to stabilize_reference in tree.c but we know how to
2609 handle our own nodes and we take extra arguments. FORCE says whether to
2610 force evaluation of everything. We set SUCCESS to true unless we walk
2611 through something we don't know how to stabilize. */
2613 tree
2615 {
2618 tree result;
2620 /* Assume we'll success unless proven otherwise. */
2625 {
2630 /* No action is needed in this case. */
2634 CASE_CONVERT:
2638 result
2641 success));
2648 force));
2654 success),
2661 success),
2669 success),
2671 force),
2682 success),
2684 success));
2688 /* Constructors with 1 element are used extensively to formally
2689 convert objects to special wrapping types. */
2692 {
2695 result
2698 force));
2699 }
2700 else
2701 {
2705 }
2711 /* ... fall through to failure ... */
2713 /* If arg isn't a kind of lvalue we recognize, make no change.
2714 Caller should recognize the error for an invalid lvalue. */
2719 }
2721 /* TREE_THIS_VOLATILE and TREE_SIDE_EFFECTS set on the initial expression
2722 may not be sustained across some paths, such as the way via build1 for
2723 INDIRECT_REF. We reset those flags here in the general case, which is
2724 consistent with the GCC version of this routine.
2726 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
2727 paths introduce side-effects where there was none initially (e.g. if a
2728 SAVE_EXPR is built) and we also want to keep track of that. */
2740 }
2742 /* If EXPR is an expression that is invariant in the current function, in the
2743 sense that it can be evaluated anywhere in the function and any number of
2744 times, return EXPR or an equivalent expression. Otherwise return NULL. */
2746 tree
2748 {
2765 {
2767 {
2796 }
2799 }
2801 object:
2822 }