| blob | dd4151b5bc599dc58eb21d393fd90423bc2442e2 |
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 {
315 }
317 /* Otherwise, if the length is some other constant value, we know that
318 this dimension in the second array cannot be superflat, so we can
319 just use its length computed from the actual stored bounds. */
321 {
322 tree bt;
326 /* Note that we know that UB2 and LB2 are constant and hence
327 cannot contain a PLACEHOLDER_EXPR. */
332 comparison
340 this_a1_is_null
344 }
346 /* Otherwise, compare the computed lengths. */
347 else
348 {
352 comparison
355 /* If the length expression is of the form (cond ? val : 0), assume
356 that cond is equivalent to (length != 0). That's guaranteed by
357 construction of the array types in gnat_to_gnu_entity. */
360 this_a1_is_null
362 else
366 /* Likewise for the second array. */
369 this_a2_is_null
371 else
374 }
376 /* Append expressions for this dimension to the final expressions. */
388 }
390 /* Unless the length of some dimension is known to be zero, compare the
391 data in the array. */
393 {
395 tree comparison;
398 {
401 }
405 result
407 }
409 /* The result is also true if both sizes are zero. */
413 result);
415 /* If either operand has side-effects, they have to be evaluated before
416 starting the comparison above since the place they would be otherwise
417 evaluated could be wrong. */
425 }
427 /* Return an expression tree representing an equality comparison of P1 and P2,
428 two objects of fat pointer type. The result should be of type RESULT_TYPE.
430 Two fat pointers are equal in one of two ways: (1) if both have a null
431 pointer to the array or (2) if they contain the same couple of pointers.
432 We perform the comparison in as efficient a manner as possible. */
434 static tree
436 {
440 /* If either operand has side-effects, they have to be evaluated only once
441 in spite of the multiple references to the operand in the comparison. */
445 /* The constant folder doesn't fold fat pointer types so we do it here. */
448 else
452 p1_array_is_null
455 null_pointer_node));
459 else
463 p2_array_is_null
466 null_pointer_node));
468 /* If one of the pointers to the array is null, just compare the other. */
474 /* Otherwise, do the fully-fledged comparison. */
475 same_array
480 else
481 p1_bounds
487 else
488 p2_bounds
492 same_bounds
495 /* P1_ARRAY == P2_ARRAY && (P1_ARRAY == NULL || P1_BOUNDS == P2_BOUNDS). */
499 }
500 \f
501 /* Compute the result of applying OP_CODE to LHS and RHS, where both are of
502 type TYPE. We know that TYPE is a modular type with a nonbinary
503 modulus. */
505 static tree
507 tree rhs)
508 {
514 tree result;
516 /* If this is an addition of a constant, convert it to a subtraction
517 of a constant since we can do that faster. */
519 {
522 }
524 /* For the logical operations, we only need PRECISION bits. For
525 addition and subtraction, we need one more and for multiplication we
526 need twice as many. But we never want to make a size smaller than
527 our size. */
535 /* Unsigned will do for everything but subtraction. */
539 /* If our type is the wrong signedness or isn't wide enough, make a new
540 type and convert both our operands to it. */
543 {
544 /* Copy the node so we ensure it can be modified to make it modular. */
551 }
553 /* Do the operation, then we'll fix it up. */
556 /* For multiplication, we have no choice but to do a full modulus
557 operation. However, we want to do this in the narrowest
558 possible size. */
560 {
568 }
570 /* For subtraction, add the modulus back if we are negative. */
572 {
578 result);
579 }
581 /* For the other operations, subtract the modulus if we are >= it. */
582 else
583 {
590 result);
591 }
594 }
595 \f
596 /* This page contains routines that implement the Ada semantics with regard
597 to atomic objects. They are fully piggybacked on the middle-end support
598 for atomic loads and stores.
600 *** Memory barriers and volatile objects ***
602 We implement the weakened form of the C.6(16) clause that was introduced
603 in Ada 2012 (AI05-117). Earlier forms of this clause wouldn't have been
604 implementable without significant performance hits on modern platforms.
606 We also take advantage of the requirements imposed on shared variables by
607 9.10 (conditions for sequential actions) to have non-erroneous execution
608 and consider that C.6(16) and C.6(17) only prescribe an uniform order of
609 volatile updates with regard to sequential actions, i.e. with regard to
610 reads or updates of atomic objects.
612 As such, an update of an atomic object by a task requires that all earlier
613 accesses to volatile objects have completed. Similarly, later accesses to
614 volatile objects cannot be reordered before the update of the atomic object.
615 So, memory barriers both before and after the atomic update are needed.
617 For a read of an atomic object, to avoid seeing writes of volatile objects
618 by a task earlier than by the other tasks, a memory barrier is needed before
619 the atomic read. Finally, to avoid reordering later reads or updates of
620 volatile objects to before the atomic read, a barrier is needed after the
621 atomic read.
623 So, memory barriers are needed before and after atomic reads and updates.
624 And, in order to simplify the implementation, we use full memory barriers
625 in all cases, i.e. we enforce sequential consistency for atomic accesses. */
627 /* Return the size of TYPE, which must be a positive power of 2. */
629 static unsigned int
631 {
637 /* We shouldn't reach here without having already detected that the size
638 isn't compatible with an atomic access. */
642 }
644 /* Build an atomic load for the underlying atomic object in SRC. */
646 tree
648 {
649 tree ptr_type
650 = build_pointer_type
658 /* Remove conversions to get the address of the underlying object. */
670 /* First reinterpret the loaded bits in the original type of the load,
671 then convert to the expected result type. */
674 }
676 /* Build an atomic store from SRC to the underlying atomic object in DEST. */
678 tree
680 {
681 tree ptr_type
682 = build_pointer_type
690 /* Remove conversions to get the address of the underlying object. */
700 /* First convert the bits to be stored to the original type of the store,
701 then reinterpret them in the effective type. But if the original type
702 is a padded type with the same size, convert to the inner type instead,
703 as we don't want to artificially introduce a CONSTRUCTOR here. */
708 else
714 }
715 \f
716 /* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
717 desired for the result. Usually the operation is to be performed
718 in that type. For INIT_EXPR and MODIFY_EXPR, RESULT_TYPE must be
719 NULL_TREE. For ARRAY_REF, RESULT_TYPE may be NULL_TREE, in which
720 case the type to be used will be derived from the operands.
722 This function is very much unlike the ones for C and C++ since we
723 have already done any type conversion and matching required. All we
724 have to do here is validate the work done by SEM and handle subtypes. */
726 tree
729 {
749 modulus = (operation_type
755 {
758 #ifdef ENABLE_CHECKING
760 #endif
761 /* If there were integral or pointer conversions on the LHS, remove
762 them; we'll be putting them back below if needed. Likewise for
763 conversions between array and record types, except for justified
764 modular types. But don't do this if the right operand is not
765 BLKmode (for packed arrays) unless we are not changing the mode. */
786 (TREE_OPERAND
788 {
791 }
793 /* If a class-wide type may be involved, force use of the RHS type. */
799 /* If we are copying between padded objects with compatible types, use
800 the padded view of the objects, this is very likely more efficient.
801 Likewise for a padded object that is assigned a constructor, if we
802 can convert the constructor to the inner type, to avoid putting a
803 VIEW_CONVERT_EXPR on the LHS. But don't do so if we wouldn't have
804 actually copied anything. */
809 == TYPE_MAIN_VARIANT
812 && !CONTAINS_PLACEHOLDER_P
815 {
816 /* We make an exception for a BLKmode type padding a non-BLKmode
817 inner type and do the conversion of the LHS right away, since
818 unchecked_convert wouldn't do it properly. */
822 {
826 }
827 else
829 }
831 /* If we have a call to a function that returns an unconstrained type
832 with default discriminant on the RHS, use the RHS type (which is
833 padded) as we cannot compute the size of the actual assignment. */
836 && CONTAINS_PLACEHOLDER_P
840 /* Find the best type to use for copying between aggregate types. */
848 /* Otherwise use the LHS type. */
849 else
852 /* Ensure everything on the LHS is valid. If we have a field reference,
853 strip anything that get_inner_reference can handle. Then remove any
854 conversions between types having the same code and mode. And mark
855 VIEW_CONVERT_EXPRs with TREE_ADDRESSABLE. When done, we must have
856 either an INDIRECT_REF, a NULL_EXPR or a DECL node. */
859 {
879 {
882 }
883 else
885 }
891 /* Convert the right operand to the operation type unless it is
892 either already of the correct type or if the type involves a
893 placeholder, since the RHS may not have the same record type. */
896 {
899 }
901 /* If the left operand is not of the same type as the operation
902 type, wrap it up in a VIEW_CONVERT_EXPR. */
914 /* ... fall through ... */
917 /* First look through conversion between type variants. Note that
918 this changes neither the operation type nor the type domain. */
922 {
925 }
927 /* For a range, make sure the element type is consistent. */
933 /* Then convert the right operand to its base type. This will prevent
934 unneeded sign conversions when sizetype is wider than integer. */
945 #ifdef ENABLE_CHECKING
947 #endif
959 #ifdef ENABLE_CHECKING
961 #endif
962 /* If either operand is a NULL_EXPR, just return a new one. */
967 integer_zero_node);
973 integer_zero_node);
975 /* If either object is a justified modular types, get the
976 fields from within. */
979 {
981 left_operand);
984 }
988 {
990 right_operand);
993 }
995 /* If both objects are arrays, compare them specially. */
1002 {
1007 else
1011 }
1013 /* Otherwise, the base types must be the same, unless they are both fat
1014 pointer types or record types. In the latter case, use the best type
1015 and convert both operands to that type. */
1017 {
1020 {
1024 }
1028 {
1029 /* The only way this is permitted is if both types have the same
1030 name. In that case, one of them must not be self-referential.
1031 Use it as the best type. Even better with a fixed size. */
1044 else
1046 }
1048 else
1053 }
1054 else
1055 {
1058 }
1060 /* If both objects are fat pointers, compare them specially. */
1062 {
1063 result
1068 else
1072 }
1081 /* The RHS of a shift can be any type. Also, ignore any modulus
1082 (we used to abort, but this is needed for unchecked conversion
1083 to modular types). Otherwise, processing is the same as normal. */
1092 /* For binary modulus, if the inputs are in range, so are the
1093 outputs. */
1109 /* These always produce results lower than either operand. */
1124 else
1128 /* ... fall through ... */
1132 /* Avoid doing arithmetics in ENUMERAL_TYPE or BOOLEAN_TYPE like the
1133 other compilers. Contrary to C, Ada doesn't allow arithmetics in
1134 these types but can generate addition/subtraction for Succ/Pred. */
1142 /* ... fall through ... */
1145 common:
1146 /* The result type should be the same as the base types of the
1147 both operands (and they should be the same). Convert
1148 everything to the result type. */
1154 }
1157 {
1161 }
1162 /* If either operand is a NULL_EXPR, just return a new one. */
1172 else
1173 result
1177 ;
1179 {
1183 }
1184 else
1190 /* If we are working with modular types, perform the MOD operation
1191 if something above hasn't eliminated the need for it. */
1200 }
1201 \f
1202 /* Similar, but for unary operations. */
1204 tree
1206 {
1210 tree result;
1223 {
1228 else
1235 #ifdef ENABLE_CHECKING
1237 #endif
1239 /* When not optimizing, fold the result as invert_truthvalue_loc
1240 doesn't fold the result of comparisons. This is intended to undo
1241 the trick used for boolean rvalues in gnat_to_gnu. */
1249 {
1254 /* Make sure the type here is a pointer, not a reference.
1255 GCC wants pointer types for function addresses. */
1259 /* If the underlying object can alias everything, propagate the
1260 property since we are effectively retrieving the object. */
1263 {
1266 result_type
1272 result_type
1276 }
1285 /* Fold a compound expression if it has unconstrained array type
1286 since the middle-end cannot handle it. But we don't it in the
1287 general case because it may introduce aliasing issues if the
1288 first operand is an indirect assignment and the second operand
1289 the corresponding address, e.g. for an allocator. */
1291 {
1297 }
1304 /* If this is for 'Address, find the address of the prefix and add
1305 the offset to the field. Otherwise, do this the normal way. */
1307 {
1308 HOST_WIDE_INT bitsize;
1309 HOST_WIDE_INT bitpos;
1318 /* If INNER is a padding type whose field has a self-referential
1319 size, convert to that inner type. We know the offset is zero
1320 and we need to have that type visible. */
1322 && CONTAINS_PLACEHOLDER_P
1326 inner);
1328 /* Compute the offset as a byte offset from INNER. */
1335 /* Take the address of INNER, convert the offset to void *, and
1336 add then. It will later be converted to the desired result
1337 type, if any. */
1343 result);
1345 }
1349 /* If this is just a constructor for a padded record, we can
1350 just take the address of the single field and convert it to
1351 a pointer to our type. */
1353 {
1358 }
1368 /* ... fallthru ... */
1371 /* If this just a variant conversion or if the conversion doesn't
1372 change the mode, get the result type from this type and go down.
1373 This is needed for conversions of CONST_DECLs, to eventually get
1374 to the address of their CORRESPONDING_VARs. */
1389 /* ... fall through ... */
1392 common:
1394 /* If we are taking the address of a padded record whose field
1395 contains a template, take the address of the field. */
1399 {
1402 }
1406 }
1412 {
1416 /* If TYPE is a thin pointer, either first retrieve the base if this
1417 is an expression with an offset built for the initialization of an
1418 object with an unconstrained nominal subtype, or else convert to
1419 the fat pointer. */
1421 {
1428 {
1431 }
1433 {
1434 operand
1436 operand);
1438 }
1439 }
1441 /* If we want to refer to an unconstrained array, use the appropriate
1442 expression. But this will never survive down to the back-end. */
1444 {
1449 }
1451 /* If we are dereferencing an ADDR_EXPR, return its operand. */
1455 /* Otherwise, build and fold the indirect reference. */
1456 else
1457 {
1460 }
1463 {
1467 }
1475 }
1479 {
1480 tree modulus = ((operation_type
1486 /* If this is a modular type, there are various possibilities
1487 depending on the operation and whether the modulus is a
1488 power of two or not. */
1491 {
1495 /* The fastest in the negate case for binary modulus is
1496 the straightforward code; the TRUNC_MOD_EXPR below
1497 is an AND operation. */
1501 operand),
1502 modulus);
1504 /* For nonbinary negate case, return zero for zero operand,
1505 else return the modulus minus the operand. If the modulus
1506 is a power of two minus one, we can do the subtraction
1507 as an XOR since it is equivalent and faster on most machines. */
1509 {
1511 modulus,
1513 integer_one_node))))
1516 else
1522 boolean_type_node,
1523 operand,
1524 convert
1526 integer_zero_node)),
1528 }
1529 else
1530 {
1531 /* For the NOT cases, we need a constant equal to
1532 the modulus minus one. For a binary modulus, we
1533 XOR against the constant and subtract the operand from
1534 that constant for nonbinary modulus. */
1538 integer_one_node));
1543 else
1546 }
1549 }
1550 }
1552 /* ... fall through ... */
1558 }
1564 }
1565 \f
1566 /* Similar, but for COND_EXPR. */
1568 tree
1571 {
1573 tree result;
1575 /* The front-end verified that result, true and false operands have
1576 same base type. Convert everything to the result type. */
1580 /* If the result type is unconstrained, take the address of the operands and
1581 then dereference the result. Likewise if the result type is passed by
1582 reference, because creating a temporary of this type is not allowed. */
1586 {
1591 }
1596 /* If we have a common SAVE_EXPR (possibly surrounded by arithmetics)
1597 in both arms, make sure it gets evaluated by moving it ahead of the
1598 conditional expression. This is necessary because it is evaluated
1599 in only one place at run time and would otherwise be uninitialized
1600 in one of the arms. */
1611 }
1613 /* Similar, but for COMPOUND_EXPR. */
1615 tree
1617 {
1619 tree result;
1621 /* If the result type is unconstrained, take the address of the operand and
1622 then dereference the result. Likewise if the result type is passed by
1623 reference, but this is natively handled in the gimplifier. */
1626 {
1630 }
1633 expr_operand);
1639 }
1640 \f
1641 /* Conveniently construct a function call expression. FNDECL names the
1642 function to be called, N is the number of arguments, and the "..."
1643 parameters are the argument expressions. Unlike build_call_expr
1644 this doesn't fold the call, hence it will always return a CALL_EXPR. */
1646 tree
1648 {
1657 }
1658 \f
1659 /* Call a function that raises an exception and pass the line number and file
1660 name, if requested. MSG says which exception function to call.
1662 GNAT_NODE is the gnat node conveying the source location for which the
1663 error should be signaled, or Empty in which case the error is signaled on
1664 the current ref_file_name/input_line.
1666 KIND says which kind of exception this is for
1667 (N_Raise_{Constraint,Storage,Program}_Error). */
1669 tree
1671 {
1674 tree filename;
1679 /* If this is to be done as a goto, handle that case. */
1681 {
1685 /* If Local_Raise is present, generate
1686 Local_Raise (exception'Identity); */
1688 {
1689 tree gnu_local_raise
1691 tree gnu_exception_entity
1693 tree gnu_call
1696 gnu_exception_entity));
1702 }
1704 str
1708 ? IDENTIFIER_POINTER
1710 (Debug_Source_Name
1716 line_number
1724 return
1728 filename),
1730 }
1732 /* Similar to build_call_raise, for an index or range check exception as
1733 determined by MSG, with extra information generated of the form
1734 "INDEX out of range FIRST..LAST". */
1736 tree
1739 {
1741 tree filename;
1746 str
1750 ? IDENTIFIER_POINTER
1752 (Debug_Source_Name
1759 {
1762 }
1763 else
1764 {
1767 }
1772 return
1776 filename),
1782 }
1784 /* Similar to build_call_raise, with extra information about the column
1785 where the check failed. */
1787 tree
1789 {
1791 tree filename;
1796 str
1800 ? IDENTIFIER_POINTER
1802 (Debug_Source_Name
1809 {
1812 }
1813 else
1814 {
1817 }
1822 return
1826 filename),
1829 }
1830 \f
1831 /* qsort comparer for the bit positions of two constructor elements
1832 for record components. */
1834 static int
1836 {
1841 const int ret
1845 }
1847 /* Return a CONSTRUCTOR of TYPE whose elements are V. */
1849 tree
1851 {
1858 /* Scan the elements to see if they are all constant or if any has side
1859 effects, to let us set global flags on the resulting constructor. Count
1860 the elements along the way for possible sorting purposes below. */
1862 {
1863 /* The predicate must be in keeping with output_constructor. */
1876 }
1878 /* For record types with constant components only, sort field list
1879 by increasing bit position. This is necessary to ensure the
1880 constructor can be output as static data. */
1890 }
1891 \f
1892 /* Return a COMPONENT_REF to access a field that is given by COMPONENT,
1893 an IDENTIFIER_NODE giving the name of the field, or FIELD, a FIELD_DECL,
1894 for the field. Don't fold the result if NO_FOLD_P is true.
1896 We also handle the fact that we might have been passed a pointer to the
1897 actual record and know how to look for fields in variant parts. */
1899 static tree
1902 {
1910 /* If no field was specified, look for a field with the specified name in
1911 the current record only. */
1914 field;
1922 /* If this field is not in the specified record, see if we can find a field
1923 in the specified record whose original field is the same as this one. */
1925 {
1926 tree new_field;
1928 /* First loop through normal components. */
1930 new_field;
1935 /* Next, see if we're looking for an inherited component in an extension.
1936 If so, look through the extension directly, unless the type contains
1937 a placeholder, as it might be needed for a later substitution. */
1943 == RECORD_TYPE
1945 {
1950 }
1952 /* Next, loop through DECL_INTERNAL_P components if we haven't found the
1953 component in the first search. Doing this search in two steps is
1954 required to avoid hidden homonymous fields in the _Parent field. */
1957 new_field;
1960 {
1961 tree field_ref
1965 no_fold_p);
1968 }
1971 }
1976 /* If the field's offset has overflowed, do not try to access it, as doing
1977 so may trigger sanity checks deeper in the back-end. Note that we don't
1978 need to warn since this will be done on trying to declare the object. */
1983 /* We have found a suitable field. Before building the COMPONENT_REF, get
1984 the base object of the record variable if possible. */
1988 {
1992 /* Look through a conversion between type variants. This is transparent
1993 as far as the field is concerned. */
1997 /* Look through a conversion between original and packable version, but
1998 the field needs to be adjusted in this case. */
2000 {
2001 tree new_field;
2004 new_field;
2009 {
2012 }
2013 }
2014 }
2031 /* The generic folder may punt in this case because the inner array type
2032 can be self-referential, but folding is in fact not problematic. */
2035 {
2043 }
2046 }
2047 \f
2048 /* Likewise, but generate a Constraint_Error if the reference could not be
2049 found. */
2051 tree
2054 {
2056 no_fold_p);
2060 /* If FIELD was specified, assume this is an invalid user field so raise
2061 Constraint_Error. Otherwise, we have no type to return so abort. */
2065 N_Raise_Constraint_Error));
2066 }
2067 \f
2068 /* Helper for build_call_alloc_dealloc, with arguments to be interpreted
2069 identically. Process the case where a GNAT_PROC to call is provided. */
2074 {
2076 tree gnu_call;
2078 /* A storage pool's underlying type is a record type (for both predefined
2079 storage pools and GNAT simple storage pools). The secondary stack uses
2080 the same mechanism, but its pool object (SS_Pool) is an integer. */
2082 {
2083 /* The size is the third parameter; the alignment is the
2084 same type. */
2085 Entity_Id gnat_size_type
2096 /* The first arg is always the address of the storage pool; next
2097 comes the address of the object, for a deallocator, then the
2098 size and alignment. */
2102 else
2105 }
2107 /* Secondary stack case. */
2108 else
2109 {
2110 /* The size is the second parameter. */
2111 Entity_Id gnat_size_type
2117 /* The first arg is the address of the object, for a deallocator,
2118 then the size. */
2121 else
2123 }
2126 }
2128 /* Helper for build_call_alloc_dealloc, to build and return an allocator for
2129 DATA_SIZE bytes aimed at containing a DATA_TYPE object, using the default
2130 __gnat_malloc allocator. Honor DATA_TYPE alignments greater than what the
2131 latter offers. */
2135 {
2136 /* When the DATA_TYPE alignment is stricter than what malloc offers
2137 (super-aligned case), we allocate an "aligning" wrapper type and return
2138 the address of its single data field with the malloc's return value
2139 stored just in front. */
2142 unsigned int system_allocator_alignment
2145 tree aligning_type
2148 system_allocator_alignment,
2150 gnat_node)
2153 tree size_to_malloc
2156 tree malloc_ptr;
2158 /* On VMS, if pointers are 64-bit and the allocator size is 32-bit or
2159 Convention C, allocate 32-bit memory. */
2166 else
2170 {
2171 /* Latch malloc's return value and get a pointer to the aligning field
2172 first. */
2175 tree aligning_record_addr
2178 tree aligning_record
2181 tree aligning_field
2185 tree aligning_field_addr
2188 /* Then arrange to store the allocator's return value ahead
2189 and return. */
2190 tree storage_ptr_slot_addr
2196 tree storage_ptr_slot
2199 storage_ptr_slot_addr));
2201 return
2205 aligning_field_addr);
2206 }
2207 else
2209 }
2211 /* Helper for build_call_alloc_dealloc, to release a DATA_TYPE object
2212 designated by DATA_PTR using the __gnat_free entry point. */
2216 {
2217 /* In the regular alignment case, we pass the data pointer straight to free.
2218 In the superaligned case, we need to retrieve the initial allocator
2219 return value, stored in front of the data block at allocation time. */
2222 unsigned int system_allocator_alignment
2225 tree free_ptr;
2228 {
2229 /* DATA_FRONT_PTR (void *)
2230 = (void *)DATA_PTR - (void *)sizeof (void *)) */
2231 tree data_front_ptr
2232 = build_binary_op
2237 /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */
2238 free_ptr
2239 = build_unary_op
2242 }
2243 else
2247 }
2249 /* Build a GCC tree to call an allocation or deallocation function.
2250 If GNU_OBJ is nonzero, it is an object to deallocate. Otherwise,
2251 generate an allocator.
2253 GNU_SIZE is the number of bytes to allocate and GNU_TYPE is the contained
2254 object type, used to determine the to-be-honored address alignment.
2255 GNAT_PROC, if present, is a procedure to call and GNAT_POOL is the storage
2256 pool to use. If not present, malloc and free are used. GNAT_NODE is used
2257 to provide an error location for restriction violation messages. */
2259 tree
2262 Node_Id gnat_node)
2263 {
2266 /* Explicit proc to call ? This one is assumed to deal with the type
2267 alignment constraints. */
2272 /* Otherwise, object to "free" or "malloc" with possible special processing
2273 for alignments stricter than what the default allocator honors. */
2276 else
2277 {
2278 /* Assert that we no longer can be called with this special pool. */
2281 /* Check that we aren't violating the associated restriction. */
2286 }
2287 }
2288 \f
2289 /* Build a GCC tree that corresponds to allocating an object of TYPE whose
2290 initial value is INIT, if INIT is nonzero. Convert the expression to
2291 RESULT_TYPE, which must be some pointer type, and return the result.
2293 GNAT_PROC and GNAT_POOL optionally give the procedure to call and
2294 the storage pool to use. GNAT_NODE is used to provide an error
2295 location for restriction violation messages. If IGNORE_INIT_TYPE is
2296 true, ignore the type of INIT for the purpose of determining the size;
2297 this will cause the maximum size to be allocated if TYPE is of
2298 self-referential size. */
2300 tree
2303 {
2306 /* If the initializer, if present, is a NULL_EXPR, just return a new one. */
2310 /* If the initializer, if present, is a COND_EXPR, deal with each branch. */
2315 ignore_init_type),
2318 ignore_init_type));
2320 /* If RESULT_TYPE is a fat or thin pointer, set SIZE to be the sum of the
2321 sizes of the object and its template. Allocate the whole thing and
2322 fill in the parts that are known. */
2324 {
2325 tree storage_type
2332 init);
2334 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2344 /* If there is an initializing expression, then make a constructor for
2345 the entire object including the bounds and copy it into the object.
2346 If there is no initializing expression, just set the bounds. */
2348 {
2355 init);
2356 storage_init
2359 }
2360 else
2361 storage_init
2370 }
2374 /* If we have an initializing expression, see if its size is simpler
2375 than the size from the type. */
2381 /* If the size is still self-referential, reference the initializing
2382 expression, if it is present. If not, this must have been a
2383 call to allocate a library-level object, in which case we use
2384 the maximum size. */
2386 {
2389 else
2391 }
2393 /* If the size overflows, pass -1 so Storage_Error will be raised. */
2400 gnat_node));
2402 /* If we have an initial value, protect the new address, assign the value
2403 and return the address with a COMPOUND_EXPR. */
2405 {
2409 storage_init
2412 }
2415 }
2416 \f
2417 /* Indicate that we need to take the address of T and that it therefore
2418 should not be allocated in a register. Returns true if successful. */
2420 bool
2422 {
2425 {
2434 CASE_CONVERT:
2462 }
2463 }
2464 \f
2465 /* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c
2466 but we know how to handle our own nodes. */
2468 tree
2470 {
2478 {
2482 }
2484 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2485 This may be more efficient, but will also allow us to more easily find
2486 the match for the PLACEHOLDER_EXPR. */
2493 }
2495 /* Protect EXP for immediate reuse. This is a variant of gnat_save_expr that
2496 is optimized under the assumption that EXP's value doesn't change before
2497 its subsequent reuse(s) except through its potential reevaluation. */
2499 tree
2501 {
2508 /* If EXP has no side effects, we theoretically don't need to do anything.
2509 However, we may be recursively passed more and more complex expressions
2510 involving checks which will be reused multiple times and eventually be
2511 unshared for gimplification; in order to avoid a complexity explosion
2512 at that point, we protect any expressions more complex than a simple
2513 arithmetic expression. */
2515 {
2519 }
2521 /* If this is a conversion, protect what's inside the conversion. */
2527 /* If we're indirectly referencing something, we only need to protect the
2528 address since the data itself can't change in these situations. */
2530 {
2534 }
2536 /* If this is a COMPONENT_REF of a fat pointer, save the entire fat pointer.
2537 This may be more efficient, but will also allow us to more easily find
2538 the match for the PLACEHOLDER_EXPR. */
2544 /* If this is a fat pointer or something that can be placed in a register,
2545 just make a SAVE_EXPR. Likewise for a CALL_EXPR as large objects are
2546 returned via invisible reference in most ABIs so the temporary will
2547 directly be filled by the callee. */
2553 /* Otherwise reference, protect the address and dereference. */
2554 return
2558 exp)));
2559 }
2561 /* This is equivalent to stabilize_reference_1 in tree.c but we take an extra
2562 argument to force evaluation of everything. */
2564 static tree
2566 {
2569 tree result;
2571 /* We cannot ignore const expressions because it might be a reference
2572 to a const array but whose index contains side-effects. But we can
2573 ignore things that are actual constant or that already have been
2574 handled by this function. */
2579 {
2586 /* If this is a COMPONENT_REF of a fat pointer, save the entire
2587 fat pointer. This may be more efficient, but will also allow
2588 us to more easily find the match for the PLACEHOLDER_EXPR. */
2591 result
2595 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2596 so that it will only be evaluated once. */
2597 /* The tcc_reference and tcc_comparison classes could be handled as
2598 below, but it is generally faster to only evaluate them once. */
2601 else
2606 /* Recursively stabilize each operand. */
2607 result
2614 /* Recursively stabilize each operand. */
2615 result
2622 }
2624 /* See similar handling in gnat_stabilize_reference. */
2636 }
2638 /* This is equivalent to stabilize_reference in tree.c but we know how to
2639 handle our own nodes and we take extra arguments. FORCE says whether to
2640 force evaluation of everything. We set SUCCESS to true unless we walk
2641 through something we don't know how to stabilize. */
2643 tree
2645 {
2648 tree result;
2650 /* Assume we'll success unless proven otherwise. */
2655 {
2660 /* No action is needed in this case. */
2664 CASE_CONVERT:
2668 result
2671 success));
2678 force));
2684 success),
2691 success),
2699 success),
2701 force),
2712 success),
2714 success));
2718 /* Constructors with 1 element are used extensively to formally
2719 convert objects to special wrapping types. */
2722 {
2725 result
2728 force));
2729 }
2730 else
2731 {
2735 }
2741 /* ... fall through to failure ... */
2743 /* If arg isn't a kind of lvalue we recognize, make no change.
2744 Caller should recognize the error for an invalid lvalue. */
2749 }
2751 /* TREE_THIS_VOLATILE and TREE_SIDE_EFFECTS set on the initial expression
2752 may not be sustained across some paths, such as the way via build1 for
2753 INDIRECT_REF. We reset those flags here in the general case, which is
2754 consistent with the GCC version of this routine.
2756 Special care should be taken regarding TREE_SIDE_EFFECTS, because some
2757 paths introduce side-effects where there was none initially (e.g. if a
2758 SAVE_EXPR is built) and we also want to keep track of that. */
2770 }
2772 /* If EXPR is an expression that is invariant in the current function, in the
2773 sense that it can be evaluated anywhere in the function and any number of
2774 times, return EXPR or an equivalent expression. Otherwise return NULL. */
2776 tree
2778 {
2795 {
2797 {
2826 }
2829 }
2831 object:
2852 }