| blob | f9e50644a3e0069b613603775ae12ee4d2164577 |
1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /*@@ This file should be rewritten to use an arbitrary precision
21 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
22 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
23 @@ The routines that translate from the ap rep should
24 @@ warn if precision et. al. is lost.
25 @@ This would also make life easier when this technology is used
26 @@ for cross-compilers. */
28 /* The entry points in this file are fold, size_int_wide and size_binop.
30 fold takes a tree as argument and returns a simplified tree.
32 size_binop takes a tree code for an arithmetic operation
33 and two operands that are trees, and produces a tree for the
34 result, assuming the type comes from `sizetype'.
36 size_int takes an integer value, and creates a tree constant
37 with type from `sizetype'.
39 Note: Since the folders get called on non-gimple code as well as
40 gimple code, we need to handle GIMPLE tuples as well as their
41 corresponding tree equivalents. */
77 #ifndef LOAD_EXTEND_OP
78 #define LOAD_EXTEND_OP(M) UNKNOWN
79 #endif
81 /* Nonzero if we are folding constants inside an initializer; zero
82 otherwise. */
85 /* The following constants represent a bit based encoding of GCC's
86 comparison operators. This encoding simplifies transformations
87 on relational comparison operators, such as AND and OR. */
105 };
121 HOST_WIDE_INT *,
150 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
151 Otherwise, return LOC. */
153 static location_t
155 {
158 }
160 /* Similar to protected_set_expr_location, but never modify x in place,
161 if location can and needs to be set, unshare it. */
165 {
171 {
174 }
176 }
177 \f
178 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
179 division and returns the quotient. Otherwise returns
180 NULL_TREE. */
182 tree
184 {
185 widest_int quo;
192 }
193 \f
194 /* This is nonzero if we should defer warnings about undefined
195 overflow. This facility exists because these warnings are a
196 special case. The code to estimate loop iterations does not want
197 to issue any warnings, since it works with expressions which do not
198 occur in user code. Various bits of cleanup code call fold(), but
199 only use the result if it has certain characteristics (e.g., is a
200 constant); that code only wants to issue a warning if the result is
201 used. */
205 /* If a warning about undefined overflow is deferred, this is the
206 warning. Note that this may cause us to turn two warnings into
207 one, but that is fine since it is sufficient to only give one
208 warning per expression. */
212 /* If a warning about undefined overflow is deferred, this is the
213 level at which the warning should be emitted. */
217 /* Start deferring overflow warnings. We could use a stack here to
218 permit nested calls, but at present it is not necessary. */
220 void
222 {
224 }
226 /* Stop deferring overflow warnings. If there is a pending warning,
227 and ISSUE is true, then issue the warning if appropriate. STMT is
228 the statement with which the warning should be associated (used for
229 location information); STMT may be NULL. CODE is the level of the
230 warning--a warn_strict_overflow_code value. This function will use
231 the smaller of CODE and the deferred code when deciding whether to
232 issue the warning. CODE may be zero to mean to always use the
233 deferred code. */
235 void
237 {
239 location_t locus;
244 {
250 }
261 /* Use the smallest code level when deciding to issue the
262 warning. */
271 else
274 }
276 /* Stop deferring overflow warnings, ignoring any deferred
277 warnings. */
279 void
281 {
283 }
285 /* Whether we are deferring overflow warnings. */
287 bool
289 {
291 }
293 /* This is called when we fold something based on the fact that signed
294 overflow is undefined. */
296 static void
298 {
300 {
303 {
306 }
307 }
310 }
311 \f
312 /* Return true if the built-in mathematical function specified by CODE
313 is odd, i.e. -f(x) == f(-x). */
315 bool
317 {
319 {
353 }
355 }
357 /* Check whether we may negate an integer constant T without causing
358 overflow. */
360 bool
362 {
363 tree type;
372 }
374 /* Determine whether an expression T can be cheaply negated using
375 the function negate_expr without introducing undefined overflow. */
377 static bool
379 {
380 tree type;
389 {
394 /* Check that -CST will not overflow type. */
407 /* We want to canonicalize to positive real constants. Pretend
408 that only negative ones can be easily negated. */
416 {
427 }
442 /* -(A + B) -> (-B) - A. */
447 /* -(A + B) -> (-A) - B. */
451 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
462 /* INT_MIN/n * n doesn't overflow while negating one operand it does
463 if n is a power of two. */
472 /* Fall through. */
487 /* In general we can't negate B in A / B, because if A is INT_MIN and
488 B is 1, we may turn this into INT_MIN / -1 which is undefined
489 and actually traps on some architectures. */
498 /* Negate -((double)float) as (double)(-float). */
500 {
504 }
508 /* Negate -f(x) as f(-x). */
514 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
516 {
520 }
525 }
527 }
529 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
530 simplification is possible.
531 If negate_expr_p would return true for T, NULL_TREE will never be
532 returned. */
534 static tree
536 {
538 tree tem;
541 {
542 /* Convert - (~A) to A + 1. */
568 {
573 }
577 {
582 {
586 }
589 }
612 {
613 /* -(A + B) -> (-B) - A. */
617 {
621 }
623 /* -(A + B) -> (-A) - B. */
625 {
629 }
630 }
634 /* - (A - B) -> B - A */
646 /* Fall through. */
650 {
659 }
671 /* In general we can't negate B in A / B, because if A is INT_MIN and
672 B is 1, we may turn this into INT_MIN / -1 which is undefined
673 and actually traps on some architectures. */
685 /* Convert -((double)float) into (double)(-float). */
687 {
691 }
695 /* Negate -f(x) as f(-x). */
698 {
704 }
708 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
710 {
713 {
720 }
721 }
726 }
729 }
731 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
732 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
733 return NULL_TREE. */
735 static tree
737 {
739 location_t loc;
752 }
753 \f
754 /* Split a tree IN into a constant, literal and variable parts that could be
755 combined with CODE to make IN. "constant" means an expression with
756 TREE_CONSTANT but that isn't an actual constant. CODE must be a
757 commutative arithmetic operation. Store the constant part into *CONP,
758 the literal in *LITP and return the variable part. If a part isn't
759 present, set it to null. If the tree does not decompose in this way,
760 return the entire tree as the variable part and the other parts as null.
762 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
763 case, we negate an operand that was subtracted. Except if it is a
764 literal for which we use *MINUS_LITP instead.
766 If NEGATE_P is true, we are negating all of IN, again except a literal
767 for which we use *MINUS_LITP instead.
769 If IN is itself a literal or constant, return it as appropriate.
771 Note that we do not guarantee that any of the three values will be the
772 same type as IN, but they will have the same signedness and mode. */
774 static tree
777 {
784 /* Strip any conversions that don't change the machine mode or signedness. */
793 /* We can associate addition and subtraction together (even
794 though the C standard doesn't say so) for integers because
795 the value is not affected. For reals, the value might be
796 affected, so we can't. */
799 {
805 /* First see if either of the operands is a literal, then a constant. */
818 /* If we haven't dealt with either operand, this is not a case we can
819 decompose. Otherwise, VAR is either of the ones remaining, if any. */
824 else
827 /* Now do any needed negations. */
834 }
837 {
838 /* -X - 1 is folded to ~X, undo that here. */
841 }
844 else
848 {
855 }
858 }
860 /* Re-associate trees split by the above function. T1 and T2 are
861 either expressions to associate or null. Return the new
862 expression, if any. LOC is the location of the new expression. If
863 we build an operation, do it in TYPE and with CODE. */
865 static tree
867 {
873 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
874 try to fold this since we will have infinite recursion. But do
875 deal with any NEGATE_EXPRs. */
878 {
880 {
893 }
895 {
898 }
902 }
906 }
907 \f
908 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
909 for use in int_const_binop, size_binop and size_diffop. */
911 static bool
913 {
920 {
929 }
934 }
937 /* Combine two integer constants ARG1 and ARG2 under operation CODE
938 to produce a new constant. Return NULL_TREE if we don't know how
939 to evaluate CODE at compile-time. */
941 static tree
944 {
945 wide_int res;
946 tree t;
955 {
971 {
975 else
977 }
980 /* It's unclear from the C standard whether shifts can overflow.
981 The following code ignores overflow; perhaps a C standard
982 interpretation ruling is needed. */
984 else
991 {
995 else
997 }
1001 else
1080 }
1088 }
1090 tree
1092 {
1094 }
1096 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1097 constant. We assume ARG1 and ARG2 have the same data type, or at least
1098 are the same kind of constant and the same machine mode. Return zero if
1099 combining the constants is not allowed in the current operating mode. */
1101 static tree
1103 {
1104 /* Sanity check for the recursive cases. */
1112 {
1118 }
1121 {
1122 machine_mode mode;
1123 REAL_VALUE_TYPE d1;
1124 REAL_VALUE_TYPE d2;
1125 REAL_VALUE_TYPE value;
1126 REAL_VALUE_TYPE result;
1130 /* The following codes are handled by real_arithmetic. */
1132 {
1143 }
1151 /* Don't perform operation if we honor signaling NaNs and
1152 either operand is a NaN. */
1157 /* Don't perform operation if it would raise a division
1158 by zero exception. */
1164 /* If either operand is a NaN, just return it. Otherwise, set up
1165 for floating-point trap; we return an overflow. */
1174 /* Don't constant fold this floating point operation if
1175 the result has overflowed and flag_trapping_math. */
1183 /* Don't constant fold this floating point operation if the
1184 result may dependent upon the run-time rounding mode and
1185 flag_rounding_math is set, or if GCC's software emulation
1186 is unable to accurately represent the result. */
1196 }
1199 {
1200 FIXED_VALUE_TYPE f1;
1201 FIXED_VALUE_TYPE f2;
1202 FIXED_VALUE_TYPE result;
1207 /* The following codes are handled by fixed_arithmetic. */
1209 {
1221 {
1228 }
1233 }
1240 /* Propagate overflow flags. */
1244 }
1247 {
1256 {
1267 mpc_mul);
1281 mpc_div);
1282 /* Fallthru ... */
1288 {
1289 /* Keep this algorithm in sync with
1290 tree-complex.c:expand_complex_div_straight().
1292 Expand complex division to scalars, straightforward algorithm.
1293 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1294 t = br*br + bi*bi
1295 */
1296 tree magsquared
1300 tree t1
1304 tree t2
1311 }
1312 else
1313 {
1314 /* Keep this algorithm in sync with
1315 tree-complex.c:expand_complex_div_wide().
1317 Expand complex division to scalars, modified algorithm to minimize
1318 overflow with wide input ranges. */
1324 {
1325 /* In the TRUE branch, we compute
1326 ratio = br/bi;
1327 div = (br * ratio) + bi;
1328 tr = (ar * ratio) + ai;
1329 ti = (ai * ratio) - ar;
1330 tr = tr / div;
1331 ti = ti / div; */
1342 }
1343 else
1344 {
1345 /* In the FALSE branch, we compute
1346 ratio = d/c;
1347 divisor = (d * ratio) + c;
1348 tr = (b * ratio) + a;
1349 ti = b - (a * ratio);
1350 tr = tr / div;
1351 ti = ti / div; */
1363 }
1364 }
1369 }
1373 }
1377 {
1383 {
1389 /* It is possible that const_binop cannot handle the given
1390 code and return NULL_TREE */
1393 }
1396 }
1398 /* Shifts allow a scalar offset for a vector. */
1401 {
1407 {
1412 /* It is possible that const_binop cannot handle the given
1413 code and return NULL_TREE. */
1416 }
1419 }
1421 }
1423 /* Overload that adds a TYPE parameter to be able to dispatch
1424 to fold_relational_const. */
1426 tree
1428 {
1432 /* ??? Until we make the const_binop worker take the type of the
1433 result as argument put those cases that need it here. */
1435 {
1446 {
1462 {
1468 }
1471 }
1477 {
1502 {
1515 }
1518 }
1521 }
1526 /* Make sure type and arg0 have the same saturating flag. */
1531 }
1533 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1534 Return zero if computing the constants is not possible. */
1536 tree
1538 {
1540 {
1541 CASE_CONVERT:
1548 /* If the source address is 0, and the source address space
1549 cannot have a valid object at 0, fold to dest type null. */
1560 {
1561 /* Can't call fold_negate_const directly here as that doesn't
1562 handle all cases and we might not be able to negate some
1563 constants. */
1568 }
1577 {
1581 }
1587 /* Perform BIT_NOT_EXPR on each element individually. */
1589 {
1591 tree elem;
1596 {
1602 }
1605 }
1627 {
1646 else
1650 {
1654 }
1657 }
1662 {
1676 {
1681 }
1684 {
1688 }
1691 }
1695 }
1698 }
1700 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1701 indicates which particular sizetype to create. */
1703 tree
1705 {
1707 }
1708 \f
1709 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1710 is a tree code. The type of the result is taken from the operands.
1711 Both must be equivalent integer types, ala int_binop_types_match_p.
1712 If the operands are constant, so is the result. */
1714 tree
1716 {
1725 /* Handle the special case of two integer constants faster. */
1727 {
1728 /* And some specific cases even faster than that. */
1730 {
1735 }
1737 {
1740 }
1742 {
1745 }
1747 /* Handle general case of two integer constants. For sizetype
1748 constant calculations we always want to know about overflow,
1749 even in the unsigned case. */
1751 }
1754 }
1756 /* Given two values, either both of sizetype or both of bitsizetype,
1757 compute the difference between the two values. Return the value
1758 in signed type corresponding to the type of the operands. */
1760 tree
1762 {
1764 tree ctype;
1769 /* If the type is already signed, just do the simple thing. */
1777 else
1780 /* If either operand is not a constant, do the conversions to the signed
1781 type and subtract. The hardware will do the right thing with any
1782 overflow in the subtraction. */
1788 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1789 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1790 overflow) and negate (which can't either). Special-case a result
1791 of zero while we're here. */
1797 else
1801 MINUS_EXPR,
1803 }
1804 \f
1805 /* A subroutine of fold_convert_const handling conversions of an
1806 INTEGER_CST to another integer type. */
1808 static tree
1810 {
1811 /* Given an integer constant, make new constant with new type,
1812 appropriately sign-extended or truncated. Use widest_int
1813 so that any extension is done according ARG1's type. */
1817 }
1819 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1820 to an integer type. */
1822 static tree
1824 {
1826 tree t;
1828 /* The following code implements the floating point to integer
1829 conversion rules required by the Java Language Specification,
1830 that IEEE NaNs are mapped to zero and values that overflow
1831 the target precision saturate, i.e. values greater than
1832 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1833 are mapped to INT_MIN. These semantics are allowed by the
1834 C and C++ standards that simply state that the behavior of
1835 FP-to-integer conversion is unspecified upon overflow. */
1837 wide_int val;
1838 REAL_VALUE_TYPE r;
1842 {
1849 }
1851 /* If R is NaN, return zero and show we have an overflow. */
1853 {
1856 }
1858 /* See if R is less than the lower bound or greater than the
1859 upper bound. */
1862 {
1866 {
1869 }
1870 }
1873 {
1876 {
1879 {
1882 }
1883 }
1884 }
1891 }
1893 /* A subroutine of fold_convert_const handling conversions of a
1894 FIXED_CST to an integer type. */
1896 static tree
1898 {
1899 tree t;
1903 /* Right shift FIXED_CST to temp by fbit. */
1907 {
1909 HOST_BITS_PER_DOUBLE_INT,
1912 /* Left shift temp to temp_trunc by fbit. */
1914 HOST_BITS_PER_DOUBLE_INT,
1916 }
1917 else
1918 {
1921 }
1923 /* If FIXED_CST is negative, we need to round the value toward 0.
1924 By checking if the fractional bits are not zero to add 1 to temp. */
1930 /* Given a fixed-point constant, make new constant with new type,
1931 appropriately sign-extended or truncated. */
1939 }
1941 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1942 to another floating point type. */
1944 static tree
1946 {
1947 REAL_VALUE_TYPE value;
1948 tree t;
1953 /* If converting an infinity or NAN to a representation that doesn't
1954 have one, set the overflow bit so that we can produce some kind of
1955 error message at the appropriate point if necessary. It's not the
1956 most user-friendly message, but it's better than nothing. */
1963 /* Regular overflow, conversion produced an infinity in a mode that
1964 can't represent them. */
1969 else
1972 }
1974 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1975 to a floating point type. */
1977 static tree
1979 {
1980 REAL_VALUE_TYPE value;
1981 tree t;
1988 }
1990 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1991 to another fixed-point type. */
1993 static tree
1995 {
1996 FIXED_VALUE_TYPE value;
1997 tree t;
2004 /* Propagate overflow flags. */
2008 }
2010 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2011 to a fixed-point type. */
2013 static tree
2015 {
2016 FIXED_VALUE_TYPE value;
2017 tree t;
2019 double_int di;
2026 else
2034 /* Propagate overflow flags. */
2038 }
2040 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2041 to a fixed-point type. */
2043 static tree
2045 {
2046 FIXED_VALUE_TYPE value;
2047 tree t;
2055 /* Propagate overflow flags. */
2059 }
2061 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2062 type TYPE. If no simplification can be done return NULL_TREE. */
2064 static tree
2066 {
2072 {
2079 }
2081 {
2088 }
2090 {
2097 }
2099 }
2101 /* Construct a vector of zero elements of vector type TYPE. */
2103 static tree
2105 {
2106 tree t;
2110 }
2112 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2114 bool
2116 {
2131 {
2150 }
2151 }
2153 /* Convert expression ARG to type TYPE. Used by the middle-end for
2154 simple conversions in preference to calling the front-end's convert. */
2156 tree
2158 {
2160 tree tem;
2171 {
2174 /* Handle conversions between pointers to different address spaces. */
2179 /* fall through */
2184 {
2188 }
2202 {
2206 }
2208 {
2212 }
2214 {
2218 }
2221 {
2239 }
2244 {
2248 }
2251 {
2265 }
2269 {
2278 integer_zero_node));
2280 {
2284 {
2290 }
2298 }
2302 }
2320 }
2321 fold_convert_exit:
2324 }
2325 \f
2326 /* Return false if expr can be assumed not to be an lvalue, true
2327 otherwise. */
2329 static bool
2331 {
2332 /* We only need to wrap lvalue tree codes. */
2334 {
2365 /* Assume the worst for front-end tree codes. */
2369 }
2372 }
2374 /* Return an expr equal to X but certainly not valid as an lvalue. */
2376 tree
2378 {
2379 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2380 us. */
2387 }
2389 /* When pedantic, return an expr equal to X but certainly not valid as a
2390 pedantic lvalue. Otherwise, return X. */
2392 static tree
2394 {
2396 }
2397 \f
2398 /* Given a tree comparison code, return the code that is the logical inverse.
2399 It is generally not safe to do this for floating-point comparisons, except
2400 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2401 ERROR_MARK in this case. */
2403 enum tree_code
2405 {
2411 {
2442 }
2443 }
2445 /* Similar, but return the comparison that results if the operands are
2446 swapped. This is safe for floating-point. */
2448 enum tree_code
2450 {
2452 {
2478 }
2479 }
2482 /* Convert a comparison tree code from an enum tree_code representation
2483 into a compcode bit-based encoding. This function is the inverse of
2484 compcode_to_comparison. */
2486 static enum comparison_code
2488 {
2490 {
2521 }
2522 }
2524 /* Convert a compcode bit-based encoding of a comparison operator back
2525 to GCC's enum tree_code representation. This function is the
2526 inverse of comparison_to_compcode. */
2528 static enum tree_code
2530 {
2532 {
2563 }
2564 }
2566 /* Return a tree for the comparison which is the combination of
2567 doing the AND or OR (depending on CODE) of the two operations LCODE
2568 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2569 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2570 if this makes the transformation invalid. */
2572 tree
2577 {
2584 {
2595 }
2598 {
2599 /* Eliminate unordered comparisons, as well as LTGT and ORD
2600 which are not used unless the mode has NaNs. */
2606 }
2608 {
2609 /* Check that the original operation and the optimized ones will trap
2610 under the same condition. */
2621 /* In a short-circuited boolean expression the LHS might be
2622 such that the RHS, if evaluated, will never trap. For
2623 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2624 if neither x nor y is NaN. (This is a mixed blessing: for
2625 example, the expression above will never trap, hence
2626 optimizing it to x < y would be invalid). */
2631 /* If the comparison was short-circuited, and only the RHS
2632 trapped, we may now generate a spurious trap. */
2637 /* If we changed the conditions that cause a trap, we lose. */
2640 }
2646 else
2647 {
2652 }
2653 }
2654 \f
2655 /* Return nonzero if two operands (typically of the same tree node)
2656 are necessarily equal. FLAGS modifies behavior as follows:
2658 If OEP_ONLY_CONST is set, only return nonzero for constants.
2659 This function tests whether the operands are indistinguishable;
2660 it does not test whether they are equal using C's == operation.
2661 The distinction is important for IEEE floating point, because
2662 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2663 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2665 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2666 even though it may hold multiple values during a function.
2667 This is because a GCC tree node guarantees that nothing else is
2668 executed between the evaluation of its "operands" (which may often
2669 be evaluated in arbitrary order). Hence if the operands themselves
2670 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2671 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2672 unset means assuming isochronic (or instantaneous) tree equivalence.
2673 Unless comparing arbitrary expression trees, such as from different
2674 statements, this flag can usually be left unset.
2676 If OEP_PURE_SAME is set, then pure functions with identical arguments
2677 are considered the same. It is used when the caller has other ways
2678 to ensure that global memory is unchanged in between.
2680 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2681 not values of expressions.
2683 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2684 any operand with side effect. This is unnecesarily conservative in the
2685 case we know that arg0 and arg1 are in disjoint code paths (such as in
2686 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2687 addresses with TREE_CONSTANT flag set so we know that &var == &var
2688 even if var is volatile. */
2690 int
2692 {
2693 /* If either is ERROR_MARK, they aren't equal. */
2699 /* Similar, if either does not have a type (like a released SSA name),
2700 they aren't equal. */
2704 /* We cannot consider pointers to different address space equal. */
2711 /* Check equality of integer constants before bailing out due to
2712 precision differences. */
2714 {
2715 /* Address of INTEGER_CST is not defined; check that we did not forget
2716 to drop the OEP_ADDRESS_OF flags. */
2719 }
2722 {
2723 /* If both types don't have the same signedness, then we can't consider
2724 them equal. We must check this before the STRIP_NOPS calls
2725 because they may change the signedness of the arguments. As pointers
2726 strictly don't have a signedness, require either two pointers or
2727 two non-pointers as well. */
2733 /* If both types don't have the same precision, then it is not safe
2734 to strip NOPs. */
2741 }
2742 #if 0
2743 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2744 sanity check once the issue is solved. */
2745 else
2746 /* Addresses of conversions and SSA_NAMEs (and many other things)
2747 are not defined. Check that we did not forget to drop the
2748 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2751 #endif
2753 /* In case both args are comparisons but with different comparison
2754 code, try to swap the comparison operands of one arg to produce
2755 a match and compare that variant. */
2759 {
2767 }
2770 {
2771 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2773 ;
2775 {
2776 /* If we are interested in comparing addresses ignore
2777 MEM_REF wrappings of the base that can appear just for
2778 TBAA reasons. */
2792 }
2793 else
2795 }
2797 /* When not checking adddresses, this is needed for conversions and for
2798 COMPONENT_REF. Might as well play it safe and always test this. */
2805 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2806 We don't care about side effects in that case because the SAVE_EXPR
2807 takes care of that for us. In all other cases, two expressions are
2808 equal if they have no side effects. If we have two identical
2809 expressions with side effects that should be treated the same due
2810 to the only side effects being identical SAVE_EXPR's, that will
2811 be detected in the recursive calls below.
2812 If we are taking an invariant address of two identical objects
2813 they are necessarily equal as well. */
2820 /* Next handle constant cases, those for which we can return 1 even
2821 if ONLY_CONST is set. */
2824 {
2838 {
2839 /* If we do not distinguish between signed and unsigned zero,
2840 consider them equal. */
2843 }
2847 {
2854 {
2858 }
2860 }
2864 flags)
2866 flags));
2877 flags | OEP_ADDRESS_OF
2880 /* In GIMPLE empty constructors are allowed in initializers of
2881 aggregates. */
2886 }
2891 /* Define macros to test an operand from arg0 and arg1 for equality and a
2892 variant that allows null and views null as being different from any
2893 non-null value. In the latter case, if either is null, the both
2894 must be; otherwise, do the normal comparison. */
2895 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2896 TREE_OPERAND (arg1, N), flags)
2898 #define OP_SAME_WITH_NULL(N) \
2899 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2900 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2903 {
2905 /* Two conversions are equal only if signedness and modes match. */
2907 {
2908 CASE_CONVERT:
2916 }
2926 /* For commutative ops, allow the other order. */
2934 /* If either of the pointer (or reference) expressions we are
2935 dereferencing contain a side effect, these cannot be equal,
2936 but their addresses can be. */
2943 {
2960 {
2961 /* Require equal access sizes */
2967 flags)))
2969 /* Verify that accesses are TBAA compatible. */
2971 && (!alias_ptr_types_compatible_p
2979 /* Verify that alignment is compatible. */
2983 }
2986 /* TARGET_MEM_REF require equal extra operands. */
2994 /* Operands 2 and 3 may be null.
2995 Compare the array index by value if it is constant first as we
2996 may have different types but same value here. */
3007 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3008 may be NULL when we're called to compare MEM_EXPRs. */
3023 }
3027 {
3029 /* Be sure we pass right ADDRESS_OF flag. */
3047 /* The multiplcation operands are commutative. */
3048 /* FALLTHRU */
3056 /* Otherwise take into account this is a commutative operation. */
3069 }
3073 {
3077 /* If not both CALL_EXPRs are either internal or normal function
3078 functions, then they are not equal. */
3081 {
3082 /* If the CALL_EXPRs call different internal functions, then they
3083 are not equal. */
3086 }
3087 else
3088 {
3089 /* If the CALL_EXPRs call different functions, then they are not
3090 equal. */
3092 flags))
3094 }
3096 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3097 {
3101 else
3105 }
3107 /* Now see if all the arguments are the same. */
3108 {
3119 /* If we get here and both argument lists are exhausted
3120 then the CALL_EXPRs are equal. */
3122 }
3125 }
3128 /* Consider __builtin_sqrt equal to sqrt. */
3136 {
3137 /* In GIMPLE constructors are used only to build vectors from
3138 elements. Individual elements in the constructor must be
3139 indexed in increasing order and form an initial sequence.
3141 We make no effort to compare constructors in generic.
3142 (see sem_variable::equals in ipa-icf which can do so for
3143 constants). */
3148 /* Be sure that vectors constructed have the same representation.
3149 We only tested element precision and modes to match.
3150 Vectors may be BLKmode and thus also check that the number of
3151 parts match. */
3164 {
3169 /* In GIMPLE the indexes can be either NULL or matching i.
3170 Double check this so we won't get false
3171 positives for GENERIC. */
3179 }
3181 }
3186 }
3188 #undef OP_SAME
3189 #undef OP_SAME_WITH_NULL
3190 }
3191 \f
3192 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3193 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3195 When in doubt, return 0. */
3197 static int
3199 {
3211 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3212 and see if the inner values are the same. This removes any
3213 signedness comparison, which doesn't matter here. */
3220 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3221 actual comparison operand, ARG0.
3223 First throw away any conversions to wider types
3224 already present in the operands. */
3233 {
3236 /* Make sure shorter operand is extended the right way
3237 to match the longer operand. */
3243 }
3246 }
3247 \f
3248 /* See if ARG is an expression that is either a comparison or is performing
3249 arithmetic on comparisons. The comparisons must only be comparing
3250 two different values, which will be stored in *CVAL1 and *CVAL2; if
3251 they are nonzero it means that some operands have already been found.
3252 No variables may be used anywhere else in the expression except in the
3253 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3254 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3256 If this is true, return 1. Otherwise, return zero. */
3258 static int
3260 {
3264 /* We can handle some of the tcc_expression cases here. */
3274 {
3275 /* If we've already found a CVAL1 or CVAL2, this expression is
3276 two complex to handle. */
3282 }
3285 {
3308 /* First see if we can handle the first operand, then the second. For
3309 the second operand, we know *CVAL1 can't be zero. It must be that
3310 one side of the comparison is each of the values; test for the
3311 case where this isn't true by failing if the two operands
3312 are the same. */
3321 ;
3325 ;
3326 else
3330 ;
3334 ;
3335 else
3342 }
3343 }
3344 \f
3345 /* ARG is a tree that is known to contain just arithmetic operations and
3346 comparisons. Evaluate the operations in the tree substituting NEW0 for
3347 any occurrence of OLD0 as an operand of a comparison and likewise for
3348 NEW1 and OLD1. */
3350 static tree
3353 {
3358 /* We can handle some of the tcc_expression cases here. */
3366 {
3381 {
3400 }
3401 /* Fall through - ??? */
3404 {
3408 /* We need to check both for exact equality and tree equality. The
3409 former will be true if the operand has a side-effect. In that
3410 case, we know the operand occurred exactly once. */
3423 }
3427 }
3428 }
3429 \f
3430 /* Return a tree for the case when the result of an expression is RESULT
3431 converted to TYPE and OMITTED was previously an operand of the expression
3432 but is now not needed (e.g., we folded OMITTED * 0).
3434 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3435 the conversion of RESULT to TYPE. */
3437 tree
3439 {
3442 /* If the resulting operand is an empty statement, just return the omitted
3443 statement casted to void. */
3453 }
3455 /* Return a tree for the case when the result of an expression is RESULT
3456 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3457 of the expression but are now not needed.
3459 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3460 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3461 evaluated before OMITTED2. Otherwise, if neither has side effects,
3462 just do the conversion of RESULT to TYPE. */
3464 tree
3467 {
3476 }
3478 \f
3479 /* Return a simplified tree node for the truth-negation of ARG. This
3480 never alters ARG itself. We assume that ARG is an operation that
3481 returns a truth value (0 or 1).
3483 FIXME: one would think we would fold the result, but it causes
3484 problems with the dominator optimizer. */
3486 static tree
3488 {
3493 /* If this is a comparison, we can simply invert it, except for
3494 floating-point non-equality comparisons, in which case we just
3495 enclose a TRUTH_NOT_EXPR around what we have. */
3498 {
3501 && flag_trapping_math
3512 }
3515 {
3534 /* Here we can invert either operand. We invert the first operand
3535 unless the second operand is a TRUTH_NOT_EXPR in which case our
3536 result is the XOR of the first operand with the inside of the
3537 negation of the second operand. */
3542 else
3565 {
3572 /* A COND_EXPR may have a throw as one operand, which
3573 then has void type. Just leave void operands
3574 as they are. */
3580 }
3592 CASE_CONVERT:
3596 /* ... fall through ... */
3618 }
3619 }
3621 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3622 assume that ARG is an operation that returns a truth value (0 or 1
3623 for scalars, 0 or -1 for vectors). Return the folded expression if
3624 folding is successful. Otherwise, return NULL_TREE. */
3626 static tree
3628 {
3631 ? BIT_NOT_EXPR
3634 }
3636 /* Return a simplified tree node for the truth-negation of ARG. This
3637 never alters ARG itself. We assume that ARG is an operation that
3638 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3640 tree
3642 {
3648 ? BIT_NOT_EXPR
3651 }
3653 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3654 with code CODE. This optimization is unsafe. */
3655 static tree
3658 {
3662 /* (A / C) +- (B / C) -> (A +- B) / C. */
3672 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3677 {
3689 }
3692 }
3693 \f
3694 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3695 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3696 and uses reverse storage order if REVERSEP is nonzero. */
3698 static tree
3702 {
3706 {
3713 }
3728 }
3730 /* Optimize a bit-field compare.
3732 There are two cases: First is a compare against a constant and the
3733 second is a comparison of two items where the fields are at the same
3734 bit position relative to the start of a chunk (byte, halfword, word)
3735 large enough to contain it. In these cases we can avoid the shift
3736 implicit in bitfield extractions.
3738 For constants, we emit a compare of the shifted constant with the
3739 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3740 compared. For two fields at the same position, we do the ANDs with the
3741 similar mask and compare the result of the ANDs.
3743 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3744 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3745 are the left and right operands of the comparison, respectively.
3747 If the optimization described above can be done, we return the resulting
3748 tree. Otherwise we return zero. */
3750 static tree
3753 {
3756 tree unsigned_type;
3763 tree mask;
3764 tree offset;
3766 /* Get all the information about the extractions being done. If the bit size
3767 if the same as the size of the underlying object, we aren't doing an
3768 extraction at all and so can do nothing. We also don't want to
3769 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3770 then will no longer be able to replace it. */
3779 else
3780 {
3781 /* If this is not a constant, we can only do something if bit positions,
3782 sizes, signedness and storage order are the same. */
3783 rinner
3791 }
3793 /* See if we can find a mode to refer to this field. We should be able to,
3794 but fail if we can't. */
3803 /* Set signed and unsigned types of the precision of this mode for the
3804 shifts below. */
3807 /* Compute the bit position and size for the new reference and our offset
3808 within it. If the new reference is the same size as the original, we
3809 won't optimize anything, so return zero. */
3819 /* Make the mask to be used against the extracted field. */
3826 /* If not comparing with constant, just rework the comparison
3827 and return. */
3831 unsigned_type,
3834 mask),
3837 unsigned_type,
3840 mask));
3842 /* Otherwise, we are handling the constant case. See if the constant is too
3843 big for the field. Warn and return a tree for 0 (false) if so. We do
3844 this not only for its own sake, but to avoid having to test for this
3845 error case below. If we didn't, we might generate wrong code.
3847 For unsigned fields, the constant shifted right by the field length should
3848 be all zero. For signed fields, the high-order bits should agree with
3849 the sign bit. */
3852 {
3854 {
3858 }
3859 }
3860 else
3861 {
3864 {
3868 }
3869 }
3871 /* Single-bit compares should always be against zero. */
3873 {
3876 }
3878 /* Make a new bitfield reference, shift the constant over the
3879 appropriate number of bits and mask it with the computed mask
3880 (in case this was a signed field). If we changed it, make a new one. */
3882 lreversep);
3888 mask);
3893 }
3894 \f
3895 /* Subroutine for fold_truth_andor_1: decode a field reference.
3897 If EXP is a comparison reference, we return the innermost reference.
3899 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3900 set to the starting bit number.
3902 If the innermost field can be completely contained in a mode-sized
3903 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3905 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3906 otherwise it is not changed.
3908 *PUNSIGNEDP is set to the signedness of the field.
3910 *PREVERSEP is set to the storage order of the field.
3912 *PMASK is set to the mask used. This is either contained in a
3913 BIT_AND_EXPR or derived from the width of the field.
3915 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3917 Return 0 if this is not a component reference or is one that we can't
3918 do anything with. */
3920 static tree
3925 {
3929 tree unsigned_type;
3932 /* All the optimizations using this function assume integer fields.
3933 There are problems with FP fields since the type_for_size call
3934 below can fail for, e.g., XFmode. */
3938 /* We are interested in the bare arrangement of bits, so strip everything
3939 that doesn't affect the machine mode. However, record the type of the
3940 outermost expression if it may matter below. */
3947 {
3953 }
3962 /* If the number of bits in the reference is the same as the bitsize of
3963 the outer type, then the outer type gives the signedness. Otherwise
3964 (in case of a small bitfield) the signedness is unchanged. */
3968 /* Compute the mask to access the bitfield. */
3977 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3985 }
3987 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3988 bit positions and MASK is SIGNED. */
3990 static int
3992 {
3996 /* If this function returns true when the type of the mask is
3997 UNSIGNED, then there will be errors. In particular see
3998 gcc.c-torture/execute/990326-1.c. There does not appear to be
3999 any documentation paper trail as to why this is so. But the pre
4000 wide-int worked with that restriction and it has been preserved
4001 here. */
4006 }
4008 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4009 represents the sign bit of EXP's type. If EXP represents a sign
4010 or zero extension, also test VAL against the unextended type.
4011 The return value is the (sub)expression whose sign bit is VAL,
4012 or NULL_TREE otherwise. */
4014 tree
4016 {
4018 tree t;
4020 /* Tree EXP must have an integral type. */
4025 /* Tree VAL must be an integer constant. */
4034 /* Handle extension from a narrower type. */
4040 }
4042 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4043 to be evaluated unconditionally. */
4045 static int
4047 {
4048 /* Strip any conversions that don't change the machine mode. */
4057 /* Don't regard global variables as simple. They may be
4058 allocated in ways unknown to the compiler (shared memory,
4059 #pragma weak, etc). */
4062 /* Weakrefs are not safe to be read, since they can be NULL.
4063 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4064 have DECL_WEAK flag set. */
4066 /* Loading a static variable is unduly expensive, but global
4067 registers aren't expensive. */
4069 }
4071 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4072 to be evaluated unconditionally.
4073 I addition to simple_operand_p, we assume that comparisons, conversions,
4074 and logic-not operations are simple, if their operands are simple, too. */
4076 static bool
4078 {
4098 }
4100 \f
4101 /* The following functions are subroutines to fold_range_test and allow it to
4102 try to change a logical combination of comparisons into a range test.
4104 For example, both
4105 X == 2 || X == 3 || X == 4 || X == 5
4106 and
4107 X >= 2 && X <= 5
4108 are converted to
4109 (unsigned) (X - 2) <= 3
4111 We describe each set of comparisons as being either inside or outside
4112 a range, using a variable named like IN_P, and then describe the
4113 range with a lower and upper bound. If one of the bounds is omitted,
4114 it represents either the highest or lowest value of the type.
4116 In the comments below, we represent a range by two numbers in brackets
4117 preceded by a "+" to designate being inside that range, or a "-" to
4118 designate being outside that range, so the condition can be inverted by
4119 flipping the prefix. An omitted bound is represented by a "-". For
4120 example, "- [-, 10]" means being outside the range starting at the lowest
4121 possible value and ending at 10, in other words, being greater than 10.
4122 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4123 always false.
4125 We set up things so that the missing bounds are handled in a consistent
4126 manner so neither a missing bound nor "true" and "false" need to be
4127 handled using a special case. */
4129 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4130 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4131 and UPPER1_P are nonzero if the respective argument is an upper bound
4132 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4133 must be specified for a comparison. ARG1 will be converted to ARG0's
4134 type if both are specified. */
4136 static tree
4139 {
4140 tree tem;
4144 /* If neither arg represents infinity, do the normal operation.
4145 Else, if not a comparison, return infinity. Else handle the special
4146 comparison rules. Note that most of the cases below won't occur, but
4147 are handled for consistency. */
4150 {
4155 }
4160 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4161 for neither. In real maths, we cannot assume open ended ranges are
4162 the same. But, this is computer arithmetic, where numbers are finite.
4163 We can therefore make the transformation of any unbounded range with
4164 the value Z, Z being greater than any representable number. This permits
4165 us to treat unbounded ranges as equal. */
4169 {
4190 }
4193 }
4194 \f
4195 /* Helper routine for make_range. Perform one step for it, return
4196 new expression if the loop should continue or NULL_TREE if it should
4197 stop. */
4199 tree
4203 {
4209 {
4211 /* We can only do something if the range is testing for zero. */
4220 /* We can only do something if the range is testing for zero
4221 and if the second operand is an integer constant. Note that
4222 saying something is "in" the range we make is done by
4223 complementing IN_P since it will set in the initial case of
4224 being not equal to zero; "out" is leaving it alone. */
4231 {
4252 }
4254 /* If this is an unsigned comparison, we also know that EXP is
4255 greater than or equal to zero. We base the range tests we make
4256 on that fact, so we record it here so we can parse existing
4257 range tests. We test arg0_type since often the return type
4258 of, e.g. EQ_EXPR, is boolean. */
4260 {
4264 NULL_TREE))
4269 /* If the high bound is missing, but we have a nonzero low
4270 bound, reverse the range so it goes from zero to the low bound
4271 minus 1. */
4273 {
4278 }
4279 }
4287 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4288 low and high are non-NULL, then normalize will DTRT. */
4291 {
4296 }
4298 /* (-x) IN [a,b] -> x in [-b, -a] */
4310 /* ~ X -> -X - 1 */
4319 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4320 move a constant to the other side. */
4325 /* If EXP is signed, any overflow in the computation is undefined,
4326 so we don't worry about it so long as our computations on
4327 the bounds don't overflow. For unsigned, overflow is defined
4328 and this is exactly the right thing. */
4340 normalize:
4341 /* Check for an unsigned range which has wrapped around the maximum
4342 value thus making n_high < n_low, and normalize it. */
4344 {
4350 /* If the range is of the form +/- [ x+1, x ], we won't
4351 be able to normalize it. But then, it represents the
4352 whole range or the empty set, so make it
4353 +/- [ -, - ]. */
4357 else
4359 }
4360 else
4368 CASE_CONVERT:
4386 /* If we're converting arg0 from an unsigned type, to exp,
4387 a signed type, we will be doing the comparison as unsigned.
4388 The tests above have already verified that LOW and HIGH
4389 are both positive.
4391 So we have to ensure that we will handle large unsigned
4392 values the same way that the current signed bounds treat
4393 negative values. */
4396 {
4397 tree high_positive;
4398 tree equiv_type;
4399 /* For fixed-point modes, we need to pass the saturating flag
4400 as the 2nd parameter. */
4402 equiv_type
4405 else
4406 equiv_type
4409 /* A range without an upper bound is, naturally, unbounded.
4410 Since convert would have cropped a very large value, use
4411 the max value for the destination type. */
4412 high_positive
4419 high_positive),
4422 /* If the low bound is specified, "and" the range with the
4423 range for which the original unsigned value will be
4424 positive. */
4426 {
4429 integer_zero_node),
4430 high_positive))
4434 }
4435 else
4436 {
4437 /* Otherwise, "or" the range with the range of the input
4438 that will be interpreted as negative. */
4441 integer_zero_node),
4442 high_positive))
4446 }
4447 }
4456 }
4457 }
4459 /* Given EXP, a logical expression, set the range it is testing into
4460 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4461 actually being tested. *PLOW and *PHIGH will be made of the same
4462 type as the returned expression. If EXP is not a comparison, we
4463 will most likely not be returning a useful value and range. Set
4464 *STRICT_OVERFLOW_P to true if the return value is only valid
4465 because signed overflow is undefined; otherwise, do not change
4466 *STRICT_OVERFLOW_P. */
4468 tree
4471 {
4479 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4480 and see if we can refine the range. Some of the cases below may not
4481 happen, but it doesn't seem worth worrying about this. We "continue"
4482 the outer loop when we've changed something; otherwise we "break"
4483 the switch, which will "break" the while. */
4489 {
4495 {
4503 }
4512 }
4514 /* If EXP is a constant, we can evaluate whether this is true or false. */
4516 {
4523 }
4527 }
4528 \f
4529 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4530 type, TYPE, return an expression to test if EXP is in (or out of, depending
4531 on IN_P) the range. Return 0 if the test couldn't be created. */
4533 tree
4536 {
4539 /* Disable this optimization for function pointer expressions
4540 on targets that require function pointer canonicalization. */
4547 {
4553 }
4571 {
4573 {
4577 }
4579 }
4581 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4583 {
4587 {
4589 {
4592 etype
4594 else
4597 }
4600 }
4601 }
4603 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4604 This requires wrap-around arithmetics for the type of the expression.
4605 First make sure that arithmetics in this type is valid, then make sure
4606 that it wraps around. */
4612 {
4615 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4616 for the type in question, as we rely on this here. */
4626 else
4628 }
4638 {
4640 {
4645 }
4647 }
4655 }
4656 \f
4657 /* Return the predecessor of VAL in its type, handling the infinite case. */
4659 static tree
4661 {
4667 else
4670 }
4672 /* Return the successor of VAL in its type, handling the infinite case. */
4674 static tree
4676 {
4682 else
4685 }
4687 /* Given two ranges, see if we can merge them into one. Return 1 if we
4688 can, 0 if we can't. Set the output range into the specified parameters. */
4690 bool
4693 {
4697 tree tem;
4707 /* Make range 0 be the range that starts first, or ends last if they
4708 start at the same value. Swap them if it isn't. */
4711 || (lowequal
4714 {
4718 }
4720 /* Now flag two cases, whether the ranges are disjoint or whether the
4721 second range is totally subsumed in the first. Note that the tests
4722 below are simplified by the ones above. */
4728 /* We now have four cases, depending on whether we are including or
4729 excluding the two ranges. */
4731 {
4732 /* If they don't overlap, the result is false. If the second range
4733 is a subset it is the result. Otherwise, the range is from the start
4734 of the second to the end of the first. */
4739 else
4741 }
4744 {
4745 /* If they don't overlap, the result is the first range. If they are
4746 equal, the result is false. If the second range is a subset of the
4747 first, and the ranges begin at the same place, we go from just after
4748 the end of the second range to the end of the first. If the second
4749 range is not a subset of the first, or if it is a subset and both
4750 ranges end at the same place, the range starts at the start of the
4751 first range and ends just before the second range.
4752 Otherwise, we can't describe this as a single range. */
4758 {
4763 {
4764 /* We are in the weird situation where high0 > high1 but
4765 high1 has no successor. Punt. */
4767 }
4768 }
4770 {
4775 {
4776 /* low0 < low1 but low1 has no predecessor. Punt. */
4778 }
4779 }
4780 else
4782 }
4785 {
4786 /* If they don't overlap, the result is the second range. If the second
4787 is a subset of the first, the result is false. Otherwise,
4788 the range starts just after the first range and ends at the
4789 end of the second. */
4794 else
4795 {
4800 {
4801 /* high1 > high0 but high0 has no successor. Punt. */
4803 }
4804 }
4805 }
4807 else
4808 {
4809 /* The case where we are excluding both ranges. Here the complex case
4810 is if they don't overlap. In that case, the only time we have a
4811 range is if they are adjacent. If the second is a subset of the
4812 first, the result is the first. Otherwise, the range to exclude
4813 starts at the beginning of the first range and ends at the end of the
4814 second. */
4816 {
4821 else
4822 {
4823 /* Canonicalize - [min, x] into - [-, x]. */
4826 {
4831 /* FALLTHROUGH */
4844 }
4846 /* Canonicalize - [x, max] into - [x, -]. */
4849 {
4854 /* FALLTHROUGH */
4870 }
4872 /* The ranges might be also adjacent between the maximum and
4873 minimum values of the given type. For
4874 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4875 return + [x + 1, y - 1]. */
4877 {
4884 }
4885 else
4887 }
4888 }
4891 else
4893 }
4897 }
4898 \f
4900 /* Subroutine of fold, looking inside expressions of the form
4901 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4902 of the COND_EXPR. This function is being used also to optimize
4903 A op B ? C : A, by reversing the comparison first.
4905 Return a folded expression whose code is not a COND_EXPR
4906 anymore, or NULL_TREE if no folding opportunity is found. */
4908 static tree
4911 {
4916 tree tem;
4921 /* If we have A op 0 ? A : -A, consider applying the following
4922 transformations:
4924 A == 0? A : -A same as -A
4925 A != 0? A : -A same as A
4926 A >= 0? A : -A same as abs (A)
4927 A > 0? A : -A same as abs (A)
4928 A <= 0? A : -A same as -abs (A)
4929 A < 0? A : -A same as -abs (A)
4931 None of these transformations work for modes with signed
4932 zeros. If A is +/-0, the first two transformations will
4933 change the sign of the result (from +0 to -0, or vice
4934 versa). The last four will fix the sign of the result,
4935 even though the original expressions could be positive or
4936 negative, depending on the sign of A.
4938 Note that all these transformations are correct if A is
4939 NaN, since the two alternatives (A and -A) are also NaNs. */
4946 /* In the case that A is of the form X-Y, '-A' (arg2) may
4947 have already been folded to Y-X, check for that. */
4955 {
4969 /* Fall through. */
4989 }
4991 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4992 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4993 both transformations are correct when A is NaN: A != 0
4994 is then true, and A == 0 is false. */
4998 {
5003 }
5005 /* Try some transformations of A op B ? A : B.
5007 A == B? A : B same as B
5008 A != B? A : B same as A
5009 A >= B? A : B same as max (A, B)
5010 A > B? A : B same as max (B, A)
5011 A <= B? A : B same as min (A, B)
5012 A < B? A : B same as min (B, A)
5014 As above, these transformations don't work in the presence
5015 of signed zeros. For example, if A and B are zeros of
5016 opposite sign, the first two transformations will change
5017 the sign of the result. In the last four, the original
5018 expressions give different results for (A=+0, B=-0) and
5019 (A=-0, B=+0), but the transformed expressions do not.
5021 The first two transformations are correct if either A or B
5022 is a NaN. In the first transformation, the condition will
5023 be false, and B will indeed be chosen. In the case of the
5024 second transformation, the condition A != B will be true,
5025 and A will be chosen.
5027 The conversions to max() and min() are not correct if B is
5028 a number and A is not. The conditions in the original
5029 expressions will be false, so all four give B. The min()
5030 and max() versions would give a NaN instead. */
5033 /* Avoid these transformations if the COND_EXPR may be used
5034 as an lvalue in the C++ front-end. PR c++/19199. */
5035 && (in_gimple_form
5041 {
5046 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5048 {
5052 }
5055 {
5064 /* In C++ a ?: expression can be an lvalue, so put the
5065 operand which will be used if they are equal first
5066 so that we can convert this back to the
5067 corresponding COND_EXPR. */
5069 {
5078 }
5085 {
5094 }
5109 }
5110 }
5112 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5113 we might still be able to simplify this. For example,
5114 if C1 is one less or one more than C2, this might have started
5115 out as a MIN or MAX and been transformed by this function.
5116 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5122 {
5126 /* We can replace A with C1 in this case. */
5131 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5132 MIN_EXPR, to preserve the signedness of the comparison. */
5134 OEP_ONLY_CONST)
5138 OEP_ONLY_CONST))
5139 {
5142 arg2));
5145 }
5149 /* If C1 is C2 - 1, this is min(A, C2), with the same care
5150 as above. */
5152 OEP_ONLY_CONST)
5156 OEP_ONLY_CONST))
5157 {
5160 arg2));
5163 }
5167 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5168 MAX_EXPR, to preserve the signedness of the comparison. */
5170 OEP_ONLY_CONST)
5174 OEP_ONLY_CONST))
5175 {
5178 arg2));
5180 }
5184 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5186 OEP_ONLY_CONST)
5190 OEP_ONLY_CONST))
5191 {
5194 arg2));
5196 }
5202 }
5205 }
5208 \f
5209 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5210 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5211 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5212 false) >= 2)
5213 #endif
5215 /* EXP is some logical combination of boolean tests. See if we can
5216 merge it into some range test. Return the new tree if so. */
5218 static tree
5221 {
5237 /* If this is an OR operation, invert both sides; we will invert
5238 again at the end. */
5242 /* If both expressions are the same, if we can merge the ranges, and we
5243 can build the range test, return it or it inverted. If one of the
5244 ranges is always true or always false, consider it to be the same
5245 expression as the other. */
5253 {
5257 }
5259 /* On machines where the branch cost is expensive, if this is a
5260 short-circuited branch and the underlying object on both sides
5261 is the same, make a non-short-circuit operation. */
5267 {
5268 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5269 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5270 which cases we can't do this. */
5278 {
5287 {
5290 WARN_STRICT_OVERFLOW_COMPARISON);
5294 }
5295 }
5296 }
5299 }
5300 \f
5301 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5302 bit value. Arrange things so the extra bits will be set to zero if and
5303 only if C is signed-extended to its full width. If MASK is nonzero,
5304 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5306 static tree
5308 {
5311 tree temp;
5316 /* We work by getting just the sign bit into the low-order bit, then
5317 into the high-order bit, then sign-extend. We then XOR that value
5318 with C. */
5321 /* We must use a signed type in order to get an arithmetic right shift.
5322 However, we must also avoid introducing accidental overflows, so that
5323 a subsequent call to integer_zerop will work. Hence we must
5324 do the type conversion here. At this point, the constant is either
5325 zero or one, and the conversion to a signed type can never overflow.
5326 We could get an overflow if this conversion is done anywhere else. */
5335 /* If necessary, convert the type back to match the type of C. */
5340 }
5341 \f
5342 /* For an expression that has the form
5343 (A && B) || ~B
5344 or
5345 (A || B) && ~B,
5346 we can drop one of the inner expressions and simplify to
5347 A || ~B
5348 or
5349 A && ~B
5350 LOC is the location of the resulting expression. OP is the inner
5351 logical operation; the left-hand side in the examples above, while CMPOP
5352 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5353 removing a condition that guards another, as in
5354 (A != NULL && A->...) || A == NULL
5355 which we must not transform. If RHS_ONLY is true, only eliminate the
5356 right-most operand of the inner logical operation. */
5358 static tree
5361 {
5379 {
5382 {
5385 }
5386 }
5388 {
5391 {
5394 }
5395 }
5410 }
5412 /* Find ways of folding logical expressions of LHS and RHS:
5413 Try to merge two comparisons to the same innermost item.
5414 Look for range tests like "ch >= '0' && ch <= '9'".
5415 Look for combinations of simple terms on machines with expensive branches
5416 and evaluate the RHS unconditionally.
5418 For example, if we have p->a == 2 && p->b == 4 and we can make an
5419 object large enough to span both A and B, we can do this with a comparison
5420 against the object ANDed with the a mask.
5422 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5423 operations to do this with one comparison.
5425 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5426 function and the one above.
5428 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5429 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5431 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5432 two operands.
5434 We return the simplified tree or 0 if no optimization is possible. */
5436 static tree
5439 {
5440 /* If this is the "or" of two comparisons, we can do something if
5441 the comparisons are NE_EXPR. If this is the "and", we can do something
5442 if the comparisons are EQ_EXPR. I.e.,
5443 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5445 WANTED_CODE is this operation code. For single bit fields, we can
5446 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5447 comparison for one-bit fields. */
5468 /* Start by getting the comparison codes. Fail if anything is volatile.
5469 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5470 it were surrounded with a NE_EXPR. */
5479 {
5483 }
5486 {
5490 }
5501 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5504 {
5507 {
5512 }
5515 {
5521 }
5522 }
5527 /* If the RHS can be evaluated unconditionally and its operands are
5528 simple, it wins to evaluate the RHS unconditionally on machines
5529 with expensive branches. In this case, this isn't a comparison
5530 that can be merged. */
5537 {
5538 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5549 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5559 }
5561 /* See if the comparisons can be merged. Then get all the parameters for
5562 each side. */
5587 /* It must be true that the inner operation on the lhs of each
5588 comparison must be the same if we are to be able to do anything.
5589 Then see if we have constants. If not, the same must be true for
5590 the rhs's. */
5599 {
5602 }
5607 else
5610 /* If either comparison code is not correct for our logical operation,
5611 fail. However, we can convert a one-bit comparison against zero into
5612 the opposite comparison against that bit being set in the field. */
5616 {
5618 {
5619 /* Make the left operand unsigned, since we are only interested
5620 in the value of one bit. Otherwise we are doing the wrong
5621 thing below. */
5624 }
5625 else
5627 }
5629 /* This is analogous to the code for l_const above. */
5631 {
5633 {
5636 }
5637 else
5639 }
5641 /* See if we can find a mode that contains both fields being compared on
5642 the left. If we can't, fail. Otherwise, update all constants and masks
5643 to be relative to a field of that size. */
5648 volatilep);
5658 {
5661 }
5669 {
5676 {
5680 }
5681 }
5683 {
5690 {
5694 }
5695 }
5697 /* If the right sides are not constant, do the same for it. Also,
5698 disallow this optimization if a size or signedness mismatch occurs
5699 between the left and right sides. */
5701 {
5704 /* Make sure the two fields on the right
5705 correspond to the left without being swapped. */
5713 volatilep);
5723 {
5726 }
5735 /* Make a mask that corresponds to both fields being compared.
5736 Do this for both items being compared. If the operands are the
5737 same size and the bits being compared are in the same position
5738 then we can do this by masking both and comparing the masked
5739 results. */
5743 {
5755 }
5757 /* There is still another way we can do something: If both pairs of
5758 fields being compared are adjacent, we may be able to make a wider
5759 field containing them both.
5761 Note that we still must mask the lhs/rhs expressions. Furthermore,
5762 the mask must be shifted to account for the shift done by
5763 make_bit_field_ref. */
5768 {
5769 tree type;
5785 /* Convert to the smaller type before masking out unwanted bits. */
5788 {
5790 {
5794 }
5796 {
5800 }
5801 }
5810 }
5813 }
5815 /* Handle the case of comparisons with constants. If there is something in
5816 common between the masks, those bits of the constants must be the same.
5817 If not, the condition is always false. Test for this to avoid generating
5818 incorrect code below. */
5823 {
5825 {
5828 }
5829 else
5830 {
5833 }
5834 }
5836 /* Construct the expression we will return. First get the component
5837 reference we will make. Unless the mask is all ones the width of
5838 that field, perform the mask operation. Then compare with the
5839 merged constant. */
5849 }
5850 \f
5851 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5852 constant. */
5854 static tree
5857 {
5860 tree comp_const;
5861 tree minmax_const;
5863 tree inner;
5874 /* If something does not permit us to optimize, return the original tree. */
5882 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5883 and GT_EXPR, doing the rest with recursive calls using logical
5884 simplifications. */
5886 {
5888 {
5889 tree tem
5896 }
5899 return
5901 optimize_minmax_comparison
5903 optimize_minmax_comparison
5908 /* MAX (X, 0) == 0 -> X <= 0 */
5912 /* MAX (X, 0) == 5 -> X == 5 */
5916 /* MAX (X, 0) == -1 -> false */
5920 /* MIN (X, 0) == 0 -> X >= 0 */
5924 /* MIN (X, 0) == 5 -> false */
5927 else
5928 /* MIN (X, 0) == -1 -> X == -1 */
5933 /* MAX (X, 0) > 0 -> X > 0
5934 MAX (X, 0) > 5 -> X > 5 */
5938 /* MAX (X, 0) > -1 -> true */
5942 /* MIN (X, 0) > 0 -> false
5943 MIN (X, 0) > 5 -> false */
5946 else
5947 /* MIN (X, 0) > -1 -> X > -1 */
5952 }
5953 }
5954 \f
5955 /* T is an integer expression that is being multiplied, divided, or taken a
5956 modulus (CODE says which and what kind of divide or modulus) by a
5957 constant C. See if we can eliminate that operation by folding it with
5958 other operations already in T. WIDE_TYPE, if non-null, is a type that
5959 should be used for the computation if wider than our type.
5961 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5962 (X * 2) + (Y * 4). We must, however, be assured that either the original
5963 expression would not overflow or that overflow is undefined for the type
5964 in the language in question.
5966 If we return a non-null expression, it is an equivalent form of the
5967 original computation, but need not be in the original type.
5969 We set *STRICT_OVERFLOW_P to true if the return values depends on
5970 signed overflow being undefined. Otherwise we do not change
5971 *STRICT_OVERFLOW_P. */
5973 static tree
5976 {
5977 /* To avoid exponential search depth, refuse to allow recursion past
5978 three levels. Beyond that (1) it's highly unlikely that we'll find
5979 something interesting and (2) we've probably processed it before
5980 when we built the inner expression. */
5983 tree ret;
5988 depth++;
5990 depth--;
5993 }
5995 static tree
5998 {
6009 /* Don't deal with constants of zero here; they confuse the code below. */
6019 /* Note that we need not handle conditional operations here since fold
6020 already handles those cases. So just do arithmetic here. */
6022 {
6024 /* For a constant, we can always simplify if we are a multiply
6025 or (for divide and modulus) if it is a multiple of our constant. */
6028 {
6031 /* If the multiplication overflowed to INT_MIN then we lost sign
6032 information on it and a subsequent multiplication might
6033 spuriously overflow. See PR68142. */
6038 }
6042 /* If op0 is an expression ... */
6048 /* ... and has wrapping overflow, and its type is smaller
6049 than ctype, then we cannot pass through as widening. */
6054 /* ... or this is a truncation (t is narrower than op0),
6055 then we cannot pass through this narrowing. */
6058 /* ... or signedness changes for division or modulus,
6059 then we cannot pass through this conversion. */
6063 /* ... or has undefined overflow while the converted to
6064 type has not, we cannot do the operation in the inner type
6065 as that would introduce undefined overflow. */
6071 /* Pass the constant down and see if we can make a simplification. If
6072 we can, replace this expression with the inner simplification for
6073 possible later conversion to our or some other type. */
6078 code == MULT_EXPR
6080 strict_overflow_p))))
6085 /* If widening the type changes it from signed to unsigned, then we
6086 must avoid building ABS_EXPR itself as unsigned. */
6088 {
6092 {
6095 }
6097 }
6098 /* If the constant is negative, we cannot simplify this. */
6101 /* FALLTHROUGH */
6103 /* For division and modulus, type can't be unsigned, as e.g.
6104 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6105 For signed types, even with wrapping overflow, this is fine. */
6114 /* If widening the type changes the signedness, then we can't perform
6115 this optimization as that changes the result. */
6119 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6125 {
6132 }
6136 /* If the second operand is constant, this is a multiplication
6137 or floor division, by a power of two, so we can treat it that
6138 way unless the multiplier or divisor overflows. Signed
6139 left-shift overflow is implementation-defined rather than
6140 undefined in C90, so do not convert signed left shift into
6141 multiplication. */
6144 /* const_binop may not detect overflow correctly,
6145 so check for it explicitly here. */
6149 size_one_node,
6150 op1)))
6154 ctype,
6156 t1),
6161 /* See if we can eliminate the operation on both sides. If we can, we
6162 can return a new PLUS or MINUS. If we can't, the only remaining
6163 cases where we can do anything are if the second operand is a
6164 constant. */
6170 /* If not multiplication, we can only do this if both operands
6171 are divisible by c. */
6174 {
6179 }
6181 /* If this was a subtraction, negate OP1 and set it to be an addition.
6182 This simplifies the logic below. */
6184 {
6186 /* If OP1 was not easily negatable, the constant may be OP0. */
6188 {
6191 }
6192 }
6197 /* If either OP1 or C are negative, this optimization is not safe for
6198 some of the division and remainder types while for others we need
6199 to change the code. */
6201 {
6209 }
6211 /* If it's a multiply or a division/modulus operation of a multiple
6212 of our constant, do the operation and verify it doesn't overflow. */
6215 {
6218 /* We allow the constant to overflow with wrapping semantics. */
6222 }
6223 else
6226 /* If we have an unsigned type, we cannot widen the operation since it
6227 will change the result if the original computation overflowed. */
6231 /* If we were able to eliminate our operation from the first side,
6232 apply our operation to the second side and reform the PLUS. */
6236 /* The last case is if we are a multiply. In that case, we can
6237 apply the distributive law to commute the multiply and addition
6238 if the multiplication of the constants doesn't overflow
6239 and overflow is defined. With undefined overflow
6240 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6246 op1);
6251 /* We have a special case here if we are doing something like
6252 (C * 8) % 4 since we know that's zero. */
6255 /* If the multiplication can overflow we cannot optimize this. */
6259 {
6262 }
6264 /* ... fall through ... */
6268 /* If we can extract our operation from the LHS, do so and return a
6269 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6270 do something only if the second operand is a constant. */
6284 /* If these are the same operation types, we can associate them
6285 assuming no overflow. */
6287 {
6297 {
6302 }
6303 }
6305 /* If these operations "cancel" each other, we have the main
6306 optimizations of this pass, which occur when either constant is a
6307 multiple of the other, in which case we replace this with either an
6308 operation or CODE or TCODE.
6310 If we have an unsigned type, we cannot do this since it will change
6311 the result if the original computation overflowed. */
6318 {
6320 {
6327 }
6329 {
6336 }
6337 }
6342 }
6345 }
6346 \f
6347 /* Return a node which has the indicated constant VALUE (either 0 or
6348 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6349 and is of the indicated TYPE. */
6351 tree
6353 {
6362 else
6364 }
6367 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6368 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6369 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6370 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6371 COND is the first argument to CODE; otherwise (as in the example
6372 given here), it is the second argument. TYPE is the type of the
6373 original expression. Return NULL_TREE if no simplification is
6374 possible. */
6376 static tree
6381 {
6391 {
6395 /* If this operand throws an expression, then it does not make
6396 sense to try to perform a logical or arithmetic operation
6397 involving it. */
6402 }
6403 else
6404 {
6409 }
6414 /* This transformation is only worthwhile if we don't have to wrap ARG
6415 in a SAVE_EXPR and the operation can be simplified without recursing
6416 on at least one of the branches once its pushed inside the COND_EXPR. */
6425 {
6429 else
6431 }
6433 {
6437 else
6439 }
6441 /* Check that we have simplified at least one of the branches. */
6446 }
6448 \f
6449 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6451 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6452 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6453 ADDEND is the same as X.
6455 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6456 and finite. The problematic cases are when X is zero, and its mode
6457 has signed zeros. In the case of rounding towards -infinity,
6458 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6459 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6461 bool
6463 {
6467 /* Don't allow the fold with -fsignaling-nans. */
6471 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6475 /* In a vector or complex, we would need to check the sign of all zeros. */
6479 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6483 /* The mode has signed zeros, and we have to honor their sign.
6484 In this situation, there is only one case we can return true for.
6485 X - 0 is the same as X unless rounding towards -infinity is
6486 supported. */
6488 }
6490 /* Subroutine of fold() that optimizes comparisons of a division by
6491 a nonzero integer constant against an integer constant, i.e.
6492 X/C1 op C2.
6494 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6495 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6496 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6498 The function returns the constant folded tree if a simplification
6499 can be made, and NULL_TREE otherwise. */
6501 static tree
6504 {
6512 /* We have to do this the hard way to detect unsigned overflow.
6513 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6519 {
6524 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6528 }
6530 {
6534 {
6553 }
6554 }
6555 else
6556 {
6557 /* A negative divisor reverses the relational operators. */
6563 {
6582 }
6583 }
6586 {
6607 {
6610 }
6615 {
6618 }
6623 {
6626 }
6631 {
6634 }
6639 }
6642 }
6645 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6646 equality/inequality test, then return a simplified form of the test
6647 using a sign testing. Otherwise return NULL. TYPE is the desired
6648 result type. */
6650 static tree
6653 tree result_type)
6654 {
6655 /* If this is testing a single bit, we can optimize the test. */
6659 {
6660 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6661 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6665 /* This is only a win if casting to a signed type is cheap,
6666 i.e. when arg00's type is not a partial mode. */
6669 {
6672 result_type,
6675 }
6676 }
6679 }
6681 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6682 equality/inequality test, then return a simplified form of
6683 the test using shifts and logical operations. Otherwise return
6684 NULL. TYPE is the desired result type. */
6686 tree
6689 {
6690 /* If this is testing a single bit, we can optimize the test. */
6694 {
6703 /* First, see if we can fold the single bit test into a sign-bit
6704 test. */
6706 result_type);
6710 /* Otherwise we have (A & C) != 0 where C is a single bit,
6711 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6712 Similarly for (A & C) == 0. */
6714 /* If INNER is a right shift of a constant and it plus BITNUM does
6715 not overflow, adjust BITNUM and INNER. */
6721 {
6724 }
6726 /* If we are going to be able to omit the AND below, we must do our
6727 operations as unsigned. If we must use the AND, we have a choice.
6728 Normally unsigned is faster, but for some machines signed is. */
6746 /* Put the AND last so it can combine with more things. */
6749 /* Make sure to return the proper type. */
6753 }
6755 }
6757 /* Check whether we are allowed to reorder operands arg0 and arg1,
6758 such that the evaluation of arg1 occurs before arg0. */
6760 static bool
6762 {
6769 }
6771 /* Test whether it is preferable two swap two operands, ARG0 and
6772 ARG1, for example because ARG0 is an integer constant and ARG1
6773 isn't. If REORDER is true, only recommend swapping if we can
6774 evaluate the operands in reverse order. */
6776 bool
6778 {
6796 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6797 for commutative and comparison operators. Ensuring a canonical
6798 form allows the optimizers to find additional redundancies without
6799 having to explicitly check for both orderings. */
6805 /* Put SSA_NAMEs last. */
6811 /* Put variables last. */
6818 }
6821 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6822 means A >= Y && A != MAX, but in this case we know that
6823 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6825 static tree
6827 {
6834 else
6843 {
6846 }
6848 {
6851 }
6852 else
6859 {
6860 /* Convert the pointer types into integer before taking the difference. */
6864 }
6865 else
6872 }
6874 /* Fold a sum or difference of at least one multiplication.
6875 Returns the folded tree or NULL if no simplification could be made. */
6877 static tree
6880 {
6884 /* (A * C) +- (B * C) -> (A+-B) * C.
6885 (A * C) +- A -> A * (C+-1).
6886 We are most concerned about the case where C is a constant,
6887 but other combinations show up during loop reduction. Since
6888 it is not difficult, try all four possibilities. */
6891 {
6894 }
6896 {
6899 }
6900 else
6901 {
6902 /* We cannot generate constant 1 for fract. */
6907 }
6909 {
6912 }
6914 {
6916 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6917 the purpose of this canonicalization. */
6921 {
6924 }
6925 else
6927 }
6928 else
6929 {
6930 /* We cannot generate constant 1 for fract. */
6935 }
6947 /* No identical multiplicands; see if we can find a common
6948 power-of-two factor in non-power-of-two multiplies. This
6949 can help in multi-dimensional array access. */
6952 {
6955 tree maybe_same;
6959 /* Move min of absolute values to int11. */
6961 {
6966 }
6967 else
6971 /* The remainder should not be a constant, otherwise we
6972 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6973 increased the number of multiplications necessary. */
6975 {
6983 }
6984 }
6994 }
6996 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
6997 specified by EXPR into the buffer PTR of length LEN bytes.
6998 Return the number of bytes placed in the buffer, or zero
6999 upon failure. */
7001 static int
7003 {
7017 {
7019 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7020 number of bytes. */
7024 {
7031 else
7033 }
7034 else
7039 }
7041 }
7044 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7045 specified by EXPR into the buffer PTR of length LEN bytes.
7046 Return the number of bytes placed in the buffer, or zero
7047 upon failure. */
7049 static int
7051 {
7055 FIXED_VALUE_TYPE value;
7071 }
7074 /* Subroutine of native_encode_expr. Encode the REAL_CST
7075 specified by EXPR into the buffer PTR of length LEN bytes.
7076 Return the number of bytes placed in the buffer, or zero
7077 upon failure. */
7079 static int
7081 {
7087 /* There are always 32 bits in each long, no matter the size of
7088 the hosts long. We handle floating point representations with
7089 up to 192 bits. */
7103 {
7108 {
7115 else
7117 }
7118 else
7124 }
7126 }
7128 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7129 specified by EXPR into the buffer PTR of length LEN bytes.
7130 Return the number of bytes placed in the buffer, or zero
7131 upon failure. */
7133 static int
7135 {
7137 tree part;
7152 }
7155 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7156 specified by EXPR into the buffer PTR of length LEN bytes.
7157 Return the number of bytes placed in the buffer, or zero
7158 upon failure. */
7160 static int
7162 {
7172 {
7174 {
7177 }
7188 }
7190 }
7193 /* Subroutine of native_encode_expr. Encode the STRING_CST
7194 specified by EXPR into the buffer PTR of length LEN bytes.
7195 Return the number of bytes placed in the buffer, or zero
7196 upon failure. */
7198 static int
7200 {
7202 HOST_WIDE_INT total_bytes;
7216 {
7219 {
7222 }
7225 }
7226 else
7229 }
7232 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7233 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7234 buffer PTR of length LEN bytes. If OFF is not -1 then start
7235 the encoding at byte offset OFF and encode at most LEN bytes.
7236 Return the number of bytes placed in the buffer, or zero upon failure. */
7238 int
7240 {
7241 /* We don't support starting at negative offset and -1 is special. */
7246 {
7267 }
7268 }
7271 /* Subroutine of native_interpret_expr. Interpret the contents of
7272 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7273 If the buffer cannot be interpreted, return NULL_TREE. */
7275 static tree
7277 {
7287 }
7290 /* Subroutine of native_interpret_expr. Interpret the contents of
7291 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7292 If the buffer cannot be interpreted, return NULL_TREE. */
7294 static tree
7296 {
7298 double_int result;
7299 FIXED_VALUE_TYPE fixed_value;
7309 }
7312 /* Subroutine of native_interpret_expr. Interpret the contents of
7313 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7314 If the buffer cannot be interpreted, return NULL_TREE. */
7316 static tree
7318 {
7322 /* There are always 32 bits in each long, no matter the size of
7323 the hosts long. We handle floating point representations with
7324 up to 192 bits. */
7325 REAL_VALUE_TYPE r;
7336 {
7337 /* Both OFFSET and BYTE index within a long;
7338 bitpos indexes the whole float. */
7341 {
7348 else
7350 }
7351 else
7352 {
7355 {
7356 /* Reverse bytes within each long, or within the entire float
7357 if it's smaller than a long (for HFmode). */
7360 }
7361 }
7365 }
7369 }
7372 /* Subroutine of native_interpret_expr. Interpret the contents of
7373 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7374 If the buffer cannot be interpreted, return NULL_TREE. */
7376 static tree
7378 {
7393 }
7396 /* Subroutine of native_interpret_expr. Interpret the contents of
7397 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7398 If the buffer cannot be interpreted, return NULL_TREE. */
7400 static tree
7402 {
7415 {
7420 }
7422 }
7425 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7426 the buffer PTR of length LEN as a constant of type TYPE. For
7427 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7428 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7429 return NULL_TREE. */
7431 tree
7433 {
7435 {
7457 }
7458 }
7460 /* Returns true if we can interpret the contents of a native encoding
7461 as TYPE. */
7463 static bool
7465 {
7467 {
7480 }
7481 }
7483 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7484 TYPE at compile-time. If we're unable to perform the conversion
7485 return NULL_TREE. */
7487 static tree
7489 {
7490 /* We support up to 512-bit values (for V8DFmode). */
7494 /* Check that the host and target are sane. */
7503 }
7505 /* Build an expression for the address of T. Folds away INDIRECT_REF
7506 to avoid confusing the gimplify process. */
7508 tree
7510 {
7511 /* The size of the object is not relevant when talking about its address. */
7516 {
7521 }
7531 {
7536 }
7537 else
7541 }
7543 /* Build an expression for the address of T. */
7545 tree
7547 {
7551 }
7553 /* Fold a unary expression of code CODE and type TYPE with operand
7554 OP0. Return the folded expression if folding is successful.
7555 Otherwise, return NULL_TREE. */
7557 tree
7559 {
7560 tree tem;
7561 tree arg0;
7569 {
7572 {
7573 /* Don't use STRIP_NOPS, because signedness of argument type
7574 matters. */
7576 }
7577 else
7578 {
7579 /* Strip any conversions that don't change the mode. This
7580 is safe for every expression, except for a comparison
7581 expression because its signedness is derived from its
7582 operands.
7584 Note that this is done as an internal manipulation within
7585 the constant folder, in order to find the simplest
7586 representation of the arguments so that their form can be
7587 studied. In any cases, the appropriate type conversions
7588 should be put back in the tree that will get out of the
7589 constant folder. */
7591 }
7594 {
7597 {
7601 }
7602 }
7603 }
7610 {
7617 {
7631 /* If this was a conversion, and all we did was to move into
7632 inside the COND_EXPR, bring it back out. But leave it if
7633 it is a conversion from integer to integer and the
7634 result precision is no wider than a word since such a
7635 conversion is cheap and may be optimized away by combine,
7636 while it couldn't if it were outside the COND_EXPR. Then return
7637 so we don't get into an infinite recursion loop taking the
7638 conversion out and then back in. */
7650 && (INTEGRAL_TYPE_P
7663 }
7664 }
7667 {
7673 CASE_CONVERT:
7677 {
7678 /* If we have (type) (a CMP b) and type is an integral type, return
7679 new expression involving the new type. Canonicalize
7680 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7681 non-integral type.
7682 Do not fold the result as that would not simplify further, also
7683 folding again results in recursions. */
7693 }
7695 /* Handle (T *)&A.B.C for A being of type T and B and C
7696 living at offset zero. This occurs frequently in
7697 C++ upcasting and then accessing the base. */
7701 {
7703 tree offset;
7704 machine_mode mode;
7706 tree base
7710 /* If the reference was to a (constant) zero offset, we can use
7711 the address of the base if it has the same base type
7712 as the result type and the pointer type is unqualified. */
7719 }
7723 /* Detect assigning a bitfield. */
7725 && DECL_BIT_FIELD
7727 {
7728 /* Don't leave an assignment inside a conversion
7729 unless assigning a bitfield. */
7731 /* First do the assignment, then return converted constant. */
7736 }
7738 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7739 constants (if x has signed type, the sign bit cannot be set
7740 in c). This folds extension into the BIT_AND_EXPR.
7741 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7742 very likely don't have maximal range for their precision and this
7743 transformation effectively doesn't preserve non-maximal ranges. */
7747 {
7758 <= HOST_BITS_PER_WIDE_INT
7760 {
7764 cst &= HOST_WIDE_INT_M1U
7768 && !flag_syntax_only
7771 {
7775 }
7776 }
7778 {
7783 }
7784 }
7786 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7787 cast (T1)X will fold away. We assume that this happens when X itself
7788 is a cast. */
7792 {
7796 return fold_build_pointer_plus_loc
7798 }
7800 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7801 of the same precision, and X is an integer type not narrower than
7802 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7808 {
7814 }
7816 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7817 type of X and Y (integer types only). */
7822 {
7823 /* Be careful not to introduce new overflows. */
7824 tree mult_type;
7827 else
7831 {
7838 }
7839 }
7845 {
7850 }
7861 /* Convert fabs((double)float) into (double)fabsf(float). */
7864 {
7870 targ0));
7871 }
7875 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7894 /* Note that the operand of this must be an int
7895 and its values must be 0 or 1.
7896 ("true" is a fixed value perhaps depending on the language,
7897 but we don't handle values other than 1 correctly yet.) */
7904 /* Fold *&X to X if X is an lvalue. */
7906 {
7913 }
7919 }
7922 /* If the operation was a conversion do _not_ mark a resulting constant
7923 with TREE_OVERFLOW if the original constant was not. These conversions
7924 have implementation defined behavior and retaining the TREE_OVERFLOW
7925 flag here would confuse later passes such as VRP. */
7926 tree
7929 {
7938 }
7940 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7941 operands OP0 and OP1. LOC is the location of the resulting expression.
7942 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7943 Return the folded expression if folding is successful. Otherwise,
7944 return NULL_TREE. */
7945 static tree
7948 {
7949 tree tem;
7951 /* We only do these simplifications if we are optimizing. */
7955 /* Check for things like (A || B) && (A || C). We can convert this
7956 to A || (B && C). Note that either operator can be any of the four
7957 truth and/or operations and the transformation will still be
7958 valid. Also note that we only care about order for the
7959 ANDIF and ORIF operators. If B contains side effects, this
7960 might change the truth-value of A. */
7967 {
7987 /* This case if tricky because we must either have commutative
7988 operators or else A10 must not have side-effects. */
7994 a01);
7995 }
7997 /* See if we can build a range comparison. */
8003 {
8007 }
8011 {
8015 }
8017 /* Check for the possibility of merging component references. If our
8018 lhs is another similar operation, try to merge its rhs with our
8019 rhs. Then try to merge our lhs and rhs. */
8033 {
8040 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8041 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8042 We don't want to pack more than two leafs to a non-IF AND/OR
8043 expression.
8044 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8045 equal to IF-CODE, then we don't want to add right-hand operand.
8046 If the inner right-hand side of left-hand operand has
8047 side-effects, or isn't simple, then we can't add to it,
8048 as otherwise we might destroy if-sequence. */
8051 /* Needed for sequence points to handle trappings, and
8052 side-effects. */
8054 {
8056 arg1);
8058 tem);
8059 }
8060 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8061 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8064 /* Needed for sequence points to handle trappings, and
8065 side-effects. */
8067 {
8072 }
8073 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8074 into (A OR B).
8075 For sequence point consistancy, we need to check for trapping,
8076 and side-effects. */
8080 }
8083 }
8085 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8086 by changing CODE to reduce the magnitude of constants involved in
8087 ARG0 of the comparison.
8088 Returns a canonicalized comparison tree if a simplification was
8089 possible, otherwise returns NULL_TREE.
8090 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8091 valid if signed overflow is undefined. */
8093 static tree
8097 {
8102 /* Match A +- CST code arg1. We can change this only if overflow
8103 is undefined. */
8106 /* In principle pointers also have undefined overflow behavior,
8107 but that causes problems elsewhere. */
8114 /* Identify the constant in arg0 and its sign. */
8118 /* Overflowed constants and zero will cause problems. */
8123 /* See if we can reduce the magnitude of the constant in
8124 arg0 by changing the comparison code. */
8125 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8129 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8133 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8137 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8141 else
8145 /* Now build the constant reduced in magnitude. But not if that
8146 would produce one outside of its types range. */
8162 }
8164 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8165 overflow further. Try to decrease the magnitude of constants involved
8166 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8167 and put sole constants at the second argument position.
8168 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8170 static tree
8173 {
8174 tree t;
8179 /* Try canonicalization by simplifying arg0. */
8184 {
8188 }
8190 /* Try canonicalization by simplifying arg1 using the swapped
8191 comparison. */
8199 }
8201 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8202 space. This is used to avoid issuing overflow warnings for
8203 expressions like &p->x which can not wrap. */
8205 static bool
8207 {
8214 wide_int wi_offset;
8220 else
8236 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8237 array. */
8239 {
8240 HOST_WIDE_INT base_size;
8245 }
8248 }
8250 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8251 kind INTEGER_CST. This makes sure to properly sign-extend the
8252 constant. */
8254 static HOST_WIDE_INT
8256 {
8262 }
8264 /* Subroutine of fold_binary. This routine performs all of the
8265 transformations that are common to the equality/inequality
8266 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8267 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8268 fold_binary should call fold_binary. Fold a comparison with
8269 tree code CODE and type TYPE with operands OP0 and OP1. Return
8270 the folded comparison or NULL_TREE. */
8272 static tree
8275 {
8285 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8287 && (equality_code
8294 {
8295 const enum tree_code
8302 /* If the constant operation overflowed this can be
8303 simplified as a comparison against INT_MAX/INT_MIN. */
8306 {
8310 /* Get the sign of the constant on the lhs if the
8311 operation were VARIABLE + CONST1. */
8315 /* The sign of the constant determines if we overflowed
8316 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8317 Canonicalize to the INT_MIN overflow by swapping the comparison
8318 if necessary. */
8322 /* We now can look at the canonicalized case
8323 VARIABLE + 1 CODE2 INT_MIN
8324 and decide on the result. */
8326 {
8330 return
8336 return
8341 }
8342 }
8343 else
8344 {
8347 "when changing X +- C1 cmp C2 to "
8349 WARN_STRICT_OVERFLOW_COMPARISON);
8351 }
8352 }
8354 /* For comparisons of pointers we can decompose it to a compile time
8355 comparison of the base objects and the offsets into the object.
8356 This requires at least one operand being an ADDR_EXPR or a
8357 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8363 {
8366 machine_mode mode;
8370 /* Get base and offset for the access. Strip ADDR_EXPR for
8371 get_inner_reference, but put it back by stripping INDIRECT_REF
8372 off the base object if possible. indirect_baseN will be true
8373 if baseN is not an address but refers to the object itself. */
8376 {
8377 base0
8383 else
8385 }
8387 {
8391 {
8394 }
8397 {
8402 {
8405 }
8406 }
8407 }
8411 {
8412 base1
8418 else
8420 }
8422 {
8426 {
8429 }
8432 {
8437 {
8440 }
8441 }
8442 }
8444 /* If we have equivalent bases we might be able to simplify. */
8448 {
8449 /* We can fold this expression to a constant if the non-constant
8450 offset parts are equal. */
8459 {
8465 "occur when comparing P +- C1 with "
8467 WARN_STRICT_OVERFLOW_CONDITIONAL);
8470 {
8484 }
8485 }
8486 /* We can simplify the comparison to a comparison of the variable
8487 offset parts if the constant offset parts are equal.
8488 Be careful to use signed sizetype here because otherwise we
8489 mess with array offsets in the wrong way. This is possible
8490 because pointer arithmetic is restricted to retain within an
8491 object and overflow on pointer differences is undefined as of
8492 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8494 && (equality_code
8497 {
8498 /* By converting to signed sizetype we cover middle-end pointer
8499 arithmetic which operates on unsigned pointer types of size
8500 type size and ARRAY_REF offsets which are properly sign or
8501 zero extended from their type in case it is narrower than
8502 sizetype. */
8505 else
8509 else
8516 "occur when comparing P +- C1 with "
8518 WARN_STRICT_OVERFLOW_COMPARISON);
8521 }
8522 }
8523 /* For equal offsets we can simplify to a comparison of the
8524 base addresses. */
8526 && (indirect_base0
8528 && (indirect_base1
8533 {
8539 }
8540 }
8542 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8543 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8544 the resulting offset is smaller in absolute value than the
8545 original one and has the same sign. */
8554 {
8559 tree cst;
8561 "occur when combining constants around "
8564 /* Put the constant on the side where it doesn't overflow and is
8565 of lower absolute value and of same sign than before. */
8572 {
8575 variable1,
8579 }
8587 {
8593 variable2);
8594 }
8595 }
8601 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8602 constant, we can simplify it. */
8607 {
8611 }
8613 /* If we are comparing an expression that just has comparisons
8614 of two integer values, arithmetic expressions of those comparisons,
8615 and constants, we can simplify it. There are only three cases
8616 to check: the two values can either be equal, the first can be
8617 greater, or the second can be greater. Fold the expression for
8618 those three values. Since each value must be 0 or 1, we have
8619 eight possibilities, each of which corresponds to the constant 0
8620 or 1 or one of the six possible comparisons.
8622 This handles common cases like (a > b) == 0 but also handles
8623 expressions like ((x > y) - (y > x)) > 0, which supposedly
8624 occur in macroized code. */
8627 {
8632 /* Don't handle degenerate cases here; they should already
8633 have been handled anyway. */
8642 {
8646 /* We can't just pass T to eval_subst in case cval1 or cval2
8647 was the same as ARG1. */
8649 tree high_result
8653 arg1);
8654 tree equal_result
8658 arg1);
8659 tree low_result
8663 arg1);
8665 /* All three of these results should be 0 or 1. Confirm they are.
8666 Then use those values to select the proper code to use. */
8671 {
8672 /* Make a 3-bit mask with the high-order bit being the
8673 value for `>', the next for '=', and the low for '<'. */
8677 {
8679 /* Always false. */
8700 /* Always true. */
8702 }
8705 {
8709 }
8711 }
8712 }
8713 }
8715 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8716 into a single range test. */
8724 {
8728 }
8731 }
8734 /* Subroutine of fold_binary. Optimize complex multiplications of the
8735 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8736 argument EXPR represents the expression "z" of type TYPE. */
8738 static tree
8740 {
8745 {
8748 }
8750 {
8753 }
8754 else
8755 {
8759 }
8768 }
8771 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8772 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8774 static bool
8776 {
8780 {
8783 }
8785 {
8791 else
8793 }
8794 else
8800 }
8802 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8803 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8804 NULL_TREE otherwise. */
8806 static tree
8808 {
8825 {
8829 }
8832 {
8838 }
8839 else
8841 }
8843 /* Try to fold a pointer difference of type TYPE two address expressions of
8844 array references AREF0 and AREF1 using location LOC. Return a
8845 simplified expression for the difference or NULL_TREE. */
8847 static tree
8850 {
8855 /* If the bases are array references as well, recurse. If the bases
8856 are pointer indirections compute the difference of the pointers.
8857 If the bases are equal, we are set. */
8860 && (base_offset
8864 && (base_offset
8870 {
8876 base_offset,
8879 }
8881 }
8883 /* If the real or vector real constant CST of type TYPE has an exact
8884 inverse, return it, else return NULL. */
8886 tree
8888 {
8889 REAL_VALUE_TYPE r;
8891 machine_mode mode;
8895 {
8911 {
8916 }
8922 }
8923 }
8925 /* Mask out the tz least significant bits of X of type TYPE where
8926 tz is the number of trailing zeroes in Y. */
8927 static wide_int
8929 {
8934 }
8936 /* Return true when T is an address and is known to be nonzero.
8937 For floating point we further ensure that T is not denormal.
8938 Similar logic is present in nonzero_address in rtlanal.h.
8940 If the return value is based on the assumption that signed overflow
8941 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8942 change *STRICT_OVERFLOW_P. */
8944 static bool
8946 {
8950 /* Doing something useful for floating point would need more work. */
8956 {
8959 strict_overflow_p);
8965 strict_overflow_p);
8973 }
8976 {
8979 strict_overflow_p);
8987 strict_overflow_p);
9002 strict_overflow_p);
9006 strict_overflow_p);
9009 {
9021 }
9025 }
9027 }
9029 /* Return true when T is an address and is known to be nonzero.
9030 Handle warnings about undefined signed overflow. */
9032 static bool
9034 {
9041 "determining that expression is always "
9043 WARN_STRICT_OVERFLOW_MISC);
9045 }
9047 /* Fold a binary expression of code CODE and type TYPE with operands
9048 OP0 and OP1. LOC is the location of the resulting expression.
9049 Return the folded expression if folding is successful. Otherwise,
9050 return NULL_TREE. */
9052 tree
9055 {
9070 /* Strip any conversions that don't change the mode. This is
9071 safe for every expression, except for a comparison expression
9072 because its signedness is derived from its operands. So, in
9073 the latter case, only strip conversions that don't change the
9074 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9075 preserved.
9077 Note that this is done as an internal manipulation within the
9078 constant folder, in order to find the simplest representation
9079 of the arguments so that their form can be studied. In any
9080 cases, the appropriate type conversions should be put back in
9081 the tree that will get out of the constant folder. */
9084 {
9087 }
9088 else
9089 {
9092 }
9094 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9095 constant but we can't do arithmetic on them. */
9097 {
9100 {
9104 }
9105 }
9107 /* If this is a commutative operation, and ARG0 is a constant, move it
9108 to ARG1 to reduce the number of tests below. */
9113 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9114 to ARG1 to reduce the number of tests below. */
9123 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9125 First check for cases where an arithmetic operation is applied to a
9126 compound, conditional, or comparison operation. Push the arithmetic
9127 operation inside the compound or conditional to see if any folding
9128 can then be done. Convert comparison to conditional for this purpose.
9129 The also optimizes non-constant cases that used to be done in
9130 expand_expr.
9132 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9133 one of the operands is a comparison and the other is a comparison, a
9134 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9135 code below would make the expression more complex. Change it to a
9136 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9137 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9150 {
9154 boolean_type_node,
9162 }
9166 {
9168 {
9173 tem);
9174 }
9177 {
9182 tem);
9183 }
9188 {
9194 }
9199 {
9205 }
9206 }
9209 {
9211 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9214 {
9220 }
9222 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9225 {
9226 tree base;
9227 HOST_WIDE_INT coffset;
9236 }
9241 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9247 arg1),
9249 arg0)));
9255 {
9256 /* X + (X / CST) * -CST is X % CST. */
9261 {
9270 cst0));
9271 }
9272 }
9274 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9275 one. Make sure the type is not saturating and has the signedness of
9276 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9277 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9284 {
9288 }
9291 {
9292 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9293 (plus (plus (mult) (mult)) (foo)) so that we can
9294 take advantage of the factoring cases below. */
9303 {
9309 else
9322 parg0),
9324 marg)),
9328 return
9334 parg1)));
9335 }
9336 }
9337 else
9338 {
9339 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9340 to __complex__ ( x, y ). This is not the same for SNaNs or
9341 if signed zeros are involved. */
9345 {
9352 {
9356 {
9362 }
9364 {
9370 }
9371 }
9372 }
9380 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9381 We associate floats only if the user has specified
9382 -fassociative-math. */
9386 {
9391 {
9392 tree tree0;
9395 }
9396 }
9397 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9398 We associate floats only if the user has specified
9399 -fassociative-math. */
9403 {
9408 {
9409 tree tree0;
9412 }
9413 }
9414 }
9416 bit_rotate:
9417 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9418 is a rotate of A by C1 bits. */
9419 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9420 is a rotate of A by B bits. */
9421 {
9423 tree rtype;
9432 /* Only create rotates in complete modes. Other cases are not
9433 expanded properly. */
9436 {
9450 {
9454 code0 == LSHIFT_EXPR
9458 }
9460 {
9468 element_precision
9472 return
9475 ? LROTATE_EXPR
9480 }
9482 {
9490 element_precision
9494 return fold_convert_loc
9497 ? LROTATE_EXPR
9501 }
9502 }
9503 }
9505 associate:
9506 /* In most languages, can't associate operations on floats through
9507 parentheses. Rather than remember where the parentheses were, we
9508 don't associate floats at all, unless the user has specified
9509 -fassociative-math.
9510 And, we need to make sure type is not saturating. */
9514 {
9520 /* Split both trees into variables, constants, and literals. Then
9521 associate each group together, the constants with literals,
9522 then the result with variables. This increases the chances of
9523 literals being recombined later and of generating relocatable
9524 expressions for the sum of a constant and literal. */
9529 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9533 /* With undefined overflow prefer doing association in a type
9534 which wraps on overflow, if that is one of the operand types. */
9537 {
9545 }
9547 /* With undefined overflow we can only associate constants with one
9548 variable, and constants whose association doesn't overflow. */
9551 {
9553 {
9559 {
9562 }
9569 {
9572 }
9578 /* The only case we can still associate with two variables
9579 is if they cancel out. */
9583 }
9584 }
9586 /* Only do something if we found more than two objects. Otherwise,
9587 nothing has changed and we risk infinite recursion. */
9593 {
9605 /* Preserve the MINUS_EXPR if the negative part of the literal is
9606 greater than the positive part. Otherwise, the multiplicative
9607 folding code (i.e extract_muldiv) may be fooled in case
9608 unsigned constants are subtracted, like in the following
9609 example: ((X*2 + 4) - 8U)/2. */
9611 {
9615 {
9619 }
9620 else
9621 {
9625 }
9626 }
9628 /* Don't introduce overflows through reassociation. */
9635 {
9637 return
9641 else
9642 {
9645 return
9649 }
9650 }
9653 return
9656 }
9657 }
9662 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9672 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9673 __complex__ ( x, -y ). This is not the same for SNaNs or if
9674 signed zeros are involved. */
9678 {
9685 {
9689 {
9691 arg1r ? arg1r
9696 }
9698 {
9702 arg1i ? arg1i
9705 }
9706 }
9707 }
9709 /* A - B -> A + (-B) if B is easily negatable. */
9713 /* Avoid this transformation if B is a positive REAL_CST. */
9722 /* Fold &a[i] - &a[j] to i-j. */
9727 {
9733 }
9736 && flag_unsafe_math_optimizations
9742 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9743 one. Make sure the type is not saturating and has the signedness of
9744 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9745 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9752 {
9756 }
9762 {
9763 /* Transform x * -C into -x * C if x is easily negatable. */
9772 tem);
9774 /* (A + A) * C -> A * 2 * C */
9786 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
9787 sign-changing only. */
9797 {
9800 "occur when simplifying "
9802 WARN_STRICT_OVERFLOW_MISC);
9804 }
9806 /* Optimize z * conj(z) for integer complex numbers. */
9813 }
9814 else
9815 {
9816 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9817 This is not the same for NaNs or if signed zeros are
9818 involved. */
9824 {
9827 return
9833 return
9838 }
9840 /* Optimize z * conj(z) for floating point complex numbers.
9841 Guarded by flag_unsafe_math_optimizations as non-finite
9842 imaginary components don't produce scalar results. */
9853 {
9855 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
9857 && optimize
9859 {
9863 {
9866 }
9867 }
9868 }
9869 }
9873 /* Canonicalize (X & C1) | C2. */
9877 {
9882 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9890 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9895 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9896 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9897 mode which allows further optimizations. */
9902 {
9906 {
9909 }
9910 }
9917 c3)),
9918 arg1);
9919 }
9921 /* See if this can be simplified into a rotate first. If that
9922 is unsuccessful continue in the association code. */
9926 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
9934 /* See if this can be simplified into a rotate first. If that
9935 is unsuccessful continue in the association code. */
9939 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
9944 {
9945 tree tem2;
9952 }
9953 /* Fold ~X & 1 as (X & 1) == 0. */
9957 {
9958 tree tem2;
9965 }
9966 /* Fold !X & 1 as X == 0. */
9969 {
9973 }
9975 /* Fold (X ^ Y) & Y as ~X & Y. */
9978 {
9983 }
9984 /* Fold (X ^ Y) & X as ~Y & X. */
9988 {
9993 }
9994 /* Fold X & (X ^ Y) as X & ~Y. */
9997 {
10002 }
10003 /* Fold X & (Y ^ X) as ~Y & X. */
10007 {
10012 }
10014 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10015 multiple of 1 << CST. */
10017 {
10024 }
10026 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10027 bits from CST2. */
10031 {
10039 {
10040 /* Avoid the transform if arg1 is a mask of some
10041 mode which allows further optimizations. */
10048 }
10049 }
10051 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10052 ((A & N) + B) & M -> (A + B) & M
10053 Similarly if (N & M) == 0,
10054 ((A | N) + B) & M -> (A + B) & M
10055 and for - instead of + (or unary - instead of +)
10056 and/or ^ instead of |.
10057 If B is constant and (B & M) == 0, fold into A & M. */
10059 {
10068 {
10071 wide_int cst0;
10073 /* Now we know that arg0 is (C + D) or (C - D) or
10074 -C and arg1 (M) is == (1LL << cst) - 1.
10075 Store C into PMOP[0] and D into PMOP[1]. */
10079 {
10082 }
10089 {
10099 {
10102 }
10105 /* If C or D is of the form (A & N) where
10106 (N & M) == M, or of the form (A | N) or
10107 (A ^ N) where (N & M) == 0, replace it with A. */
10111 /* If C or D is a N where (N & M) == 0, it can be
10112 omitted (assumed 0). */
10120 }
10122 /* Only build anything new if we optimized one or both arguments
10123 above. */
10127 {
10130 {
10131 /* Perform the operations in a type that has defined
10132 overflow behavior. */
10138 }
10143 {
10151 else
10153 }
10156 else
10159 /* TEM is now the new binary +, - or unary - replacement. */
10163 }
10164 }
10165 }
10167 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10170 {
10175 return
10177 }
10182 /* Don't touch a floating-point divide by zero unless the mode
10183 of the constant can represent infinity. */
10189 /* (-A) / (-B) -> A / B */
10199 /* Convert A/B/C to A/(B*C). */
10206 /* Convert A/(B/C) to (A/B)*C. */
10214 /* Convert C1/(X*C2) into (C1/C2)/X. */
10219 {
10225 }
10230 /* Optimize (X & (-A)) / A where A is a power of 2,
10231 to X >> log2(A) */
10235 {
10243 }
10244 }
10246 /* Fall through */
10249 /* Simplify A / (B << N) where A and B are positive and B is
10250 a power of 2, to A >> (N + log2(B)). */
10255 {
10258 {
10266 WARN_STRICT_OVERFLOW_MISC);
10272 }
10273 }
10275 /* Fall through */
10283 /* Convert -A / -B to A / B when the type is signed and overflow is
10284 undefined. */
10288 {
10291 "when distributing negation across "
10293 WARN_STRICT_OVERFLOW_MISC);
10299 }
10303 {
10306 "when distributing negation across "
10308 WARN_STRICT_OVERFLOW_MISC);
10314 }
10316 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10317 operation, EXACT_DIV_EXPR.
10319 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10320 At one time others generated faster code, it's not clear if they do
10321 after the last round to changes to the DIV code in expmed.c. */
10332 {
10336 WARN_STRICT_OVERFLOW_MISC);
10338 }
10350 {
10354 WARN_STRICT_OVERFLOW_MISC);
10356 }
10364 /* Since negative shift count is not well-defined,
10365 don't try to compute it in the compiler. */
10371 /* If we have a rotate of a bit operation with the rotate count and
10372 the second operand of the bit operation both constant,
10373 permute the two operations. */
10385 /* Two consecutive rotates adding up to the some integer
10386 multiple of the precision of the type can be ignored. */
10401 /* Note that the operands of this must be ints
10402 and their values must be 0 or 1.
10403 ("true" is a fixed value perhaps depending on the language.) */
10404 /* If first arg is constant zero, return it. */
10408 /* If either arg is constant true, drop it. */
10412 /* Preserve sequence points. */
10415 /* If second arg is constant zero, result is zero, but first arg
10416 must be evaluated. */
10419 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10420 case will be handled here. */
10424 /* !X && X is always false. */
10428 /* X && !X is always false. */
10433 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10434 means A >= Y && A != MAX, but in this case we know that
10435 A < X <= MAX. */
10439 {
10447 }
10456 /* Note that the operands of this must be ints
10457 and their values must be 0 or true.
10458 ("true" is a fixed value perhaps depending on the language.) */
10459 /* If first arg is constant true, return it. */
10463 /* If either arg is constant zero, drop it. */
10467 /* Preserve sequence points. */
10470 /* If second arg is constant true, result is true, but we must
10471 evaluate first arg. */
10474 /* Likewise for first arg, but note this only occurs here for
10475 TRUTH_OR_EXPR. */
10479 /* !X || X is always true. */
10483 /* X || !X is always true. */
10488 /* (X && !Y) || (!X && Y) is X ^ Y */
10491 {
10508 }
10517 /* If the second arg is constant zero, drop it. */
10520 /* If the second arg is constant true, this is a logical inversion. */
10522 {
10525 }
10526 /* Identical arguments cancel to zero. */
10530 /* !X ^ X is always true. */
10535 /* X ^ !X is always true. */
10551 /* bool_var != 1 becomes !bool_var. */
10558 /* bool_var == 0 becomes !bool_var. */
10565 /* !exp != 0 becomes !exp */
10570 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10579 {
10583 val,
10587 }
10589 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10596 {
10598 code == NE_EXPR
10601 }
10603 /* If this is an EQ or NE comparison with zero and ARG0 is
10604 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10605 two operations, but the latter can be done in one less insn
10606 on machines that have only two-operand insns or on which a
10607 constant cannot be the first operand. */
10610 {
10615 {
10622 arg1);
10623 }
10626 {
10633 arg1);
10634 }
10635 }
10637 /* If this is an NE or EQ comparison of zero against the result of a
10638 signed MOD operation whose second operand is a power of 2, make
10639 the MOD operation unsigned since it is simpler and equivalent. */
10647 {
10657 }
10659 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10660 C1 is a valid shift constant, and C2 is a power of two, i.e.
10661 a single bit. */
10665 == INTEGER_CST
10668 {
10673 /* Check for a valid shift count. */
10675 {
10679 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10680 can be rewritten as (X & (C2 << C1)) != 0. */
10682 {
10687 }
10688 /* Otherwise, for signed (arithmetic) shifts,
10689 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10690 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10694 /* Otherwise, of unsigned (logical) shifts,
10695 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10696 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10697 else
10701 arg000);
10702 }
10703 }
10705 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10706 Similarly for NE_EXPR. */
10710 {
10714 tree dandnotc
10717 notc);
10721 }
10723 /* If this is a comparison of a field, we may be able to simplify it. */
10726 /* Handle the constant case even without -O
10727 to make sure the warnings are given. */
10729 {
10733 }
10735 /* Optimize comparisons of strlen vs zero to a compare of the
10736 first character of the string vs zero. To wit,
10737 strlen(ptr) == 0 => *ptr == 0
10738 strlen(ptr) != 0 => *ptr != 0
10739 Other cases should reduce to one of these two (or a constant)
10740 due to the return value of strlen being unsigned. */
10743 {
10751 {
10756 }
10757 }
10759 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10760 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10764 {
10769 {
10771 {
10774 }
10777 }
10778 }
10780 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10781 (X & C) == 0 when C is a single bit. */
10786 {
10793 arg1));
10794 }
10796 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10797 constant C is a power of two, i.e. a single bit. */
10804 {
10808 }
10810 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10811 when is C is a power of two, i.e. a single bit. */
10818 {
10824 }
10828 {
10831 }
10833 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10836 {
10849 arg01),
10858 arg01),
10867 arg00),
10876 arg00),
10878 }
10882 {
10889 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10890 operand_equal_p guarantees no side-effects so we don't need
10891 to use omit_one_operand on Z. */
10895 arg10));
10899 arg11));
10903 arg10));
10907 arg11));
10909 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10912 {
10918 }
10919 }
10921 /* Attempt to simplify equality/inequality comparisons of complex
10922 values. Only lower the comparison if the result is known or
10923 can be simplified to a single scalar comparison. */
10928 {
10933 {
10936 }
10937 else
10938 {
10941 }
10944 {
10947 }
10948 else
10949 {
10952 }
10956 {
10958 {
10963 }
10964 else
10965 {
10970 }
10971 }
10975 {
10977 {
10982 }
10983 else
10984 {
10989 }
10990 }
10991 }
11003 /* Transform comparisons of the form X +- C CMP X. */
11010 {
11017 else
11020 /* (X - c) > X becomes false. */
11024 {
11028 "occur when assuming that (X - c) > X "
11030 WARN_STRICT_OVERFLOW_ALL);
11032 }
11034 /* Likewise (X + c) < X becomes false. */
11038 {
11042 "occur when assuming that "
11044 WARN_STRICT_OVERFLOW_ALL);
11046 }
11048 /* Convert (X - c) <= X to true. */
11053 {
11057 "occur when assuming that "
11059 WARN_STRICT_OVERFLOW_ALL);
11061 }
11063 /* Convert (X + c) >= X to true. */
11068 {
11072 "occur when assuming that "
11074 WARN_STRICT_OVERFLOW_ALL);
11076 }
11079 {
11080 /* Convert X + c > X and X - c < X to true for integers. */
11084 {
11087 "not occur when assuming that "
11089 WARN_STRICT_OVERFLOW_ALL);
11091 }
11096 {
11099 "not occur when assuming that "
11101 WARN_STRICT_OVERFLOW_ALL);
11103 }
11105 /* Convert X + c <= X and X - c >= X to false for integers. */
11109 {
11112 "not occur when assuming that "
11114 WARN_STRICT_OVERFLOW_ALL);
11116 }
11121 {
11124 "not occur when assuming that "
11126 WARN_STRICT_OVERFLOW_ALL);
11128 }
11129 }
11130 }
11132 /* If we are comparing an ABS_EXPR with a constant, we can
11133 convert all the cases into explicit comparisons, but they may
11134 well not be faster than doing the ABS and one comparison.
11135 But ABS (X) <= C is a range comparison, which becomes a subtraction
11136 and a comparison, and is probably faster. */
11150 /* Convert ABS_EXPR<x> >= 0 to true. */
11157 {
11160 "when simplifying comparison of "
11162 WARN_STRICT_OVERFLOW_CONDITIONAL);
11165 arg0);
11166 }
11168 /* Convert ABS_EXPR<x> < 0 to false. */
11173 {
11176 "when simplifying comparison of "
11178 WARN_STRICT_OVERFLOW_CONDITIONAL);
11181 arg0);
11182 }
11184 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11185 and similarly for >= into !=. */
11195 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11196 otherwise Y might be >= # of bits in X's type and thus e.g.
11197 (unsigned char) (1 << Y) for Y 15 might be 0.
11198 If the cast is widening, then 1 << Y should have unsigned type,
11199 otherwise if Y is number of bits in the signed shift type minus 1,
11200 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11201 31 might be 0xffffffff80000000. */
11212 {
11218 }
11230 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11231 {
11243 }
11248 /* When pedantic, a compound expression can be neither an lvalue
11249 nor an integer constant expression. */
11252 /* Don't let (0, 0) be null pointer constant. */
11258 /* An ASSERT_EXPR should never be passed to fold_binary. */
11264 }
11266 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11267 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11268 of GOTO_EXPR. */
11270 static tree
11272 {
11274 {
11281 /* ... fall through ... */
11285 }
11286 }
11288 /* Return whether the sub-tree ST contains a label which is accessible from
11289 outside the sub-tree. */
11291 static bool
11293 {
11294 return
11296 }
11298 /* Fold a ternary expression of code CODE and type TYPE with operands
11299 OP0, OP1, and OP2. Return the folded expression if folding is
11300 successful. Otherwise, return NULL_TREE. */
11302 tree
11305 {
11306 tree tem;
11313 /* If this is a commutative operation, and OP0 is a constant, move it
11314 to OP1 to reduce the number of tests below. */
11323 /* Strip any conversions that don't change the mode. This is safe
11324 for every expression, except for a comparison expression because
11325 its signedness is derived from its operands. So, in the latter
11326 case, only strip conversions that don't change the signedness.
11328 Note that this is done as an internal manipulation within the
11329 constant folder, in order to find the simplest representation of
11330 the arguments so that their form can be studied. In any cases,
11331 the appropriate type conversions should be put back in the tree
11332 that will get out of the constant folder. */
11334 {
11337 }
11340 {
11343 }
11346 {
11349 }
11352 {
11356 {
11362 }
11367 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11368 so all simple results must be passed through pedantic_non_lvalue. */
11370 {
11373 /* Only optimize constant conditions when the selected branch
11374 has the same type as the COND_EXPR. This avoids optimizing
11375 away "c ? x : throw", where the throw has a void type.
11376 Avoid throwing away that operand which contains label. */
11383 }
11385 {
11390 {
11395 {
11403 }
11407 }
11408 }
11410 /* If we have A op B ? A : C, we may be able to convert this to a
11411 simpler expression, depending on the operation and the values
11412 of B and C. Signed zeros prevent all of these transformations,
11413 for reasons given above each one.
11415 Also try swapping the arguments and inverting the conditional. */
11420 {
11424 }
11428 op2,
11431 {
11435 {
11439 }
11440 }
11442 /* If the second operand is simpler than the third, swap them
11443 since that produces better jump optimization results. */
11446 {
11448 /* See if this can be inverted. If it can't, possibly because
11449 it was a floating-point inequality comparison, don't do
11450 anything. */
11454 }
11456 /* Convert A ? 1 : 0 to simply A. */
11461 /* If we try to convert OP0 to our type, the
11462 call to fold will try to move the conversion inside
11463 a COND, which will recurse. In that case, the COND_EXPR
11464 is probably the best choice, so leave it alone. */
11468 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11469 over COND_EXPR in cases such as floating point comparisons. */
11478 arg0)));
11480 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11485 {
11486 /* sign_bit_p looks through both zero and sign extensions,
11487 but for this optimization only sign extensions are
11488 usable. */
11491 {
11494 {
11497 }
11499 }
11500 /* sign_bit_p only checks ARG1 bits within A's precision.
11501 If <sign bit of A> has wider type than A, bits outside
11502 of A's precision in <sign bit of A> need to be checked.
11503 If they are all 0, this optimization needs to be done
11504 in unsigned A's type, if they are all 1 in signed A's type,
11505 otherwise this can't be done. */
11511 {
11513 tree tem_type;
11526 {
11529 }
11531 {
11534 }
11535 else
11537 }
11540 return
11546 arg1)));
11547 }
11549 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11550 already handled above. */
11555 {
11564 }
11566 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11567 is probably obsolete because the first operand should be a
11568 truth value (that's why we have the two cases above), but let's
11569 leave it in until we can confirm this for all front-ends. */
11581 /* Disable the transformations below for vectors, since
11582 fold_binary_op_with_conditional_arg may undo them immediately,
11583 yielding an infinite loop. */
11587 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11596 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11601 {
11603 /* Only perform transformation if ARG0 is easily inverted. */
11607 ? BIT_IOR_EXPR
11610 arg1);
11611 }
11613 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11618 {
11620 /* Only perform transformation if ARG0 is easily inverted. */
11626 op2);
11627 }
11629 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11641 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11642 of fold_ternary on them. */
11652 {
11662 {
11667 {
11675 }
11677 /* Constructor elements can be subvectors. */
11680 {
11684 }
11686 /* We keep an exact subset of the constructor elements. */
11688 {
11694 {
11698 }
11706 CONSTRUCTOR_ELT
11709 }
11710 /* The bitfield references a single constructor element. */
11712 {
11717 else
11721 }
11722 }
11723 }
11725 /* A bit-field-ref that referenced the full argument can be stripped. */
11731 /* On constants we can use native encode/interpret to constant
11732 fold (nearly) all BIT_FIELD_REFs. */
11736 /* This limitation should not be necessary, we just need to
11737 round this up to mode size. */
11739 /* Need bit-shifting of the buffer to relax the following. */
11741 {
11746 /* ??? We cannot tell native_encode_expr to start at
11747 some random byte only. So limit us to a reasonable amount
11748 of work. */
11750 {
11755 {
11761 }
11762 }
11763 }
11768 /* For integers we can decompose the FMA if possible. */
11780 {
11796 {
11801 /* Make sure that the perm value is in an acceptable
11802 range. */
11811 else
11816 }
11819 {
11824 }
11829 {
11834 }
11840 {
11844 }
11849 /* Some targets are deficient and fail to expand a single
11850 argument permutation while still allowing an equivalent
11851 2-argument version. */
11855 {
11858 }
11861 {
11868 }
11872 }
11878 }
11880 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11881 of an array (or vector). */
11883 tree
11885 {
11890 {
11893 {
11894 /* Static constructors for variably sized objects makes no sense. */
11898 }
11899 }
11910 offset_int max_index;
11915 {
11916 /* Array constructor might explicitely set index, or specify range
11917 * or leave index NULL meaning that it is next index after previous
11918 * one. */
11920 {
11923 else
11924 {
11928 }
11929 }
11930 else
11931 {
11937 }
11939 /* Do we have match? */
11943 }
11945 }
11947 /* Perform constant folding and related simplification of EXPR.
11948 The related simplifications include x*1 => x, x*0 => 0, etc.,
11949 and application of the associative law.
11950 NOP_EXPR conversions may be removed freely (as long as we
11951 are careful not to change the type of the overall expression).
11952 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11953 but we can constant-fold them if they have constant operands. */
11955 #ifdef ENABLE_FOLD_CHECKING
11956 # define fold(x) fold_1 (x)
11958 static
11959 #endif
11960 tree
11962 {
11966 tree tem;
11969 /* Return right away if a constant. */
11973 /* CALL_EXPR-like objects with variable numbers of operands are
11974 treated specially. */
11976 {
11978 {
11981 }
11983 }
11986 {
11991 {
12009 }
12010 }
12013 {
12015 {
12022 {
12027 }
12030 }
12032 /* Return a VECTOR_CST if possible. */
12034 {
12040 tree val;
12046 }
12054 }
12056 #ifdef ENABLE_FOLD_CHECKING
12057 #undef fold
12064 /* When --enable-checking=fold, compute a digest of expr before
12065 and after actual fold call to see if fold did not accidentally
12066 change original expr. */
12068 tree
12070 {
12071 tree ret;
12091 }
12093 void
12095 {
12106 }
12108 static void
12110 {
12112 }
12114 static void
12117 {
12123 recursive_label:
12133 {
12134 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12139 }
12146 {
12147 /* Allow these fields to be modified. */
12148 tree tmp;
12156 {
12159 }
12160 }
12171 {
12174 {
12189 }
12193 {
12206 }
12223 {
12229 }
12232 {
12234 {
12237 }
12239 }
12250 {
12253 }
12263 }
12264 }
12266 /* Helper function for outputting the checksum of a tree T. When
12267 debugging with gdb, you can "define mynext" to be "next" followed
12268 by "call debug_fold_checksum (op0)", then just trace down till the
12269 outputs differ. */
12271 DEBUG_FUNCTION void
12273 {
12288 }
12290 #endif
12292 /* Fold a unary tree expression with code CODE of type TYPE with an
12293 operand OP0. LOC is the location of the resulting expression.
12294 Return a folded expression if successful. Otherwise, return a tree
12295 expression with code CODE of type TYPE with an operand OP0. */
12297 tree
12300 {
12301 tree tem;
12302 #ifdef ENABLE_FOLD_CHECKING
12311 #endif
12317 #ifdef ENABLE_FOLD_CHECKING
12324 #endif
12326 }
12328 /* Fold a binary tree expression with code CODE of type TYPE with
12329 operands OP0 and OP1. LOC is the location of the resulting
12330 expression. Return a folded expression if successful. Otherwise,
12331 return a tree expression with code CODE of type TYPE with operands
12332 OP0 and OP1. */
12334 tree
12337 MEM_STAT_DECL)
12338 {
12339 tree tem;
12340 #ifdef ENABLE_FOLD_CHECKING
12357 #endif
12363 #ifdef ENABLE_FOLD_CHECKING
12378 #endif
12380 }
12382 /* Fold a ternary tree expression with code CODE of type TYPE with
12383 operands OP0, OP1, and OP2. Return a folded expression if
12384 successful. Otherwise, return a tree expression with code CODE of
12385 type TYPE with operands OP0, OP1, and OP2. */
12387 tree
12390 {
12391 tree tem;
12392 #ifdef ENABLE_FOLD_CHECKING
12416 #endif
12423 #ifdef ENABLE_FOLD_CHECKING
12446 #endif
12448 }
12450 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12451 arguments in ARGARRAY, and a null static chain.
12452 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12453 of type TYPE from the given operands as constructed by build_call_array. */
12455 tree
12458 {
12459 tree tem;
12460 #ifdef ENABLE_FOLD_CHECKING
12479 #endif
12485 #ifdef ENABLE_FOLD_CHECKING
12501 #endif
12503 }
12505 /* Perform constant folding and related simplification of initializer
12506 expression EXPR. These behave identically to "fold_buildN" but ignore
12507 potential run-time traps and exceptions that fold must preserve. */
12509 #define START_FOLD_INIT \
12510 int saved_signaling_nans = flag_signaling_nans;\
12511 int saved_trapping_math = flag_trapping_math;\
12512 int saved_rounding_math = flag_rounding_math;\
12513 int saved_trapv = flag_trapv;\
12514 int saved_folding_initializer = folding_initializer;\
12515 flag_signaling_nans = 0;\
12516 flag_trapping_math = 0;\
12517 flag_rounding_math = 0;\
12518 flag_trapv = 0;\
12519 folding_initializer = 1;
12521 #define END_FOLD_INIT \
12522 flag_signaling_nans = saved_signaling_nans;\
12523 flag_trapping_math = saved_trapping_math;\
12524 flag_rounding_math = saved_rounding_math;\
12525 flag_trapv = saved_trapv;\
12526 folding_initializer = saved_folding_initializer;
12528 tree
12531 {
12532 tree result;
12533 START_FOLD_INIT;
12537 END_FOLD_INIT;
12539 }
12541 tree
12544 {
12545 tree result;
12546 START_FOLD_INIT;
12550 END_FOLD_INIT;
12552 }
12554 tree
12557 {
12558 tree result;
12559 START_FOLD_INIT;
12563 END_FOLD_INIT;
12565 }
12567 #undef START_FOLD_INIT
12568 #undef END_FOLD_INIT
12570 /* Determine if first argument is a multiple of second argument. Return 0 if
12571 it is not, or we cannot easily determined it to be.
12573 An example of the sort of thing we care about (at this point; this routine
12574 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12575 fold cases do now) is discovering that
12577 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12579 is a multiple of
12581 SAVE_EXPR (J * 8)
12583 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12585 This code also handles discovering that
12587 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12589 is a multiple of 8 so we don't have to worry about dealing with a
12590 possible remainder.
12592 Note that we *look* inside a SAVE_EXPR only to determine how it was
12593 calculated; it is not safe for fold to do much of anything else with the
12594 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12595 at run time. For example, the latter example above *cannot* be implemented
12596 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12597 evaluation time of the original SAVE_EXPR is not necessarily the same at
12598 the time the new expression is evaluated. The only optimization of this
12599 sort that would be valid is changing
12601 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12603 divided by 8 to
12605 SAVE_EXPR (I) * SAVE_EXPR (J)
12607 (where the same SAVE_EXPR (J) is used in the original and the
12608 transformed version). */
12610 int
12612 {
12620 {
12622 /* Bitwise and provides a power of two multiple. If the mask is
12623 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12626 /* FALLTHRU */
12639 {
12643 /* const_binop may not detect overflow correctly,
12644 so check for it explicitly here. */
12648 size_one_node,
12649 op1)))
12652 }
12656 /* Can't handle conversions from non-integral or wider integral type. */
12662 /* .. fall through ... */
12679 SIGNED);
12683 }
12684 }
12686 #define tree_expr_nonnegative_warnv_p(X, Y) \
12689 #define RECURSE(X) \
12690 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12692 /* Return true if CODE or TYPE is known to be non-negative. */
12694 static bool
12696 {
12699 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12700 have a signed:1 type (where the value is -1 and 0). */
12703 }
12705 /* Return true if (CODE OP0) is known to be non-negative. If the return
12706 value is based on the assumption that signed overflow is undefined,
12707 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12708 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12710 bool
12713 {
12718 {
12720 /* We can't return 1 if flag_wrapv is set because
12721 ABS_EXPR<INT_MIN> = INT_MIN. */
12725 {
12728 }
12736 CASE_CONVERT:
12737 {
12742 {
12746 {
12750 }
12751 }
12753 {
12759 }
12760 }
12765 }
12767 /* We don't know sign of `t', so be conservative and return false. */
12769 }
12771 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12772 value is based on the assumption that signed overflow is undefined,
12773 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12774 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12776 bool
12780 {
12785 {
12791 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12792 both unsigned and at least 2 bits shorter than the result. */
12796 {
12801 {
12805 }
12806 }
12811 {
12812 /* x * x is always non-negative for floating point x
12813 or without overflow. */
12816 {
12821 }
12822 }
12824 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12825 both unsigned and their total bits is shorter than the result. */
12829 {
12848 {
12858 }
12859 }
12886 }
12888 /* We don't know sign of `t', so be conservative and return false. */
12890 }
12892 /* Return true if T is known to be non-negative. If the return
12893 value is based on the assumption that signed overflow is undefined,
12894 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12895 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12897 bool
12899 {
12904 {
12918 /* Limit the depth of recursion to avoid quadratic behavior.
12919 This is expected to catch almost all occurrences in practice.
12920 If this code misses important cases that unbounded recursion
12921 would not, passes that need this information could be revised
12922 to provide it through dataflow propagation. */
12930 }
12931 }
12933 /* Return true if T is known to be non-negative. If the return
12934 value is based on the assumption that signed overflow is undefined,
12935 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12936 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12938 bool
12941 {
12944 {
12964 /* Always true. */
12968 /* sqrt(-0.0) is -0.0. */
13008 /* True if the 1st argument is nonnegative. */
13012 /* True if the 1st OR 2nd arguments are nonnegative. */
13016 /* True if the 1st AND 2nd arguments are nonnegative. */
13020 /* True if the 2nd argument is nonnegative. */
13024 /* True if the 1st argument is nonnegative or the second
13025 argument is an even integer. */
13032 /* True if the 1st argument is nonnegative or the second
13033 argument is an even integer valued real. */
13035 {
13036 REAL_VALUE_TYPE c;
13037 HOST_WIDE_INT n;
13042 {
13043 REAL_VALUE_TYPE cint;
13047 }
13048 }
13053 }
13055 }
13057 /* Return true if T is known to be non-negative. If the return
13058 value is based on the assumption that signed overflow is undefined,
13059 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13060 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13062 static bool
13064 {
13070 {
13072 {
13076 /* If the initializer is non-void, then it's a normal expression
13077 that will be assigned to the slot. */
13081 /* Otherwise, the initializer sets the slot in some way. One common
13082 way is an assignment statement at the end of the initializer. */
13084 {
13092 else
13094 }
13100 }
13103 {
13109 arg0,
13110 arg1,
13112 }
13125 }
13126 }
13128 #undef RECURSE
13129 #undef tree_expr_nonnegative_warnv_p
13131 /* Return true if T is known to be non-negative. If the return
13132 value is based on the assumption that signed overflow is undefined,
13133 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13134 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13136 bool
13138 {
13145 {
13167 }
13170 {
13196 }
13197 }
13199 /* Return true if `t' is known to be non-negative. Handle warnings
13200 about undefined signed overflow. */
13202 bool
13204 {
13211 "determining that expression is always "
13213 WARN_STRICT_OVERFLOW_MISC);
13215 }
13218 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13219 For floating point we further ensure that T is not denormal.
13220 Similar logic is present in nonzero_address in rtlanal.h.
13222 If the return value is based on the assumption that signed overflow
13223 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13224 change *STRICT_OVERFLOW_P. */
13226 bool
13229 {
13231 {
13234 strict_overflow_p);
13237 {
13243 strict_overflow_p));
13244 }
13249 strict_overflow_p);
13253 }
13256 }
13258 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13259 For floating point we further ensure that T is not denormal.
13260 Similar logic is present in nonzero_address in rtlanal.h.
13262 If the return value is based on the assumption that signed overflow
13263 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13264 change *STRICT_OVERFLOW_P. */
13266 bool
13268 tree type,
13269 tree op0,
13271 {
13274 {
13278 {
13279 /* With the presence of negative values it is hard
13280 to say something. */
13287 /* One of operands must be positive and the other non-negative. */
13288 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13289 overflows, on a twos-complement machine the sum of two
13290 nonnegative numbers can never be zero. */
13292 strict_overflow_p)
13294 strict_overflow_p));
13295 }
13300 {
13302 strict_overflow_p)
13304 strict_overflow_p))
13305 {
13308 }
13309 }
13318 {
13321 }
13328 {
13332 /* When both operands are nonzero, then MAX must be too. */
13334 strict_overflow_p))
13337 /* MAX where operand 0 is positive is positive. */
13339 strict_overflow_p);
13340 }
13341 /* MAX where operand 1 is positive is positive. */
13346 {
13350 }
13355 strict_overflow_p)
13357 strict_overflow_p));
13361 }
13364 }
13366 /* Return true when T is an address and is known to be nonzero.
13367 For floating point we further ensure that T is not denormal.
13368 Similar logic is present in nonzero_address in rtlanal.h.
13370 If the return value is based on the assumption that signed overflow
13371 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13372 change *STRICT_OVERFLOW_P. */
13374 bool
13376 {
13379 {
13384 {
13393 /* For objects in symbol table check if we know they are non-zero.
13394 Don't do anything for variables and functions before symtab is built;
13395 it is quite possible that they will be declared weak later. */
13397 {
13403 else
13405 }
13407 /* Function local objects are never NULL. */
13414 /* Constants are never weak. */
13419 }
13427 {
13431 }
13436 }
13438 }
13440 #define integer_valued_real_p(X) \
13443 #define RECURSE(X) \
13444 ((integer_valued_real_p) (X, depth + 1))
13446 /* Return true if the floating point result of (CODE OP0) has an
13447 integer value. We also allow +Inf, -Inf and NaN to be considered
13448 integer values.
13450 DEPTH is the current nesting depth of the query. */
13452 bool
13454 {
13456 {
13463 CASE_CONVERT:
13464 {
13471 }
13475 }
13477 }
13479 /* Return true if the floating point result of (CODE OP0 OP1) has an
13480 integer value. We also allow +Inf, -Inf and NaN to be considered
13481 integer values.
13483 DEPTH is the current nesting depth of the query. */
13485 bool
13487 {
13489 {
13499 }
13501 }
13503 /* Return true if the floating point result of calling FNDECL with arguments
13504 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13505 considered integer values. If FNDECL takes fewer than 2 arguments,
13506 the remaining ARGn are null.
13508 DEPTH is the current nesting depth of the query. */
13510 bool
13512 {
13515 {
13530 }
13532 }
13534 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13535 has an integer value. We also allow +Inf, -Inf and NaN to be
13536 considered integer values.
13538 DEPTH is the current nesting depth of the query. */
13540 bool
13542 {
13544 {
13552 /* Limit the depth of recursion to avoid quadratic behavior.
13553 This is expected to catch almost all occurrences in practice.
13554 If this code misses important cases that unbounded recursion
13555 would not, passes that need this information could be revised
13556 to provide it through dataflow propagation. */
13560 depth));
13564 }
13566 }
13568 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13569 has an integer value. We also allow +Inf, -Inf and NaN to be
13570 considered integer values.
13572 DEPTH is the current nesting depth of the query. */
13574 static bool
13576 {
13578 {
13589 }
13591 }
13593 #undef RECURSE
13594 #undef integer_valued_real_p
13596 /* Return true if the floating point expression T has an integer value.
13597 We also allow +Inf, -Inf and NaN to be considered integer values.
13599 DEPTH is the current nesting depth of the query. */
13601 bool
13603 {
13609 {
13625 }
13628 {
13634 {
13643 }
13647 }
13648 }
13650 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13651 attempt to fold the expression to a constant without modifying TYPE,
13652 OP0 or OP1.
13654 If the expression could be simplified to a constant, then return
13655 the constant. If the expression would not be simplified to a
13656 constant, then return NULL_TREE. */
13658 tree
13660 {
13663 }
13665 /* Given the components of a unary expression CODE, TYPE and OP0,
13666 attempt to fold the expression to a constant without modifying
13667 TYPE or OP0.
13669 If the expression could be simplified to a constant, then return
13670 the constant. If the expression would not be simplified to a
13671 constant, then return NULL_TREE. */
13673 tree
13675 {
13678 }
13680 /* If EXP represents referencing an element in a constant string
13681 (either via pointer arithmetic or array indexing), return the
13682 tree representing the value accessed, otherwise return NULL. */
13684 tree
13686 {
13690 {
13692 tree index;
13693 tree string;
13698 else
13699 {
13703 /* Optimize the special-case of a zero lower bound.
13705 We convert the low_bound to sizetype to avoid some problems
13706 with constant folding. (E.g. suppose the lower bound is 1,
13707 and its mode is QI. Without the conversion,l (ARRAY
13708 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13709 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13715 }
13728 }
13730 }
13732 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13733 an integer constant, real, or fixed-point constant.
13735 TYPE is the type of the result. */
13737 static tree
13739 {
13743 {
13745 {
13752 }
13759 {
13760 FIXED_VALUE_TYPE f;
13765 /* Propagate overflow flags. */
13769 }
13773 }
13776 }
13778 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13779 an integer constant or real constant.
13781 TYPE is the type of the result. */
13783 tree
13785 {
13789 {
13791 {
13792 /* If the value is unsigned or non-negative, then the absolute value
13793 is the same as the ordinary value. */
13797 /* If the value is negative, then the absolute value is
13798 its negation. */
13799 else
13800 {
13805 }
13806 }
13812 else
13818 }
13821 }
13823 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13824 constant. TYPE is the type of the result. */
13826 static tree
13828 {
13832 }
13834 /* Given CODE, a relational operator, the target type, TYPE and two
13835 constant operands OP0 and OP1, return the result of the
13836 relational operation. If the result is not a compile time
13837 constant, then return NULL_TREE. */
13839 static tree
13841 {
13844 /* From here on, the only cases we handle are when the result is
13845 known to be a constant. */
13848 {
13852 /* Handle the cases where either operand is a NaN. */
13854 {
13856 {
13884 }
13887 }
13890 }
13893 {
13897 }
13899 /* Handle equality/inequality of complex constants. */
13901 {
13912 else
13914 }
13917 {
13924 {
13936 }
13939 }
13941 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13943 To compute GT, swap the arguments and do LT.
13944 To compute GE, do LT and invert the result.
13945 To compute LE, swap the arguments, do LT and invert the result.
13946 To compute NE, do EQ and invert the result.
13948 Therefore, the code below must handle only EQ and LT. */
13951 {
13954 }
13956 /* Note that it is safe to invert for real values here because we
13957 have already handled the one case that it matters. */
13961 {
13964 }
13966 /* Compute a result for LT or EQ if args permit;
13967 Otherwise return T. */
13969 {
13972 else
13974 }
13975 else
13981 }
13983 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13984 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13985 itself. */
13987 tree
13989 {
13990 /* If the expression does not have side effects then we don't have to wrap
13991 it with a cleanup point expression. */
13995 /* If the expression is a return, check to see if the expression inside the
13996 return has no side effects or the right hand side of the modify expression
13997 inside the return. If either don't have side effects set we don't need to
13998 wrap the expression in a cleanup point expression. Note we don't check the
13999 left hand side of the modify because it should always be a return decl. */
14001 {
14008 }
14011 }
14013 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14014 of an indirection through OP0, or NULL_TREE if no simplification is
14015 possible. */
14017 tree
14019 {
14021 tree subtype;
14029 {
14032 /* *&CONST_DECL -> to the value of the const decl. */
14035 /* *&p => p; make sure to handle *&"str"[cst] here. */
14037 {
14041 else
14043 }
14044 /* *(foo *)&fooarray => fooarray[0] */
14047 && (!in_gimple_form
14049 {
14059 }
14060 /* *(foo *)&complexfoo => __real__ complexfoo */
14064 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14067 {
14071 }
14072 }
14076 {
14082 {
14083 tree op00type;
14087 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14090 {
14102 }
14103 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14106 {
14110 }
14111 /* ((foo *)&fooarray)[1] => fooarray[1] */
14114 {
14124 }
14125 }
14126 }
14128 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14131 && (!in_gimple_form
14133 {
14134 tree type_domain;
14144 NULL_TREE);
14145 }
14148 }
14150 /* Builds an expression for an indirection through T, simplifying some
14151 cases. */
14153 tree
14155 {
14163 }
14165 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14167 tree
14169 {
14174 else
14176 }
14178 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14179 whose result is ignored. The type of the returned tree need not be
14180 the same as the original expression. */
14182 tree
14184 {
14190 {
14201 else
14207 {
14223 }
14228 }
14229 }
14231 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14233 tree
14235 {
14241 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14242 have to do anything. Only do this when we are not given a const,
14243 because in that case, this check is more expensive than just
14244 doing it. */
14246 {
14251 }
14253 /* If divisor is a power of two, simplify this to bit manipulation. */
14255 {
14257 {
14271 }
14272 else
14273 {
14274 tree t;
14280 }
14281 }
14282 else
14283 {
14288 }
14291 }
14293 /* Likewise, but round down. */
14295 tree
14297 {
14304 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14305 have to do anything. Only do this when we are not given a const,
14306 because in that case, this check is more expensive than just
14307 doing it. */
14309 {
14314 }
14316 /* If divisor is a power of two, simplify this to bit manipulation. */
14318 {
14319 tree t;
14323 }
14324 else
14325 {
14330 }
14333 }
14335 /* Returns the pointer to the base of the object addressed by EXP and
14336 extracts the information about the offset of the access, storing it
14337 to PBITPOS and POFFSET. */
14339 static tree
14342 {
14343 tree core;
14344 machine_mode mode;
14346 HOST_WIDE_INT bitsize;
14350 {
14355 }
14356 else
14357 {
14361 }
14364 }
14366 /* Returns true if addresses of E1 and E2 differ by a constant, false
14367 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14369 bool
14371 {
14385 {
14395 }
14397 {
14398 /* If only one of the offsets is non-constant, the difference cannot
14399 be a constant. */
14401 }
14402 else
14407 }
14409 /* Return OFF converted to a pointer offset type suitable as offset for
14410 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14411 tree
14413 {
14415 }
14417 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14418 tree
14420 {
14423 }
14425 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14426 tree
14428 {
14431 }
14433 /* Return a char pointer for a C string if it is a string constant
14434 or sum of string constant and integer constant. */
14438 {
14439 tree offset_node;
14452 }