| blob | 5d8822fde8e89b0d661eda8a2264ede45332692e |
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. */
83 #ifndef LOAD_EXTEND_OP
84 #define LOAD_EXTEND_OP(M) UNKNOWN
85 #endif
87 /* Nonzero if we are folding constants inside an initializer; zero
88 otherwise. */
91 /* The following constants represent a bit based encoding of GCC's
92 comparison operators. This encoding simplifies transformations
93 on relational comparison operators, such as AND and OR. */
111 };
128 HOST_WIDE_INT *,
157 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
158 Otherwise, return LOC. */
160 static location_t
162 {
165 }
167 /* Similar to protected_set_expr_location, but never modify x in place,
168 if location can and needs to be set, unshare it. */
172 {
178 {
181 }
183 }
184 \f
185 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
186 division and returns the quotient. Otherwise returns
187 NULL_TREE. */
189 tree
191 {
192 widest_int quo;
199 }
200 \f
201 /* This is nonzero if we should defer warnings about undefined
202 overflow. This facility exists because these warnings are a
203 special case. The code to estimate loop iterations does not want
204 to issue any warnings, since it works with expressions which do not
205 occur in user code. Various bits of cleanup code call fold(), but
206 only use the result if it has certain characteristics (e.g., is a
207 constant); that code only wants to issue a warning if the result is
208 used. */
212 /* If a warning about undefined overflow is deferred, this is the
213 warning. Note that this may cause us to turn two warnings into
214 one, but that is fine since it is sufficient to only give one
215 warning per expression. */
219 /* If a warning about undefined overflow is deferred, this is the
220 level at which the warning should be emitted. */
224 /* Start deferring overflow warnings. We could use a stack here to
225 permit nested calls, but at present it is not necessary. */
227 void
229 {
231 }
233 /* Stop deferring overflow warnings. If there is a pending warning,
234 and ISSUE is true, then issue the warning if appropriate. STMT is
235 the statement with which the warning should be associated (used for
236 location information); STMT may be NULL. CODE is the level of the
237 warning--a warn_strict_overflow_code value. This function will use
238 the smaller of CODE and the deferred code when deciding whether to
239 issue the warning. CODE may be zero to mean to always use the
240 deferred code. */
242 void
244 {
246 location_t locus;
251 {
257 }
268 /* Use the smallest code level when deciding to issue the
269 warning. */
278 else
281 }
283 /* Stop deferring overflow warnings, ignoring any deferred
284 warnings. */
286 void
288 {
290 }
292 /* Whether we are deferring overflow warnings. */
294 bool
296 {
298 }
300 /* This is called when we fold something based on the fact that signed
301 overflow is undefined. */
303 static void
305 {
307 {
310 {
313 }
314 }
317 }
318 \f
319 /* Return true if the built-in mathematical function specified by CODE
320 is odd, i.e. -f(x) == f(-x). */
322 static bool
324 {
326 {
360 }
362 }
364 /* Check whether we may negate an integer constant T without causing
365 overflow. */
367 bool
369 {
370 tree type;
379 }
381 /* Determine whether an expression T can be cheaply negated using
382 the function negate_expr without introducing undefined overflow. */
384 static bool
386 {
387 tree type;
396 {
401 /* Check that -CST will not overflow type. */
414 /* We want to canonicalize to positive real constants. Pretend
415 that only negative ones can be easily negated. */
423 {
434 }
447 /* -(A + B) -> (-B) - A. */
452 /* -(A + B) -> (-A) - B. */
456 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
466 /* Fall through. */
477 /* In general we can't negate A / B, because if A is INT_MIN and
478 B is 1, we may turn this into INT_MIN / -1 which is undefined
479 and actually traps on some architectures. But if overflow is
480 undefined, we can negate, because - (INT_MIN / 1) is an
481 overflow. */
483 {
486 /* If overflow is undefined then we have to be careful because
487 we ask whether it's ok to associate the negate with the
488 division which is not ok for example for
489 -((a - b) / c) where (-(a - b)) / c may invoke undefined
490 overflow because of negating INT_MIN. So do not use
491 negate_expr_p here but open-code the two important cases. */
496 }
502 /* Negate -((double)float) as (double)(-float). */
504 {
508 }
512 /* Negate -f(x) as f(-x). */
518 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
520 {
524 }
529 }
531 }
533 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
534 simplification is possible.
535 If negate_expr_p would return true for T, NULL_TREE will never be
536 returned. */
538 static tree
540 {
542 tree tem;
545 {
546 /* Convert - (~A) to A + 1. */
572 {
577 }
581 {
586 {
590 }
593 }
616 {
617 /* -(A + B) -> (-B) - A. */
621 {
625 }
627 /* -(A + B) -> (-A) - B. */
629 {
633 }
634 }
638 /* - (A - B) -> B - A */
650 /* Fall through. */
654 {
663 }
669 /* In general we can't negate A / B, because if A is INT_MIN and
670 B is 1, we may turn this into INT_MIN / -1 which is undefined
671 and actually traps on some architectures. But if overflow is
672 undefined, we can negate, because - (INT_MIN / 1) is an
673 overflow. */
675 {
680 {
687 }
688 /* If overflow is undefined then we have to be careful because
689 we ask whether it's ok to associate the negate with the
690 division which is not ok for example for
691 -((a - b) / c) where (-(a - b)) / c may invoke undefined
692 overflow because of negating INT_MIN. So do not use
693 negate_expr_p here but open-code the two important cases. */
702 }
706 /* Convert -((double)float) into (double)(-float). */
708 {
712 }
716 /* Negate -f(x) as f(-x). */
719 {
725 }
729 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
731 {
734 {
741 }
742 }
747 }
750 }
752 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
753 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
754 return NULL_TREE. */
756 static tree
758 {
760 location_t loc;
773 }
774 \f
775 /* Split a tree IN into a constant, literal and variable parts that could be
776 combined with CODE to make IN. "constant" means an expression with
777 TREE_CONSTANT but that isn't an actual constant. CODE must be a
778 commutative arithmetic operation. Store the constant part into *CONP,
779 the literal in *LITP and return the variable part. If a part isn't
780 present, set it to null. If the tree does not decompose in this way,
781 return the entire tree as the variable part and the other parts as null.
783 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
784 case, we negate an operand that was subtracted. Except if it is a
785 literal for which we use *MINUS_LITP instead.
787 If NEGATE_P is true, we are negating all of IN, again except a literal
788 for which we use *MINUS_LITP instead.
790 If IN is itself a literal or constant, return it as appropriate.
792 Note that we do not guarantee that any of the three values will be the
793 same type as IN, but they will have the same signedness and mode. */
795 static tree
798 {
805 /* Strip any conversions that don't change the machine mode or signedness. */
814 /* We can associate addition and subtraction together (even
815 though the C standard doesn't say so) for integers because
816 the value is not affected. For reals, the value might be
817 affected, so we can't. */
820 {
826 /* First see if either of the operands is a literal, then a constant. */
839 /* If we haven't dealt with either operand, this is not a case we can
840 decompose. Otherwise, VAR is either of the ones remaining, if any. */
845 else
848 /* Now do any needed negations. */
855 }
858 {
859 /* -X - 1 is folded to ~X, undo that here. */
862 }
865 else
869 {
876 }
879 }
881 /* Re-associate trees split by the above function. T1 and T2 are
882 either expressions to associate or null. Return the new
883 expression, if any. LOC is the location of the new expression. If
884 we build an operation, do it in TYPE and with CODE. */
886 static tree
888 {
894 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
895 try to fold this since we will have infinite recursion. But do
896 deal with any NEGATE_EXPRs. */
899 {
901 {
914 }
916 {
919 }
923 }
927 }
928 \f
929 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
930 for use in int_const_binop, size_binop and size_diffop. */
932 static bool
934 {
941 {
950 }
955 }
958 /* Combine two integer constants ARG1 and ARG2 under operation CODE
959 to produce a new constant. Return NULL_TREE if we don't know how
960 to evaluate CODE at compile-time. */
962 static tree
965 {
966 wide_int res;
967 tree t;
976 {
992 {
996 else
998 }
1001 /* It's unclear from the C standard whether shifts can overflow.
1002 The following code ignores overflow; perhaps a C standard
1003 interpretation ruling is needed. */
1005 else
1012 {
1016 else
1018 }
1022 else
1101 }
1109 }
1111 tree
1113 {
1115 }
1117 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1118 constant. We assume ARG1 and ARG2 have the same data type, or at least
1119 are the same kind of constant and the same machine mode. Return zero if
1120 combining the constants is not allowed in the current operating mode. */
1122 static tree
1124 {
1125 /* Sanity check for the recursive cases. */
1133 {
1139 }
1142 {
1143 machine_mode mode;
1144 REAL_VALUE_TYPE d1;
1145 REAL_VALUE_TYPE d2;
1146 REAL_VALUE_TYPE value;
1147 REAL_VALUE_TYPE result;
1151 /* The following codes are handled by real_arithmetic. */
1153 {
1164 }
1172 /* Don't perform operation if we honor signaling NaNs and
1173 either operand is a NaN. */
1178 /* Don't perform operation if it would raise a division
1179 by zero exception. */
1185 /* If either operand is a NaN, just return it. Otherwise, set up
1186 for floating-point trap; we return an overflow. */
1195 /* Don't constant fold this floating point operation if
1196 the result has overflowed and flag_trapping_math. */
1204 /* Don't constant fold this floating point operation if the
1205 result may dependent upon the run-time rounding mode and
1206 flag_rounding_math is set, or if GCC's software emulation
1207 is unable to accurately represent the result. */
1217 }
1220 {
1221 FIXED_VALUE_TYPE f1;
1222 FIXED_VALUE_TYPE f2;
1223 FIXED_VALUE_TYPE result;
1228 /* The following codes are handled by fixed_arithmetic. */
1230 {
1242 {
1249 }
1254 }
1261 /* Propagate overflow flags. */
1265 }
1268 {
1277 {
1288 mpc_mul);
1302 mpc_div);
1303 /* Fallthru ... */
1309 {
1310 /* Keep this algorithm in sync with
1311 tree-complex.c:expand_complex_div_straight().
1313 Expand complex division to scalars, straightforward algorithm.
1314 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1315 t = br*br + bi*bi
1316 */
1317 tree magsquared
1321 tree t1
1325 tree t2
1332 }
1333 else
1334 {
1335 /* Keep this algorithm in sync with
1336 tree-complex.c:expand_complex_div_wide().
1338 Expand complex division to scalars, modified algorithm to minimize
1339 overflow with wide input ranges. */
1345 {
1346 /* In the TRUE branch, we compute
1347 ratio = br/bi;
1348 div = (br * ratio) + bi;
1349 tr = (ar * ratio) + ai;
1350 ti = (ai * ratio) - ar;
1351 tr = tr / div;
1352 ti = ti / div; */
1363 }
1364 else
1365 {
1366 /* In the FALSE branch, we compute
1367 ratio = d/c;
1368 divisor = (d * ratio) + c;
1369 tr = (b * ratio) + a;
1370 ti = b - (a * ratio);
1371 tr = tr / div;
1372 ti = ti / div; */
1384 }
1385 }
1390 }
1394 }
1398 {
1404 {
1410 /* It is possible that const_binop cannot handle the given
1411 code and return NULL_TREE */
1414 }
1417 }
1419 /* Shifts allow a scalar offset for a vector. */
1422 {
1428 {
1433 /* It is possible that const_binop cannot handle the given
1434 code and return NULL_TREE. */
1437 }
1440 }
1442 }
1444 /* Overload that adds a TYPE parameter to be able to dispatch
1445 to fold_relational_const. */
1447 tree
1449 {
1453 /* ??? Until we make the const_binop worker take the type of the
1454 result as argument put those cases that need it here. */
1456 {
1467 {
1483 {
1489 }
1492 }
1498 {
1523 {
1536 }
1539 }
1542 }
1547 /* Make sure type and arg0 have the same saturating flag. */
1552 }
1554 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1555 Return zero if computing the constants is not possible. */
1557 tree
1559 {
1561 {
1562 CASE_CONVERT:
1577 {
1578 /* Can't call fold_negate_const directly here as that doesn't
1579 handle all cases and we might not be able to negate some
1580 constants. */
1585 }
1594 {
1598 }
1604 /* Perform BIT_NOT_EXPR on each element individually. */
1606 {
1608 tree elem;
1613 {
1619 }
1622 }
1644 {
1663 else
1667 {
1671 }
1674 }
1679 {
1693 {
1698 }
1701 {
1705 }
1708 }
1712 }
1715 }
1717 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1718 indicates which particular sizetype to create. */
1720 tree
1722 {
1724 }
1725 \f
1726 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1727 is a tree code. The type of the result is taken from the operands.
1728 Both must be equivalent integer types, ala int_binop_types_match_p.
1729 If the operands are constant, so is the result. */
1731 tree
1733 {
1742 /* Handle the special case of two integer constants faster. */
1744 {
1745 /* And some specific cases even faster than that. */
1747 {
1752 }
1754 {
1757 }
1759 {
1762 }
1764 /* Handle general case of two integer constants. For sizetype
1765 constant calculations we always want to know about overflow,
1766 even in the unsigned case. */
1768 }
1771 }
1773 /* Given two values, either both of sizetype or both of bitsizetype,
1774 compute the difference between the two values. Return the value
1775 in signed type corresponding to the type of the operands. */
1777 tree
1779 {
1781 tree ctype;
1786 /* If the type is already signed, just do the simple thing. */
1794 else
1797 /* If either operand is not a constant, do the conversions to the signed
1798 type and subtract. The hardware will do the right thing with any
1799 overflow in the subtraction. */
1805 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1806 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1807 overflow) and negate (which can't either). Special-case a result
1808 of zero while we're here. */
1814 else
1818 MINUS_EXPR,
1820 }
1821 \f
1822 /* A subroutine of fold_convert_const handling conversions of an
1823 INTEGER_CST to another integer type. */
1825 static tree
1827 {
1828 /* Given an integer constant, make new constant with new type,
1829 appropriately sign-extended or truncated. Use widest_int
1830 so that any extension is done according ARG1's type. */
1834 }
1836 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1837 to an integer type. */
1839 static tree
1841 {
1843 tree t;
1845 /* The following code implements the floating point to integer
1846 conversion rules required by the Java Language Specification,
1847 that IEEE NaNs are mapped to zero and values that overflow
1848 the target precision saturate, i.e. values greater than
1849 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1850 are mapped to INT_MIN. These semantics are allowed by the
1851 C and C++ standards that simply state that the behavior of
1852 FP-to-integer conversion is unspecified upon overflow. */
1854 wide_int val;
1855 REAL_VALUE_TYPE r;
1859 {
1866 }
1868 /* If R is NaN, return zero and show we have an overflow. */
1870 {
1873 }
1875 /* See if R is less than the lower bound or greater than the
1876 upper bound. */
1879 {
1883 {
1886 }
1887 }
1890 {
1893 {
1896 {
1899 }
1900 }
1901 }
1908 }
1910 /* A subroutine of fold_convert_const handling conversions of a
1911 FIXED_CST to an integer type. */
1913 static tree
1915 {
1916 tree t;
1920 /* Right shift FIXED_CST to temp by fbit. */
1924 {
1926 HOST_BITS_PER_DOUBLE_INT,
1929 /* Left shift temp to temp_trunc by fbit. */
1931 HOST_BITS_PER_DOUBLE_INT,
1933 }
1934 else
1935 {
1938 }
1940 /* If FIXED_CST is negative, we need to round the value toward 0.
1941 By checking if the fractional bits are not zero to add 1 to temp. */
1947 /* Given a fixed-point constant, make new constant with new type,
1948 appropriately sign-extended or truncated. */
1956 }
1958 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1959 to another floating point type. */
1961 static tree
1963 {
1964 REAL_VALUE_TYPE value;
1965 tree t;
1970 /* If converting an infinity or NAN to a representation that doesn't
1971 have one, set the overflow bit so that we can produce some kind of
1972 error message at the appropriate point if necessary. It's not the
1973 most user-friendly message, but it's better than nothing. */
1980 /* Regular overflow, conversion produced an infinity in a mode that
1981 can't represent them. */
1986 else
1989 }
1991 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1992 to a floating point type. */
1994 static tree
1996 {
1997 REAL_VALUE_TYPE value;
1998 tree t;
2005 }
2007 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2008 to another fixed-point type. */
2010 static tree
2012 {
2013 FIXED_VALUE_TYPE value;
2014 tree t;
2021 /* Propagate overflow flags. */
2025 }
2027 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2028 to a fixed-point type. */
2030 static tree
2032 {
2033 FIXED_VALUE_TYPE value;
2034 tree t;
2036 double_int di;
2043 else
2051 /* Propagate overflow flags. */
2055 }
2057 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2058 to a fixed-point type. */
2060 static tree
2062 {
2063 FIXED_VALUE_TYPE value;
2064 tree t;
2072 /* Propagate overflow flags. */
2076 }
2078 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2079 type TYPE. If no simplification can be done return NULL_TREE. */
2081 static tree
2083 {
2089 {
2096 }
2098 {
2105 }
2107 {
2114 }
2116 }
2118 /* Construct a vector of zero elements of vector type TYPE. */
2120 static tree
2122 {
2123 tree t;
2127 }
2129 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2131 bool
2133 {
2148 {
2167 }
2168 }
2170 /* Convert expression ARG to type TYPE. Used by the middle-end for
2171 simple conversions in preference to calling the front-end's convert. */
2173 tree
2175 {
2177 tree tem;
2188 {
2191 /* Handle conversions between pointers to different address spaces. */
2196 /* fall through */
2201 {
2205 }
2219 {
2223 }
2225 {
2229 }
2231 {
2235 }
2238 {
2256 }
2261 {
2265 }
2268 {
2282 }
2286 {
2295 integer_zero_node));
2297 {
2301 {
2307 }
2315 }
2319 }
2337 }
2338 fold_convert_exit:
2341 }
2342 \f
2343 /* Return false if expr can be assumed not to be an lvalue, true
2344 otherwise. */
2346 static bool
2348 {
2349 /* We only need to wrap lvalue tree codes. */
2351 {
2382 /* Assume the worst for front-end tree codes. */
2386 }
2389 }
2391 /* Return an expr equal to X but certainly not valid as an lvalue. */
2393 tree
2395 {
2396 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2397 us. */
2404 }
2406 /* When pedantic, return an expr equal to X but certainly not valid as a
2407 pedantic lvalue. Otherwise, return X. */
2409 static tree
2411 {
2413 }
2414 \f
2415 /* Given a tree comparison code, return the code that is the logical inverse.
2416 It is generally not safe to do this for floating-point comparisons, except
2417 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2418 ERROR_MARK in this case. */
2420 enum tree_code
2422 {
2428 {
2459 }
2460 }
2462 /* Similar, but return the comparison that results if the operands are
2463 swapped. This is safe for floating-point. */
2465 enum tree_code
2467 {
2469 {
2495 }
2496 }
2499 /* Convert a comparison tree code from an enum tree_code representation
2500 into a compcode bit-based encoding. This function is the inverse of
2501 compcode_to_comparison. */
2503 static enum comparison_code
2505 {
2507 {
2538 }
2539 }
2541 /* Convert a compcode bit-based encoding of a comparison operator back
2542 to GCC's enum tree_code representation. This function is the
2543 inverse of comparison_to_compcode. */
2545 static enum tree_code
2547 {
2549 {
2580 }
2581 }
2583 /* Return a tree for the comparison which is the combination of
2584 doing the AND or OR (depending on CODE) of the two operations LCODE
2585 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2586 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2587 if this makes the transformation invalid. */
2589 tree
2594 {
2601 {
2612 }
2615 {
2616 /* Eliminate unordered comparisons, as well as LTGT and ORD
2617 which are not used unless the mode has NaNs. */
2623 }
2625 {
2626 /* Check that the original operation and the optimized ones will trap
2627 under the same condition. */
2638 /* In a short-circuited boolean expression the LHS might be
2639 such that the RHS, if evaluated, will never trap. For
2640 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2641 if neither x nor y is NaN. (This is a mixed blessing: for
2642 example, the expression above will never trap, hence
2643 optimizing it to x < y would be invalid). */
2648 /* If the comparison was short-circuited, and only the RHS
2649 trapped, we may now generate a spurious trap. */
2654 /* If we changed the conditions that cause a trap, we lose. */
2657 }
2663 else
2664 {
2669 }
2670 }
2671 \f
2672 /* Return nonzero if two operands (typically of the same tree node)
2673 are necessarily equal. If either argument has side-effects this
2674 function returns zero. FLAGS modifies behavior as follows:
2676 If OEP_ONLY_CONST is set, only return nonzero for constants.
2677 This function tests whether the operands are indistinguishable;
2678 it does not test whether they are equal using C's == operation.
2679 The distinction is important for IEEE floating point, because
2680 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2681 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2683 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2684 even though it may hold multiple values during a function.
2685 This is because a GCC tree node guarantees that nothing else is
2686 executed between the evaluation of its "operands" (which may often
2687 be evaluated in arbitrary order). Hence if the operands themselves
2688 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2689 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2690 unset means assuming isochronic (or instantaneous) tree equivalence.
2691 Unless comparing arbitrary expression trees, such as from different
2692 statements, this flag can usually be left unset.
2694 If OEP_PURE_SAME is set, then pure functions with identical arguments
2695 are considered the same. It is used when the caller has other ways
2696 to ensure that global memory is unchanged in between. */
2698 int
2700 {
2701 /* If either is ERROR_MARK, they aren't equal. */
2707 /* Similar, if either does not have a type (like a released SSA name),
2708 they aren't equal. */
2712 /* Check equality of integer constants before bailing out due to
2713 precision differences. */
2717 /* If both types don't have the same signedness, then we can't consider
2718 them equal. We must check this before the STRIP_NOPS calls
2719 because they may change the signedness of the arguments. As pointers
2720 strictly don't have a signedness, require either two pointers or
2721 two non-pointers as well. */
2726 /* We cannot consider pointers to different address space equal. */
2732 /* If both types don't have the same precision, then it is not safe
2733 to strip NOPs. */
2741 /* In case both args are comparisons but with different comparison
2742 code, try to swap the comparison operands of one arg to produce
2743 a match and compare that variant. */
2747 {
2755 }
2758 {
2759 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2761 ;
2763 {
2764 /* If we are interested in comparing addresses ignore
2765 MEM_REF wrappings of the base that can appear just for
2766 TBAA reasons. */
2780 }
2781 else
2783 }
2785 /* This is needed for conversions and for COMPONENT_REF.
2786 Might as well play it safe and always test this. */
2792 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2793 We don't care about side effects in that case because the SAVE_EXPR
2794 takes care of that for us. In all other cases, two expressions are
2795 equal if they have no side effects. If we have two identical
2796 expressions with side effects that should be treated the same due
2797 to the only side effects being identical SAVE_EXPR's, that will
2798 be detected in the recursive calls below.
2799 If we are taking an invariant address of two identical objects
2800 they are necessarily equal as well. */
2807 /* Next handle constant cases, those for which we can return 1 even
2808 if ONLY_CONST is set. */
2811 {
2825 {
2826 /* If we do not distinguish between signed and unsigned zero,
2827 consider them equal. */
2830 }
2834 {
2841 {
2845 }
2847 }
2851 flags)
2853 flags));
2867 }
2872 /* Define macros to test an operand from arg0 and arg1 for equality and a
2873 variant that allows null and views null as being different from any
2874 non-null value. In the latter case, if either is null, the both
2875 must be; otherwise, do the normal comparison. */
2876 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2877 TREE_OPERAND (arg1, N), flags)
2879 #define OP_SAME_WITH_NULL(N) \
2880 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2881 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2884 {
2886 /* Two conversions are equal only if signedness and modes match. */
2888 {
2889 CASE_CONVERT:
2897 }
2907 /* For commutative ops, allow the other order. */
2915 /* If either of the pointer (or reference) expressions we are
2916 dereferencing contain a side effect, these cannot be equal,
2917 but their addresses can be. */
2924 {
2939 /* Require equal access sizes, and similar pointer types.
2940 We can have incomplete types for array references of
2941 variable-sized arrays from the Fortran frontend
2942 though. Also verify the types are compatible. */
2950 || (alias_ptr_types_compatible_p
2962 /* TARGET_MEM_REF require equal extra operands. */
2970 /* Operands 2 and 3 may be null.
2971 Compare the array index by value if it is constant first as we
2972 may have different types but same value here. */
2983 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
2984 may be NULL when we're called to compare MEM_EXPRs. */
2999 }
3003 {
3021 /* The multiplcation operands are commutative. */
3022 /* FALLTHRU */
3030 /* Otherwise take into account this is a commutative operation. */
3043 }
3047 {
3051 /* If not both CALL_EXPRs are either internal or normal function
3052 functions, then they are not equal. */
3055 {
3056 /* If the CALL_EXPRs call different internal functions, then they
3057 are not equal. */
3060 }
3061 else
3062 {
3063 /* If the CALL_EXPRs call different functions, then they are not
3064 equal. */
3066 flags))
3068 }
3070 {
3074 else
3078 }
3080 /* Now see if all the arguments are the same. */
3081 {
3092 /* If we get here and both argument lists are exhausted
3093 then the CALL_EXPRs are equal. */
3095 }
3098 }
3101 /* Consider __builtin_sqrt equal to sqrt. */
3109 }
3111 #undef OP_SAME
3112 #undef OP_SAME_WITH_NULL
3113 }
3114 \f
3115 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3116 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3118 When in doubt, return 0. */
3120 static int
3122 {
3134 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3135 and see if the inner values are the same. This removes any
3136 signedness comparison, which doesn't matter here. */
3143 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3144 actual comparison operand, ARG0.
3146 First throw away any conversions to wider types
3147 already present in the operands. */
3156 {
3159 /* Make sure shorter operand is extended the right way
3160 to match the longer operand. */
3166 }
3169 }
3170 \f
3171 /* See if ARG is an expression that is either a comparison or is performing
3172 arithmetic on comparisons. The comparisons must only be comparing
3173 two different values, which will be stored in *CVAL1 and *CVAL2; if
3174 they are nonzero it means that some operands have already been found.
3175 No variables may be used anywhere else in the expression except in the
3176 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3177 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3179 If this is true, return 1. Otherwise, return zero. */
3181 static int
3183 {
3187 /* We can handle some of the tcc_expression cases here. */
3197 {
3198 /* If we've already found a CVAL1 or CVAL2, this expression is
3199 two complex to handle. */
3205 }
3208 {
3231 /* First see if we can handle the first operand, then the second. For
3232 the second operand, we know *CVAL1 can't be zero. It must be that
3233 one side of the comparison is each of the values; test for the
3234 case where this isn't true by failing if the two operands
3235 are the same. */
3244 ;
3248 ;
3249 else
3253 ;
3257 ;
3258 else
3265 }
3266 }
3267 \f
3268 /* ARG is a tree that is known to contain just arithmetic operations and
3269 comparisons. Evaluate the operations in the tree substituting NEW0 for
3270 any occurrence of OLD0 as an operand of a comparison and likewise for
3271 NEW1 and OLD1. */
3273 static tree
3276 {
3281 /* We can handle some of the tcc_expression cases here. */
3289 {
3304 {
3323 }
3324 /* Fall through - ??? */
3327 {
3331 /* We need to check both for exact equality and tree equality. The
3332 former will be true if the operand has a side-effect. In that
3333 case, we know the operand occurred exactly once. */
3346 }
3350 }
3351 }
3352 \f
3353 /* Return a tree for the case when the result of an expression is RESULT
3354 converted to TYPE and OMITTED was previously an operand of the expression
3355 but is now not needed (e.g., we folded OMITTED * 0).
3357 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3358 the conversion of RESULT to TYPE. */
3360 tree
3362 {
3365 /* If the resulting operand is an empty statement, just return the omitted
3366 statement casted to void. */
3376 }
3378 /* Return a tree for the case when the result of an expression is RESULT
3379 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3380 of the expression but are now not needed.
3382 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3383 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3384 evaluated before OMITTED2. Otherwise, if neither has side effects,
3385 just do the conversion of RESULT to TYPE. */
3387 tree
3390 {
3399 }
3401 \f
3402 /* Return a simplified tree node for the truth-negation of ARG. This
3403 never alters ARG itself. We assume that ARG is an operation that
3404 returns a truth value (0 or 1).
3406 FIXME: one would think we would fold the result, but it causes
3407 problems with the dominator optimizer. */
3409 static tree
3411 {
3416 /* If this is a comparison, we can simply invert it, except for
3417 floating-point non-equality comparisons, in which case we just
3418 enclose a TRUTH_NOT_EXPR around what we have. */
3421 {
3424 && flag_trapping_math
3435 }
3438 {
3457 /* Here we can invert either operand. We invert the first operand
3458 unless the second operand is a TRUTH_NOT_EXPR in which case our
3459 result is the XOR of the first operand with the inside of the
3460 negation of the second operand. */
3465 else
3488 {
3495 /* A COND_EXPR may have a throw as one operand, which
3496 then has void type. Just leave void operands
3497 as they are. */
3503 }
3515 CASE_CONVERT:
3519 /* ... fall through ... */
3541 }
3542 }
3544 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3545 assume that ARG is an operation that returns a truth value (0 or 1
3546 for scalars, 0 or -1 for vectors). Return the folded expression if
3547 folding is successful. Otherwise, return NULL_TREE. */
3549 static tree
3551 {
3554 ? BIT_NOT_EXPR
3557 }
3559 /* Return a simplified tree node for the truth-negation of ARG. This
3560 never alters ARG itself. We assume that ARG is an operation that
3561 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3563 tree
3565 {
3571 ? BIT_NOT_EXPR
3574 }
3576 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3577 with code CODE. This optimization is unsafe. */
3578 static tree
3581 {
3585 /* (A / C) +- (B / C) -> (A +- B) / C. */
3595 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3600 {
3612 }
3615 }
3616 \f
3617 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3618 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3620 static tree
3623 {
3627 {
3634 }
3648 }
3650 /* Optimize a bit-field compare.
3652 There are two cases: First is a compare against a constant and the
3653 second is a comparison of two items where the fields are at the same
3654 bit position relative to the start of a chunk (byte, halfword, word)
3655 large enough to contain it. In these cases we can avoid the shift
3656 implicit in bitfield extractions.
3658 For constants, we emit a compare of the shifted constant with the
3659 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3660 compared. For two fields at the same position, we do the ANDs with the
3661 similar mask and compare the result of the ANDs.
3663 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3664 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3665 are the left and right operands of the comparison, respectively.
3667 If the optimization described above can be done, we return the resulting
3668 tree. Otherwise we return zero. */
3670 static tree
3673 {
3676 tree unsigned_type;
3682 tree mask;
3683 tree offset;
3685 /* Get all the information about the extractions being done. If the bit size
3686 if the same as the size of the underlying object, we aren't doing an
3687 extraction at all and so can do nothing. We also don't want to
3688 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3689 then will no longer be able to replace it. */
3697 {
3698 /* If this is not a constant, we can only do something if bit positions,
3699 sizes, and signedness are the same. */
3707 }
3709 /* See if we can find a mode to refer to this field. We should be able to,
3710 but fail if we can't. */
3719 /* Set signed and unsigned types of the precision of this mode for the
3720 shifts below. */
3723 /* Compute the bit position and size for the new reference and our offset
3724 within it. If the new reference is the same size as the original, we
3725 won't optimize anything, so return zero. */
3735 /* Make the mask to be used against the extracted field. */
3742 /* If not comparing with constant, just rework the comparison
3743 and return. */
3747 unsigned_type,
3750 mask),
3753 unsigned_type,
3756 mask));
3758 /* Otherwise, we are handling the constant case. See if the constant is too
3759 big for the field. Warn and return a tree of for 0 (false) if so. We do
3760 this not only for its own sake, but to avoid having to test for this
3761 error case below. If we didn't, we might generate wrong code.
3763 For unsigned fields, the constant shifted right by the field length should
3764 be all zero. For signed fields, the high-order bits should agree with
3765 the sign bit. */
3768 {
3770 {
3774 }
3775 }
3776 else
3777 {
3780 {
3784 }
3785 }
3787 /* Single-bit compares should always be against zero. */
3789 {
3792 }
3794 /* Make a new bitfield reference, shift the constant over the
3795 appropriate number of bits and mask it with the computed mask
3796 (in case this was a signed field). If we changed it, make a new one. */
3803 mask);
3808 }
3809 \f
3810 /* Subroutine for fold_truth_andor_1: decode a field reference.
3812 If EXP is a comparison reference, we return the innermost reference.
3814 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3815 set to the starting bit number.
3817 If the innermost field can be completely contained in a mode-sized
3818 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3820 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3821 otherwise it is not changed.
3823 *PUNSIGNEDP is set to the signedness of the field.
3825 *PMASK is set to the mask used. This is either contained in a
3826 BIT_AND_EXPR or derived from the width of the field.
3828 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3830 Return 0 if this is not a component reference or is one that we can't
3831 do anything with. */
3833 static tree
3838 {
3842 tree unsigned_type;
3845 /* All the optimizations using this function assume integer fields.
3846 There are problems with FP fields since the type_for_size call
3847 below can fail for, e.g., XFmode. */
3851 /* We are interested in the bare arrangement of bits, so strip everything
3852 that doesn't affect the machine mode. However, record the type of the
3853 outermost expression if it may matter below. */
3860 {
3866 }
3875 /* If the number of bits in the reference is the same as the bitsize of
3876 the outer type, then the outer type gives the signedness. Otherwise
3877 (in case of a small bitfield) the signedness is unchanged. */
3881 /* Compute the mask to access the bitfield. */
3890 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3898 }
3900 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3901 bit positions and MASK is SIGNED. */
3903 static int
3905 {
3909 /* If this function returns true when the type of the mask is
3910 UNSIGNED, then there will be errors. In particular see
3911 gcc.c-torture/execute/990326-1.c. There does not appear to be
3912 any documentation paper trail as to why this is so. But the pre
3913 wide-int worked with that restriction and it has been preserved
3914 here. */
3919 }
3921 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3922 represents the sign bit of EXP's type. If EXP represents a sign
3923 or zero extension, also test VAL against the unextended type.
3924 The return value is the (sub)expression whose sign bit is VAL,
3925 or NULL_TREE otherwise. */
3927 tree
3929 {
3931 tree t;
3933 /* Tree EXP must have an integral type. */
3938 /* Tree VAL must be an integer constant. */
3947 /* Handle extension from a narrower type. */
3953 }
3955 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3956 to be evaluated unconditionally. */
3958 static int
3960 {
3961 /* Strip any conversions that don't change the machine mode. */
3970 /* Don't regard global variables as simple. They may be
3971 allocated in ways unknown to the compiler (shared memory,
3972 #pragma weak, etc). */
3975 /* Weakrefs are not safe to be read, since they can be NULL.
3976 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
3977 have DECL_WEAK flag set. */
3979 /* Loading a static variable is unduly expensive, but global
3980 registers aren't expensive. */
3982 }
3984 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3985 to be evaluated unconditionally.
3986 I addition to simple_operand_p, we assume that comparisons, conversions,
3987 and logic-not operations are simple, if their operands are simple, too. */
3989 static bool
3991 {
4011 }
4013 \f
4014 /* The following functions are subroutines to fold_range_test and allow it to
4015 try to change a logical combination of comparisons into a range test.
4017 For example, both
4018 X == 2 || X == 3 || X == 4 || X == 5
4019 and
4020 X >= 2 && X <= 5
4021 are converted to
4022 (unsigned) (X - 2) <= 3
4024 We describe each set of comparisons as being either inside or outside
4025 a range, using a variable named like IN_P, and then describe the
4026 range with a lower and upper bound. If one of the bounds is omitted,
4027 it represents either the highest or lowest value of the type.
4029 In the comments below, we represent a range by two numbers in brackets
4030 preceded by a "+" to designate being inside that range, or a "-" to
4031 designate being outside that range, so the condition can be inverted by
4032 flipping the prefix. An omitted bound is represented by a "-". For
4033 example, "- [-, 10]" means being outside the range starting at the lowest
4034 possible value and ending at 10, in other words, being greater than 10.
4035 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4036 always false.
4038 We set up things so that the missing bounds are handled in a consistent
4039 manner so neither a missing bound nor "true" and "false" need to be
4040 handled using a special case. */
4042 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4043 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4044 and UPPER1_P are nonzero if the respective argument is an upper bound
4045 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4046 must be specified for a comparison. ARG1 will be converted to ARG0's
4047 type if both are specified. */
4049 static tree
4052 {
4053 tree tem;
4057 /* If neither arg represents infinity, do the normal operation.
4058 Else, if not a comparison, return infinity. Else handle the special
4059 comparison rules. Note that most of the cases below won't occur, but
4060 are handled for consistency. */
4063 {
4068 }
4073 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4074 for neither. In real maths, we cannot assume open ended ranges are
4075 the same. But, this is computer arithmetic, where numbers are finite.
4076 We can therefore make the transformation of any unbounded range with
4077 the value Z, Z being greater than any representable number. This permits
4078 us to treat unbounded ranges as equal. */
4082 {
4103 }
4106 }
4107 \f
4108 /* Helper routine for make_range. Perform one step for it, return
4109 new expression if the loop should continue or NULL_TREE if it should
4110 stop. */
4112 tree
4116 {
4122 {
4124 /* We can only do something if the range is testing for zero. */
4133 /* We can only do something if the range is testing for zero
4134 and if the second operand is an integer constant. Note that
4135 saying something is "in" the range we make is done by
4136 complementing IN_P since it will set in the initial case of
4137 being not equal to zero; "out" is leaving it alone. */
4144 {
4165 }
4167 /* If this is an unsigned comparison, we also know that EXP is
4168 greater than or equal to zero. We base the range tests we make
4169 on that fact, so we record it here so we can parse existing
4170 range tests. We test arg0_type since often the return type
4171 of, e.g. EQ_EXPR, is boolean. */
4173 {
4177 NULL_TREE))
4182 /* If the high bound is missing, but we have a nonzero low
4183 bound, reverse the range so it goes from zero to the low bound
4184 minus 1. */
4186 {
4191 }
4192 }
4200 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4201 low and high are non-NULL, then normalize will DTRT. */
4204 {
4209 }
4211 /* (-x) IN [a,b] -> x in [-b, -a] */
4223 /* ~ X -> -X - 1 */
4232 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4233 move a constant to the other side. */
4238 /* If EXP is signed, any overflow in the computation is undefined,
4239 so we don't worry about it so long as our computations on
4240 the bounds don't overflow. For unsigned, overflow is defined
4241 and this is exactly the right thing. */
4253 normalize:
4254 /* Check for an unsigned range which has wrapped around the maximum
4255 value thus making n_high < n_low, and normalize it. */
4257 {
4263 /* If the range is of the form +/- [ x+1, x ], we won't
4264 be able to normalize it. But then, it represents the
4265 whole range or the empty set, so make it
4266 +/- [ -, - ]. */
4270 else
4272 }
4273 else
4281 CASE_CONVERT:
4299 /* If we're converting arg0 from an unsigned type, to exp,
4300 a signed type, we will be doing the comparison as unsigned.
4301 The tests above have already verified that LOW and HIGH
4302 are both positive.
4304 So we have to ensure that we will handle large unsigned
4305 values the same way that the current signed bounds treat
4306 negative values. */
4309 {
4310 tree high_positive;
4311 tree equiv_type;
4312 /* For fixed-point modes, we need to pass the saturating flag
4313 as the 2nd parameter. */
4315 equiv_type
4318 else
4319 equiv_type
4322 /* A range without an upper bound is, naturally, unbounded.
4323 Since convert would have cropped a very large value, use
4324 the max value for the destination type. */
4325 high_positive
4332 high_positive),
4335 /* If the low bound is specified, "and" the range with the
4336 range for which the original unsigned value will be
4337 positive. */
4339 {
4342 integer_zero_node),
4343 high_positive))
4347 }
4348 else
4349 {
4350 /* Otherwise, "or" the range with the range of the input
4351 that will be interpreted as negative. */
4354 integer_zero_node),
4355 high_positive))
4359 }
4360 }
4369 }
4370 }
4372 /* Given EXP, a logical expression, set the range it is testing into
4373 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4374 actually being tested. *PLOW and *PHIGH will be made of the same
4375 type as the returned expression. If EXP is not a comparison, we
4376 will most likely not be returning a useful value and range. Set
4377 *STRICT_OVERFLOW_P to true if the return value is only valid
4378 because signed overflow is undefined; otherwise, do not change
4379 *STRICT_OVERFLOW_P. */
4381 tree
4384 {
4392 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4393 and see if we can refine the range. Some of the cases below may not
4394 happen, but it doesn't seem worth worrying about this. We "continue"
4395 the outer loop when we've changed something; otherwise we "break"
4396 the switch, which will "break" the while. */
4402 {
4408 {
4416 }
4425 }
4427 /* If EXP is a constant, we can evaluate whether this is true or false. */
4429 {
4436 }
4440 }
4441 \f
4442 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4443 type, TYPE, return an expression to test if EXP is in (or out of, depending
4444 on IN_P) the range. Return 0 if the test couldn't be created. */
4446 tree
4449 {
4452 /* Disable this optimization for function pointer expressions
4453 on targets that require function pointer canonicalization. */
4460 {
4466 }
4484 {
4486 {
4490 }
4492 }
4494 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4496 {
4500 {
4502 {
4505 etype
4507 else
4510 }
4513 }
4514 }
4516 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4517 This requires wrap-around arithmetics for the type of the expression.
4518 First make sure that arithmetics in this type is valid, then make sure
4519 that it wraps around. */
4525 {
4528 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4529 for the type in question, as we rely on this here. */
4539 else
4541 }
4551 {
4553 {
4558 }
4560 }
4568 }
4569 \f
4570 /* Return the predecessor of VAL in its type, handling the infinite case. */
4572 static tree
4574 {
4580 else
4583 }
4585 /* Return the successor of VAL in its type, handling the infinite case. */
4587 static tree
4589 {
4595 else
4598 }
4600 /* Given two ranges, see if we can merge them into one. Return 1 if we
4601 can, 0 if we can't. Set the output range into the specified parameters. */
4603 bool
4606 {
4610 tree tem;
4620 /* Make range 0 be the range that starts first, or ends last if they
4621 start at the same value. Swap them if it isn't. */
4624 || (lowequal
4627 {
4631 }
4633 /* Now flag two cases, whether the ranges are disjoint or whether the
4634 second range is totally subsumed in the first. Note that the tests
4635 below are simplified by the ones above. */
4641 /* We now have four cases, depending on whether we are including or
4642 excluding the two ranges. */
4644 {
4645 /* If they don't overlap, the result is false. If the second range
4646 is a subset it is the result. Otherwise, the range is from the start
4647 of the second to the end of the first. */
4652 else
4654 }
4657 {
4658 /* If they don't overlap, the result is the first range. If they are
4659 equal, the result is false. If the second range is a subset of the
4660 first, and the ranges begin at the same place, we go from just after
4661 the end of the second range to the end of the first. If the second
4662 range is not a subset of the first, or if it is a subset and both
4663 ranges end at the same place, the range starts at the start of the
4664 first range and ends just before the second range.
4665 Otherwise, we can't describe this as a single range. */
4671 {
4676 {
4677 /* We are in the weird situation where high0 > high1 but
4678 high1 has no successor. Punt. */
4680 }
4681 }
4683 {
4688 {
4689 /* low0 < low1 but low1 has no predecessor. Punt. */
4691 }
4692 }
4693 else
4695 }
4698 {
4699 /* If they don't overlap, the result is the second range. If the second
4700 is a subset of the first, the result is false. Otherwise,
4701 the range starts just after the first range and ends at the
4702 end of the second. */
4707 else
4708 {
4713 {
4714 /* high1 > high0 but high0 has no successor. Punt. */
4716 }
4717 }
4718 }
4720 else
4721 {
4722 /* The case where we are excluding both ranges. Here the complex case
4723 is if they don't overlap. In that case, the only time we have a
4724 range is if they are adjacent. If the second is a subset of the
4725 first, the result is the first. Otherwise, the range to exclude
4726 starts at the beginning of the first range and ends at the end of the
4727 second. */
4729 {
4734 else
4735 {
4736 /* Canonicalize - [min, x] into - [-, x]. */
4739 {
4744 /* FALLTHROUGH */
4757 }
4759 /* Canonicalize - [x, max] into - [x, -]. */
4762 {
4767 /* FALLTHROUGH */
4783 }
4785 /* The ranges might be also adjacent between the maximum and
4786 minimum values of the given type. For
4787 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4788 return + [x + 1, y - 1]. */
4790 {
4797 }
4798 else
4800 }
4801 }
4804 else
4806 }
4810 }
4811 \f
4813 /* Subroutine of fold, looking inside expressions of the form
4814 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4815 of the COND_EXPR. This function is being used also to optimize
4816 A op B ? C : A, by reversing the comparison first.
4818 Return a folded expression whose code is not a COND_EXPR
4819 anymore, or NULL_TREE if no folding opportunity is found. */
4821 static tree
4824 {
4829 tree tem;
4834 /* If we have A op 0 ? A : -A, consider applying the following
4835 transformations:
4837 A == 0? A : -A same as -A
4838 A != 0? A : -A same as A
4839 A >= 0? A : -A same as abs (A)
4840 A > 0? A : -A same as abs (A)
4841 A <= 0? A : -A same as -abs (A)
4842 A < 0? A : -A same as -abs (A)
4844 None of these transformations work for modes with signed
4845 zeros. If A is +/-0, the first two transformations will
4846 change the sign of the result (from +0 to -0, or vice
4847 versa). The last four will fix the sign of the result,
4848 even though the original expressions could be positive or
4849 negative, depending on the sign of A.
4851 Note that all these transformations are correct if A is
4852 NaN, since the two alternatives (A and -A) are also NaNs. */
4859 /* In the case that A is of the form X-Y, '-A' (arg2) may
4860 have already been folded to Y-X, check for that. */
4868 {
4882 /* Fall through. */
4904 }
4906 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4907 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4908 both transformations are correct when A is NaN: A != 0
4909 is then true, and A == 0 is false. */
4913 {
4918 }
4920 /* Try some transformations of A op B ? A : B.
4922 A == B? A : B same as B
4923 A != B? A : B same as A
4924 A >= B? A : B same as max (A, B)
4925 A > B? A : B same as max (B, A)
4926 A <= B? A : B same as min (A, B)
4927 A < B? A : B same as min (B, A)
4929 As above, these transformations don't work in the presence
4930 of signed zeros. For example, if A and B are zeros of
4931 opposite sign, the first two transformations will change
4932 the sign of the result. In the last four, the original
4933 expressions give different results for (A=+0, B=-0) and
4934 (A=-0, B=+0), but the transformed expressions do not.
4936 The first two transformations are correct if either A or B
4937 is a NaN. In the first transformation, the condition will
4938 be false, and B will indeed be chosen. In the case of the
4939 second transformation, the condition A != B will be true,
4940 and A will be chosen.
4942 The conversions to max() and min() are not correct if B is
4943 a number and A is not. The conditions in the original
4944 expressions will be false, so all four give B. The min()
4945 and max() versions would give a NaN instead. */
4948 /* Avoid these transformations if the COND_EXPR may be used
4949 as an lvalue in the C++ front-end. PR c++/19199. */
4950 && (in_gimple_form
4956 {
4961 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
4963 {
4967 }
4970 {
4979 /* In C++ a ?: expression can be an lvalue, so put the
4980 operand which will be used if they are equal first
4981 so that we can convert this back to the
4982 corresponding COND_EXPR. */
4984 {
4993 }
5000 {
5009 }
5024 }
5025 }
5027 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5028 we might still be able to simplify this. For example,
5029 if C1 is one less or one more than C2, this might have started
5030 out as a MIN or MAX and been transformed by this function.
5031 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5037 {
5041 /* We can replace A with C1 in this case. */
5046 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5047 MIN_EXPR, to preserve the signedness of the comparison. */
5049 OEP_ONLY_CONST)
5053 OEP_ONLY_CONST))
5054 {
5057 arg2));
5060 }
5064 /* If C1 is C2 - 1, this is min(A, C2), with the same care
5065 as above. */
5067 OEP_ONLY_CONST)
5071 OEP_ONLY_CONST))
5072 {
5075 arg2));
5078 }
5082 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5083 MAX_EXPR, to preserve the signedness of the comparison. */
5085 OEP_ONLY_CONST)
5089 OEP_ONLY_CONST))
5090 {
5093 arg2));
5095 }
5099 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5101 OEP_ONLY_CONST)
5105 OEP_ONLY_CONST))
5106 {
5109 arg2));
5111 }
5117 }
5120 }
5123 \f
5124 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5125 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5126 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5127 false) >= 2)
5128 #endif
5130 /* EXP is some logical combination of boolean tests. See if we can
5131 merge it into some range test. Return the new tree if so. */
5133 static tree
5136 {
5152 /* If this is an OR operation, invert both sides; we will invert
5153 again at the end. */
5157 /* If both expressions are the same, if we can merge the ranges, and we
5158 can build the range test, return it or it inverted. If one of the
5159 ranges is always true or always false, consider it to be the same
5160 expression as the other. */
5168 {
5172 }
5174 /* On machines where the branch cost is expensive, if this is a
5175 short-circuited branch and the underlying object on both sides
5176 is the same, make a non-short-circuit operation. */
5182 {
5183 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5184 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5185 which cases we can't do this. */
5193 {
5202 {
5205 WARN_STRICT_OVERFLOW_COMPARISON);
5209 }
5210 }
5211 }
5214 }
5215 \f
5216 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5217 bit value. Arrange things so the extra bits will be set to zero if and
5218 only if C is signed-extended to its full width. If MASK is nonzero,
5219 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5221 static tree
5223 {
5226 tree temp;
5231 /* We work by getting just the sign bit into the low-order bit, then
5232 into the high-order bit, then sign-extend. We then XOR that value
5233 with C. */
5236 /* We must use a signed type in order to get an arithmetic right shift.
5237 However, we must also avoid introducing accidental overflows, so that
5238 a subsequent call to integer_zerop will work. Hence we must
5239 do the type conversion here. At this point, the constant is either
5240 zero or one, and the conversion to a signed type can never overflow.
5241 We could get an overflow if this conversion is done anywhere else. */
5250 /* If necessary, convert the type back to match the type of C. */
5255 }
5256 \f
5257 /* For an expression that has the form
5258 (A && B) || ~B
5259 or
5260 (A || B) && ~B,
5261 we can drop one of the inner expressions and simplify to
5262 A || ~B
5263 or
5264 A && ~B
5265 LOC is the location of the resulting expression. OP is the inner
5266 logical operation; the left-hand side in the examples above, while CMPOP
5267 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5268 removing a condition that guards another, as in
5269 (A != NULL && A->...) || A == NULL
5270 which we must not transform. If RHS_ONLY is true, only eliminate the
5271 right-most operand of the inner logical operation. */
5273 static tree
5276 {
5294 {
5297 {
5300 }
5301 }
5303 {
5306 {
5309 }
5310 }
5325 }
5327 /* Find ways of folding logical expressions of LHS and RHS:
5328 Try to merge two comparisons to the same innermost item.
5329 Look for range tests like "ch >= '0' && ch <= '9'".
5330 Look for combinations of simple terms on machines with expensive branches
5331 and evaluate the RHS unconditionally.
5333 For example, if we have p->a == 2 && p->b == 4 and we can make an
5334 object large enough to span both A and B, we can do this with a comparison
5335 against the object ANDed with the a mask.
5337 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5338 operations to do this with one comparison.
5340 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5341 function and the one above.
5343 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5344 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5346 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5347 two operands.
5349 We return the simplified tree or 0 if no optimization is possible. */
5351 static tree
5354 {
5355 /* If this is the "or" of two comparisons, we can do something if
5356 the comparisons are NE_EXPR. If this is the "and", we can do something
5357 if the comparisons are EQ_EXPR. I.e.,
5358 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5360 WANTED_CODE is this operation code. For single bit fields, we can
5361 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5362 comparison for one-bit fields. */
5382 /* Start by getting the comparison codes. Fail if anything is volatile.
5383 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5384 it were surrounded with a NE_EXPR. */
5393 {
5397 }
5400 {
5404 }
5415 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5418 {
5421 {
5426 }
5429 {
5435 }
5436 }
5441 /* If the RHS can be evaluated unconditionally and its operands are
5442 simple, it wins to evaluate the RHS unconditionally on machines
5443 with expensive branches. In this case, this isn't a comparison
5444 that can be merged. */
5451 {
5452 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5463 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5473 }
5475 /* See if the comparisons can be merged. Then get all the parameters for
5476 each side. */
5500 /* It must be true that the inner operation on the lhs of each
5501 comparison must be the same if we are to be able to do anything.
5502 Then see if we have constants. If not, the same must be true for
5503 the rhs's. */
5514 else
5517 /* If either comparison code is not correct for our logical operation,
5518 fail. However, we can convert a one-bit comparison against zero into
5519 the opposite comparison against that bit being set in the field. */
5523 {
5525 {
5526 /* Make the left operand unsigned, since we are only interested
5527 in the value of one bit. Otherwise we are doing the wrong
5528 thing below. */
5531 }
5532 else
5534 }
5536 /* This is analogous to the code for l_const above. */
5538 {
5540 {
5543 }
5544 else
5546 }
5548 /* See if we can find a mode that contains both fields being compared on
5549 the left. If we can't, fail. Otherwise, update all constants and masks
5550 to be relative to a field of that size. */
5555 volatilep);
5565 {
5568 }
5576 {
5583 {
5587 }
5588 }
5590 {
5597 {
5601 }
5602 }
5604 /* If the right sides are not constant, do the same for it. Also,
5605 disallow this optimization if a size or signedness mismatch occurs
5606 between the left and right sides. */
5608 {
5611 /* Make sure the two fields on the right
5612 correspond to the left without being swapped. */
5620 volatilep);
5630 {
5633 }
5642 /* Make a mask that corresponds to both fields being compared.
5643 Do this for both items being compared. If the operands are the
5644 same size and the bits being compared are in the same position
5645 then we can do this by masking both and comparing the masked
5646 results. */
5650 {
5662 }
5664 /* There is still another way we can do something: If both pairs of
5665 fields being compared are adjacent, we may be able to make a wider
5666 field containing them both.
5668 Note that we still must mask the lhs/rhs expressions. Furthermore,
5669 the mask must be shifted to account for the shift done by
5670 make_bit_field_ref. */
5675 {
5676 tree type;
5690 /* Convert to the smaller type before masking out unwanted bits. */
5693 {
5695 {
5699 }
5701 {
5705 }
5706 }
5715 }
5718 }
5720 /* Handle the case of comparisons with constants. If there is something in
5721 common between the masks, those bits of the constants must be the same.
5722 If not, the condition is always false. Test for this to avoid generating
5723 incorrect code below. */
5728 {
5730 {
5733 }
5734 else
5735 {
5738 }
5739 }
5741 /* Construct the expression we will return. First get the component
5742 reference we will make. Unless the mask is all ones the width of
5743 that field, perform the mask operation. Then compare with the
5744 merged constant. */
5754 }
5755 \f
5756 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5757 constant. */
5759 static tree
5762 {
5765 tree comp_const;
5766 tree minmax_const;
5768 tree inner;
5779 /* If something does not permit us to optimize, return the original tree. */
5787 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5788 and GT_EXPR, doing the rest with recursive calls using logical
5789 simplifications. */
5791 {
5793 {
5794 tree tem
5801 }
5804 return
5806 optimize_minmax_comparison
5808 optimize_minmax_comparison
5813 /* MAX (X, 0) == 0 -> X <= 0 */
5817 /* MAX (X, 0) == 5 -> X == 5 */
5821 /* MAX (X, 0) == -1 -> false */
5825 /* MIN (X, 0) == 0 -> X >= 0 */
5829 /* MIN (X, 0) == 5 -> false */
5832 else
5833 /* MIN (X, 0) == -1 -> X == -1 */
5838 /* MAX (X, 0) > 0 -> X > 0
5839 MAX (X, 0) > 5 -> X > 5 */
5843 /* MAX (X, 0) > -1 -> true */
5847 /* MIN (X, 0) > 0 -> false
5848 MIN (X, 0) > 5 -> false */
5851 else
5852 /* MIN (X, 0) > -1 -> X > -1 */
5857 }
5858 }
5859 \f
5860 /* T is an integer expression that is being multiplied, divided, or taken a
5861 modulus (CODE says which and what kind of divide or modulus) by a
5862 constant C. See if we can eliminate that operation by folding it with
5863 other operations already in T. WIDE_TYPE, if non-null, is a type that
5864 should be used for the computation if wider than our type.
5866 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5867 (X * 2) + (Y * 4). We must, however, be assured that either the original
5868 expression would not overflow or that overflow is undefined for the type
5869 in the language in question.
5871 If we return a non-null expression, it is an equivalent form of the
5872 original computation, but need not be in the original type.
5874 We set *STRICT_OVERFLOW_P to true if the return values depends on
5875 signed overflow being undefined. Otherwise we do not change
5876 *STRICT_OVERFLOW_P. */
5878 static tree
5881 {
5882 /* To avoid exponential search depth, refuse to allow recursion past
5883 three levels. Beyond that (1) it's highly unlikely that we'll find
5884 something interesting and (2) we've probably processed it before
5885 when we built the inner expression. */
5888 tree ret;
5893 depth++;
5895 depth--;
5898 }
5900 static tree
5903 {
5914 /* Don't deal with constants of zero here; they confuse the code below. */
5924 /* Note that we need not handle conditional operations here since fold
5925 already handles those cases. So just do arithmetic here. */
5927 {
5929 /* For a constant, we can always simplify if we are a multiply
5930 or (for divide and modulus) if it is a multiple of our constant. */
5938 /* If op0 is an expression ... */
5944 /* ... and has wrapping overflow, and its type is smaller
5945 than ctype, then we cannot pass through as widening. */
5950 /* ... or this is a truncation (t is narrower than op0),
5951 then we cannot pass through this narrowing. */
5954 /* ... or signedness changes for division or modulus,
5955 then we cannot pass through this conversion. */
5959 /* ... or has undefined overflow while the converted to
5960 type has not, we cannot do the operation in the inner type
5961 as that would introduce undefined overflow. */
5967 /* Pass the constant down and see if we can make a simplification. If
5968 we can, replace this expression with the inner simplification for
5969 possible later conversion to our or some other type. */
5974 code == MULT_EXPR
5976 strict_overflow_p))))
5981 /* If widening the type changes it from signed to unsigned, then we
5982 must avoid building ABS_EXPR itself as unsigned. */
5984 {
5988 {
5991 }
5993 }
5994 /* If the constant is negative, we cannot simplify this. */
5997 /* FALLTHROUGH */
5999 /* For division and modulus, type can't be unsigned, as e.g.
6000 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6001 For signed types, even with wrapping overflow, this is fine. */
6010 /* If widening the type changes the signedness, then we can't perform
6011 this optimization as that changes the result. */
6015 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6021 {
6028 }
6032 /* If the second operand is constant, this is a multiplication
6033 or floor division, by a power of two, so we can treat it that
6034 way unless the multiplier or divisor overflows. Signed
6035 left-shift overflow is implementation-defined rather than
6036 undefined in C90, so do not convert signed left shift into
6037 multiplication. */
6040 /* const_binop may not detect overflow correctly,
6041 so check for it explicitly here. */
6045 size_one_node,
6046 op1)))
6050 ctype,
6052 t1),
6057 /* See if we can eliminate the operation on both sides. If we can, we
6058 can return a new PLUS or MINUS. If we can't, the only remaining
6059 cases where we can do anything are if the second operand is a
6060 constant. */
6066 /* If not multiplication, we can only do this if both operands
6067 are divisible by c. */
6070 {
6075 }
6077 /* If this was a subtraction, negate OP1 and set it to be an addition.
6078 This simplifies the logic below. */
6080 {
6082 /* If OP1 was not easily negatable, the constant may be OP0. */
6084 {
6087 }
6088 }
6093 /* If either OP1 or C are negative, this optimization is not safe for
6094 some of the division and remainder types while for others we need
6095 to change the code. */
6097 {
6105 }
6107 /* If it's a multiply or a division/modulus operation of a multiple
6108 of our constant, do the operation and verify it doesn't overflow. */
6111 {
6114 /* We allow the constant to overflow with wrapping semantics. */
6118 }
6119 else
6122 /* If we have an unsigned type, we cannot widen the operation since it
6123 will change the result if the original computation overflowed. */
6127 /* If we were able to eliminate our operation from the first side,
6128 apply our operation to the second side and reform the PLUS. */
6132 /* The last case is if we are a multiply. In that case, we can
6133 apply the distributive law to commute the multiply and addition
6134 if the multiplication of the constants doesn't overflow
6135 and overflow is defined. With undefined overflow
6136 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6142 op1);
6147 /* We have a special case here if we are doing something like
6148 (C * 8) % 4 since we know that's zero. */
6151 /* If the multiplication can overflow we cannot optimize this. */
6155 {
6158 }
6160 /* ... fall through ... */
6164 /* If we can extract our operation from the LHS, do so and return a
6165 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6166 do something only if the second operand is a constant. */
6180 /* If these are the same operation types, we can associate them
6181 assuming no overflow. */
6183 {
6193 {
6198 }
6199 }
6201 /* If these operations "cancel" each other, we have the main
6202 optimizations of this pass, which occur when either constant is a
6203 multiple of the other, in which case we replace this with either an
6204 operation or CODE or TCODE.
6206 If we have an unsigned type, we cannot do this since it will change
6207 the result if the original computation overflowed. */
6214 {
6216 {
6223 }
6225 {
6232 }
6233 }
6238 }
6241 }
6242 \f
6243 /* Return a node which has the indicated constant VALUE (either 0 or
6244 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6245 and is of the indicated TYPE. */
6247 tree
6249 {
6258 else
6260 }
6263 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6264 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6265 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6266 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6267 COND is the first argument to CODE; otherwise (as in the example
6268 given here), it is the second argument. TYPE is the type of the
6269 original expression. Return NULL_TREE if no simplification is
6270 possible. */
6272 static tree
6277 {
6287 {
6291 /* If this operand throws an expression, then it does not make
6292 sense to try to perform a logical or arithmetic operation
6293 involving it. */
6298 }
6299 else
6300 {
6305 }
6310 /* This transformation is only worthwhile if we don't have to wrap ARG
6311 in a SAVE_EXPR and the operation can be simplified without recursing
6312 on at least one of the branches once its pushed inside the COND_EXPR. */
6321 {
6325 else
6327 }
6329 {
6333 else
6335 }
6337 /* Check that we have simplified at least one of the branches. */
6342 }
6344 \f
6345 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6347 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6348 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6349 ADDEND is the same as X.
6351 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6352 and finite. The problematic cases are when X is zero, and its mode
6353 has signed zeros. In the case of rounding towards -infinity,
6354 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6355 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6357 bool
6359 {
6363 /* Don't allow the fold with -fsignaling-nans. */
6367 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6371 /* In a vector or complex, we would need to check the sign of all zeros. */
6375 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6379 /* The mode has signed zeros, and we have to honor their sign.
6380 In this situation, there is only one case we can return true for.
6381 X - 0 is the same as X unless rounding towards -infinity is
6382 supported. */
6384 }
6386 /* Subroutine of fold() that optimizes comparisons of a division by
6387 a nonzero integer constant against an integer constant, i.e.
6388 X/C1 op C2.
6390 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6391 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6392 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6394 The function returns the constant folded tree if a simplification
6395 can be made, and NULL_TREE otherwise. */
6397 static tree
6400 {
6408 /* We have to do this the hard way to detect unsigned overflow.
6409 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6415 {
6420 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6424 }
6426 {
6430 {
6449 }
6450 }
6451 else
6452 {
6453 /* A negative divisor reverses the relational operators. */
6459 {
6478 }
6479 }
6482 {
6503 {
6506 }
6511 {
6514 }
6519 {
6522 }
6527 {
6530 }
6535 }
6538 }
6541 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6542 equality/inequality test, then return a simplified form of the test
6543 using a sign testing. Otherwise return NULL. TYPE is the desired
6544 result type. */
6546 static tree
6549 tree result_type)
6550 {
6551 /* If this is testing a single bit, we can optimize the test. */
6555 {
6556 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6557 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6561 /* This is only a win if casting to a signed type is cheap,
6562 i.e. when arg00's type is not a partial mode. */
6565 {
6568 result_type,
6571 }
6572 }
6575 }
6577 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6578 equality/inequality test, then return a simplified form of
6579 the test using shifts and logical operations. Otherwise return
6580 NULL. TYPE is the desired result type. */
6582 tree
6585 {
6586 /* If this is testing a single bit, we can optimize the test. */
6590 {
6599 /* First, see if we can fold the single bit test into a sign-bit
6600 test. */
6602 result_type);
6606 /* Otherwise we have (A & C) != 0 where C is a single bit,
6607 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6608 Similarly for (A & C) == 0. */
6610 /* If INNER is a right shift of a constant and it plus BITNUM does
6611 not overflow, adjust BITNUM and INNER. */
6617 {
6620 }
6622 /* If we are going to be able to omit the AND below, we must do our
6623 operations as unsigned. If we must use the AND, we have a choice.
6624 Normally unsigned is faster, but for some machines signed is. */
6642 /* Put the AND last so it can combine with more things. */
6645 /* Make sure to return the proper type. */
6649 }
6651 }
6653 /* Check whether we are allowed to reorder operands arg0 and arg1,
6654 such that the evaluation of arg1 occurs before arg0. */
6656 static bool
6658 {
6665 }
6667 /* Test whether it is preferable two swap two operands, ARG0 and
6668 ARG1, for example because ARG0 is an integer constant and ARG1
6669 isn't. If REORDER is true, only recommend swapping if we can
6670 evaluate the operands in reverse order. */
6672 bool
6674 {
6692 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6693 for commutative and comparison operators. Ensuring a canonical
6694 form allows the optimizers to find additional redundancies without
6695 having to explicitly check for both orderings. */
6701 /* Put SSA_NAMEs last. */
6707 /* Put variables last. */
6714 }
6717 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6718 means A >= Y && A != MAX, but in this case we know that
6719 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6721 static tree
6723 {
6730 else
6739 {
6742 }
6744 {
6747 }
6748 else
6755 {
6756 /* Convert the pointer types into integer before taking the difference. */
6760 }
6761 else
6768 }
6770 /* Fold a sum or difference of at least one multiplication.
6771 Returns the folded tree or NULL if no simplification could be made. */
6773 static tree
6776 {
6780 /* (A * C) +- (B * C) -> (A+-B) * C.
6781 (A * C) +- A -> A * (C+-1).
6782 We are most concerned about the case where C is a constant,
6783 but other combinations show up during loop reduction. Since
6784 it is not difficult, try all four possibilities. */
6787 {
6790 }
6792 {
6795 }
6796 else
6797 {
6798 /* We cannot generate constant 1 for fract. */
6803 }
6805 {
6808 }
6810 {
6812 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6813 the purpose of this canonicalization. */
6817 {
6820 }
6821 else
6823 }
6824 else
6825 {
6826 /* We cannot generate constant 1 for fract. */
6831 }
6843 /* No identical multiplicands; see if we can find a common
6844 power-of-two factor in non-power-of-two multiplies. This
6845 can help in multi-dimensional array access. */
6848 {
6851 tree maybe_same;
6855 /* Move min of absolute values to int11. */
6857 {
6862 }
6863 else
6867 /* The remainder should not be a constant, otherwise we
6868 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6869 increased the number of multiplications necessary. */
6871 {
6879 }
6880 }
6890 }
6892 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
6893 specified by EXPR into the buffer PTR of length LEN bytes.
6894 Return the number of bytes placed in the buffer, or zero
6895 upon failure. */
6897 static int
6899 {
6913 {
6915 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
6916 number of bytes. */
6920 {
6927 else
6929 }
6930 else
6935 }
6937 }
6940 /* Subroutine of native_encode_expr. Encode the FIXED_CST
6941 specified by EXPR into the buffer PTR of length LEN bytes.
6942 Return the number of bytes placed in the buffer, or zero
6943 upon failure. */
6945 static int
6947 {
6951 FIXED_VALUE_TYPE value;
6967 }
6970 /* Subroutine of native_encode_expr. Encode the REAL_CST
6971 specified by EXPR into the buffer PTR of length LEN bytes.
6972 Return the number of bytes placed in the buffer, or zero
6973 upon failure. */
6975 static int
6977 {
6983 /* There are always 32 bits in each long, no matter the size of
6984 the hosts long. We handle floating point representations with
6985 up to 192 bits. */
6999 {
7004 {
7011 else
7013 }
7014 else
7020 }
7022 }
7024 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7025 specified by EXPR into the buffer PTR of length LEN bytes.
7026 Return the number of bytes placed in the buffer, or zero
7027 upon failure. */
7029 static int
7031 {
7033 tree part;
7048 }
7051 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7052 specified by EXPR into the buffer PTR of length LEN bytes.
7053 Return the number of bytes placed in the buffer, or zero
7054 upon failure. */
7056 static int
7058 {
7068 {
7070 {
7073 }
7084 }
7086 }
7089 /* Subroutine of native_encode_expr. Encode the STRING_CST
7090 specified by EXPR into the buffer PTR of length LEN bytes.
7091 Return the number of bytes placed in the buffer, or zero
7092 upon failure. */
7094 static int
7096 {
7098 HOST_WIDE_INT total_bytes;
7112 {
7115 {
7118 }
7121 }
7122 else
7125 }
7128 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7129 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7130 buffer PTR of length LEN bytes. If OFF is not -1 then start
7131 the encoding at byte offset OFF and encode at most LEN bytes.
7132 Return the number of bytes placed in the buffer, or zero upon failure. */
7134 int
7136 {
7137 /* We don't support starting at negative offset and -1 is special. */
7142 {
7163 }
7164 }
7167 /* Subroutine of native_interpret_expr. Interpret the contents of
7168 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7169 If the buffer cannot be interpreted, return NULL_TREE. */
7171 static tree
7173 {
7183 }
7186 /* Subroutine of native_interpret_expr. Interpret the contents of
7187 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7188 If the buffer cannot be interpreted, return NULL_TREE. */
7190 static tree
7192 {
7194 double_int result;
7195 FIXED_VALUE_TYPE fixed_value;
7205 }
7208 /* Subroutine of native_interpret_expr. Interpret the contents of
7209 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7210 If the buffer cannot be interpreted, return NULL_TREE. */
7212 static tree
7214 {
7218 /* There are always 32 bits in each long, no matter the size of
7219 the hosts long. We handle floating point representations with
7220 up to 192 bits. */
7221 REAL_VALUE_TYPE r;
7232 {
7233 /* Both OFFSET and BYTE index within a long;
7234 bitpos indexes the whole float. */
7237 {
7244 else
7246 }
7247 else
7248 {
7251 {
7252 /* Reverse bytes within each long, or within the entire float
7253 if it's smaller than a long (for HFmode). */
7256 }
7257 }
7261 }
7265 }
7268 /* Subroutine of native_interpret_expr. Interpret the contents of
7269 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7270 If the buffer cannot be interpreted, return NULL_TREE. */
7272 static tree
7274 {
7289 }
7292 /* Subroutine of native_interpret_expr. Interpret the contents of
7293 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7294 If the buffer cannot be interpreted, return NULL_TREE. */
7296 static tree
7298 {
7311 {
7316 }
7318 }
7321 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7322 the buffer PTR of length LEN as a constant of type TYPE. For
7323 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7324 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7325 return NULL_TREE. */
7327 tree
7329 {
7331 {
7353 }
7354 }
7356 /* Returns true if we can interpret the contents of a native encoding
7357 as TYPE. */
7359 static bool
7361 {
7363 {
7376 }
7377 }
7379 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7380 TYPE at compile-time. If we're unable to perform the conversion
7381 return NULL_TREE. */
7383 static tree
7385 {
7386 /* We support up to 512-bit values (for V8DFmode). */
7390 /* Check that the host and target are sane. */
7399 }
7401 /* Build an expression for the address of T. Folds away INDIRECT_REF
7402 to avoid confusing the gimplify process. */
7404 tree
7406 {
7407 /* The size of the object is not relevant when talking about its address. */
7412 {
7417 }
7427 {
7432 }
7433 else
7437 }
7439 /* Build an expression for the address of T. */
7441 tree
7443 {
7447 }
7449 /* Fold a unary expression of code CODE and type TYPE with operand
7450 OP0. Return the folded expression if folding is successful.
7451 Otherwise, return NULL_TREE. */
7453 tree
7455 {
7456 tree tem;
7457 tree arg0;
7465 {
7468 {
7469 /* Don't use STRIP_NOPS, because signedness of argument type
7470 matters. */
7472 }
7473 else
7474 {
7475 /* Strip any conversions that don't change the mode. This
7476 is safe for every expression, except for a comparison
7477 expression because its signedness is derived from its
7478 operands.
7480 Note that this is done as an internal manipulation within
7481 the constant folder, in order to find the simplest
7482 representation of the arguments so that their form can be
7483 studied. In any cases, the appropriate type conversions
7484 should be put back in the tree that will get out of the
7485 constant folder. */
7487 }
7490 {
7493 {
7497 }
7498 }
7499 }
7506 {
7513 {
7527 /* If this was a conversion, and all we did was to move into
7528 inside the COND_EXPR, bring it back out. But leave it if
7529 it is a conversion from integer to integer and the
7530 result precision is no wider than a word since such a
7531 conversion is cheap and may be optimized away by combine,
7532 while it couldn't if it were outside the COND_EXPR. Then return
7533 so we don't get into an infinite recursion loop taking the
7534 conversion out and then back in. */
7546 && (INTEGRAL_TYPE_P
7559 }
7560 }
7563 {
7569 CASE_CONVERT:
7573 {
7574 /* If we have (type) (a CMP b) and type is an integral type, return
7575 new expression involving the new type. Canonicalize
7576 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7577 non-integral type.
7578 Do not fold the result as that would not simplify further, also
7579 folding again results in recursions. */
7589 }
7591 /* Handle (T *)&A.B.C for A being of type T and B and C
7592 living at offset zero. This occurs frequently in
7593 C++ upcasting and then accessing the base. */
7597 {
7599 tree offset;
7600 machine_mode mode;
7605 /* If the reference was to a (constant) zero offset, we can use
7606 the address of the base if it has the same base type
7607 as the result type and the pointer type is unqualified. */
7614 }
7618 /* Detect assigning a bitfield. */
7620 && DECL_BIT_FIELD
7622 {
7623 /* Don't leave an assignment inside a conversion
7624 unless assigning a bitfield. */
7626 /* First do the assignment, then return converted constant. */
7631 }
7633 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7634 constants (if x has signed type, the sign bit cannot be set
7635 in c). This folds extension into the BIT_AND_EXPR.
7636 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7637 very likely don't have maximal range for their precision and this
7638 transformation effectively doesn't preserve non-maximal ranges. */
7642 {
7653 <= HOST_BITS_PER_WIDE_INT
7655 {
7659 cst &= HOST_WIDE_INT_M1U
7663 && !flag_syntax_only
7666 {
7670 }
7671 }
7673 {
7678 }
7679 }
7681 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7682 when one of the new casts will fold away. Conservatively we assume
7683 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7690 {
7694 return fold_build_pointer_plus_loc
7696 }
7698 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7699 of the same precision, and X is an integer type not narrower than
7700 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7706 {
7712 }
7714 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7715 type of X and Y (integer types only). */
7720 {
7721 /* Be careful not to introduce new overflows. */
7722 tree mult_type;
7725 else
7729 {
7736 }
7737 }
7755 /* Convert fabs((double)float) into (double)fabsf(float). */
7758 {
7764 targ0));
7765 }
7767 /* Strip sign ops from argument. */
7769 {
7774 }
7778 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7797 /* Note that the operand of this must be an int
7798 and its values must be 0 or 1.
7799 ("true" is a fixed value perhaps depending on the language,
7800 but we don't handle values other than 1 correctly yet.) */
7807 /* Fold *&X to X if X is an lvalue. */
7809 {
7816 }
7822 }
7825 /* If the operation was a conversion do _not_ mark a resulting constant
7826 with TREE_OVERFLOW if the original constant was not. These conversions
7827 have implementation defined behavior and retaining the TREE_OVERFLOW
7828 flag here would confuse later passes such as VRP. */
7829 tree
7832 {
7841 }
7843 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7844 operands OP0 and OP1. LOC is the location of the resulting expression.
7845 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7846 Return the folded expression if folding is successful. Otherwise,
7847 return NULL_TREE. */
7848 static tree
7851 {
7852 tree tem;
7854 /* We only do these simplifications if we are optimizing. */
7858 /* Check for things like (A || B) && (A || C). We can convert this
7859 to A || (B && C). Note that either operator can be any of the four
7860 truth and/or operations and the transformation will still be
7861 valid. Also note that we only care about order for the
7862 ANDIF and ORIF operators. If B contains side effects, this
7863 might change the truth-value of A. */
7870 {
7890 /* This case if tricky because we must either have commutative
7891 operators or else A10 must not have side-effects. */
7897 a01);
7898 }
7900 /* See if we can build a range comparison. */
7906 {
7910 }
7914 {
7918 }
7920 /* Check for the possibility of merging component references. If our
7921 lhs is another similar operation, try to merge its rhs with our
7922 rhs. Then try to merge our lhs and rhs. */
7936 {
7943 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
7944 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
7945 We don't want to pack more than two leafs to a non-IF AND/OR
7946 expression.
7947 If tree-code of left-hand operand isn't an AND/OR-IF code and not
7948 equal to IF-CODE, then we don't want to add right-hand operand.
7949 If the inner right-hand side of left-hand operand has
7950 side-effects, or isn't simple, then we can't add to it,
7951 as otherwise we might destroy if-sequence. */
7954 /* Needed for sequence points to handle trappings, and
7955 side-effects. */
7957 {
7959 arg1);
7961 tem);
7962 }
7963 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
7964 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
7967 /* Needed for sequence points to handle trappings, and
7968 side-effects. */
7970 {
7975 }
7976 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
7977 into (A OR B).
7978 For sequence point consistancy, we need to check for trapping,
7979 and side-effects. */
7983 }
7986 }
7988 /* Fold a binary expression of code CODE and type TYPE with operands
7989 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
7990 Return the folded expression if folding is successful. Otherwise,
7991 return NULL_TREE. */
7993 static tree
7995 {
8002 else
8005 /* MIN (MAX (a, b), b) == b. */
8010 /* MIN (MAX (b, a), b) == b. */
8016 /* MIN (a, MAX (a, b)) == a. */
8022 /* MIN (a, MAX (b, a)) == a. */
8029 }
8031 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8032 by changing CODE to reduce the magnitude of constants involved in
8033 ARG0 of the comparison.
8034 Returns a canonicalized comparison tree if a simplification was
8035 possible, otherwise returns NULL_TREE.
8036 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8037 valid if signed overflow is undefined. */
8039 static tree
8043 {
8048 /* Match A +- CST code arg1. We can change this only if overflow
8049 is undefined. */
8052 /* In principle pointers also have undefined overflow behavior,
8053 but that causes problems elsewhere. */
8060 /* Identify the constant in arg0 and its sign. */
8064 /* Overflowed constants and zero will cause problems. */
8069 /* See if we can reduce the magnitude of the constant in
8070 arg0 by changing the comparison code. */
8071 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8075 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8079 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8083 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8087 else
8091 /* Now build the constant reduced in magnitude. But not if that
8092 would produce one outside of its types range. */
8108 }
8110 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8111 overflow further. Try to decrease the magnitude of constants involved
8112 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8113 and put sole constants at the second argument position.
8114 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8116 static tree
8119 {
8120 tree t;
8125 /* Try canonicalization by simplifying arg0. */
8130 {
8134 }
8136 /* Try canonicalization by simplifying arg1 using the swapped
8137 comparison. */
8145 }
8147 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8148 space. This is used to avoid issuing overflow warnings for
8149 expressions like &p->x which can not wrap. */
8151 static bool
8153 {
8160 wide_int wi_offset;
8166 else
8182 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8183 array. */
8185 {
8186 HOST_WIDE_INT base_size;
8191 }
8194 }
8196 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8197 kind INTEGER_CST. This makes sure to properly sign-extend the
8198 constant. */
8200 static HOST_WIDE_INT
8202 {
8208 }
8210 /* Subroutine of fold_binary. This routine performs all of the
8211 transformations that are common to the equality/inequality
8212 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8213 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8214 fold_binary should call fold_binary. Fold a comparison with
8215 tree code CODE and type TYPE with operands OP0 and OP1. Return
8216 the folded comparison or NULL_TREE. */
8218 static tree
8221 {
8231 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8233 && (equality_code
8240 {
8241 const enum tree_code
8248 /* If the constant operation overflowed this can be
8249 simplified as a comparison against INT_MAX/INT_MIN. */
8252 {
8256 /* Get the sign of the constant on the lhs if the
8257 operation were VARIABLE + CONST1. */
8261 /* The sign of the constant determines if we overflowed
8262 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8263 Canonicalize to the INT_MIN overflow by swapping the comparison
8264 if necessary. */
8268 /* We now can look at the canonicalized case
8269 VARIABLE + 1 CODE2 INT_MIN
8270 and decide on the result. */
8272 {
8276 return
8282 return
8287 }
8288 }
8289 else
8290 {
8293 "when changing X +- C1 cmp C2 to "
8295 WARN_STRICT_OVERFLOW_COMPARISON);
8297 }
8298 }
8300 /* For comparisons of pointers we can decompose it to a compile time
8301 comparison of the base objects and the offsets into the object.
8302 This requires at least one operand being an ADDR_EXPR or a
8303 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8309 {
8312 machine_mode mode;
8316 /* Get base and offset for the access. Strip ADDR_EXPR for
8317 get_inner_reference, but put it back by stripping INDIRECT_REF
8318 off the base object if possible. indirect_baseN will be true
8319 if baseN is not an address but refers to the object itself. */
8322 {
8328 else
8330 }
8332 {
8336 {
8339 }
8342 {
8347 {
8350 }
8351 }
8352 }
8356 {
8362 else
8364 }
8366 {
8370 {
8373 }
8376 {
8381 {
8384 }
8385 }
8386 }
8388 /* If we have equivalent bases we might be able to simplify. */
8391 {
8392 /* We can fold this expression to a constant if the non-constant
8393 offset parts are equal. */
8402 {
8408 "occur when comparing P +- C1 with "
8410 WARN_STRICT_OVERFLOW_CONDITIONAL);
8413 {
8427 }
8428 }
8429 /* We can simplify the comparison to a comparison of the variable
8430 offset parts if the constant offset parts are equal.
8431 Be careful to use signed sizetype here because otherwise we
8432 mess with array offsets in the wrong way. This is possible
8433 because pointer arithmetic is restricted to retain within an
8434 object and overflow on pointer differences is undefined as of
8435 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8437 && (equality_code
8440 {
8441 /* By converting to signed sizetype we cover middle-end pointer
8442 arithmetic which operates on unsigned pointer types of size
8443 type size and ARRAY_REF offsets which are properly sign or
8444 zero extended from their type in case it is narrower than
8445 sizetype. */
8448 else
8452 else
8459 "occur when comparing P +- C1 with "
8461 WARN_STRICT_OVERFLOW_COMPARISON);
8464 }
8465 }
8466 /* For equal offsets we can simplify to a comparison of the
8467 base addresses. */
8469 && (indirect_base0
8471 && (indirect_base1
8476 {
8482 }
8483 }
8485 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8486 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8487 the resulting offset is smaller in absolute value than the
8488 original one and has the same sign. */
8497 {
8502 tree cst;
8504 "occur when combining constants around "
8507 /* Put the constant on the side where it doesn't overflow and is
8508 of lower absolute value and of same sign than before. */
8515 {
8518 variable1,
8522 }
8530 {
8536 variable2);
8537 }
8538 }
8544 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8545 constant, we can simplify it. */
8550 {
8554 }
8556 /* If we are comparing an expression that just has comparisons
8557 of two integer values, arithmetic expressions of those comparisons,
8558 and constants, we can simplify it. There are only three cases
8559 to check: the two values can either be equal, the first can be
8560 greater, or the second can be greater. Fold the expression for
8561 those three values. Since each value must be 0 or 1, we have
8562 eight possibilities, each of which corresponds to the constant 0
8563 or 1 or one of the six possible comparisons.
8565 This handles common cases like (a > b) == 0 but also handles
8566 expressions like ((x > y) - (y > x)) > 0, which supposedly
8567 occur in macroized code. */
8570 {
8575 /* Don't handle degenerate cases here; they should already
8576 have been handled anyway. */
8585 {
8589 /* We can't just pass T to eval_subst in case cval1 or cval2
8590 was the same as ARG1. */
8592 tree high_result
8596 arg1);
8597 tree equal_result
8601 arg1);
8602 tree low_result
8606 arg1);
8608 /* All three of these results should be 0 or 1. Confirm they are.
8609 Then use those values to select the proper code to use. */
8614 {
8615 /* Make a 3-bit mask with the high-order bit being the
8616 value for `>', the next for '=', and the low for '<'. */
8620 {
8622 /* Always false. */
8643 /* Always true. */
8645 }
8648 {
8652 }
8654 }
8655 }
8656 }
8658 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8659 into a single range test. */
8667 {
8671 }
8674 }
8677 /* Subroutine of fold_binary. Optimize complex multiplications of the
8678 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8679 argument EXPR represents the expression "z" of type TYPE. */
8681 static tree
8683 {
8688 {
8691 }
8693 {
8696 }
8697 else
8698 {
8702 }
8711 }
8714 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8715 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8717 static bool
8719 {
8723 {
8726 }
8728 {
8734 else
8736 }
8737 else
8743 }
8745 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8746 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8747 NULL_TREE otherwise. */
8749 static tree
8751 {
8768 {
8772 }
8775 {
8781 }
8782 else
8784 }
8786 /* Try to fold a pointer difference of type TYPE two address expressions of
8787 array references AREF0 and AREF1 using location LOC. Return a
8788 simplified expression for the difference or NULL_TREE. */
8790 static tree
8793 {
8798 /* If the bases are array references as well, recurse. If the bases
8799 are pointer indirections compute the difference of the pointers.
8800 If the bases are equal, we are set. */
8803 && (base_offset
8811 {
8817 base_offset,
8820 }
8822 }
8824 /* If the real or vector real constant CST of type TYPE has an exact
8825 inverse, return it, else return NULL. */
8827 tree
8829 {
8830 REAL_VALUE_TYPE r;
8832 machine_mode mode;
8836 {
8852 {
8857 }
8863 }
8864 }
8866 /* Mask out the tz least significant bits of X of type TYPE where
8867 tz is the number of trailing zeroes in Y. */
8868 static wide_int
8870 {
8875 }
8877 /* Return true when T is an address and is known to be nonzero.
8878 For floating point we further ensure that T is not denormal.
8879 Similar logic is present in nonzero_address in rtlanal.h.
8881 If the return value is based on the assumption that signed overflow
8882 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8883 change *STRICT_OVERFLOW_P. */
8885 static bool
8887 {
8891 /* Doing something useful for floating point would need more work. */
8897 {
8900 strict_overflow_p);
8906 strict_overflow_p);
8914 }
8917 {
8920 strict_overflow_p);
8928 strict_overflow_p);
8943 strict_overflow_p);
8947 strict_overflow_p);
8950 {
8962 }
8966 }
8968 }
8970 /* Return true when T is an address and is known to be nonzero.
8971 Handle warnings about undefined signed overflow. */
8973 static bool
8975 {
8982 "determining that expression is always "
8984 WARN_STRICT_OVERFLOW_MISC);
8986 }
8988 /* Fold a binary expression of code CODE and type TYPE with operands
8989 OP0 and OP1. LOC is the location of the resulting expression.
8990 Return the folded expression if folding is successful. Otherwise,
8991 return NULL_TREE. */
8993 tree
8996 {
9011 /* Strip any conversions that don't change the mode. This is
9012 safe for every expression, except for a comparison expression
9013 because its signedness is derived from its operands. So, in
9014 the latter case, only strip conversions that don't change the
9015 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9016 preserved.
9018 Note that this is done as an internal manipulation within the
9019 constant folder, in order to find the simplest representation
9020 of the arguments so that their form can be studied. In any
9021 cases, the appropriate type conversions should be put back in
9022 the tree that will get out of the constant folder. */
9025 {
9028 }
9029 else
9030 {
9033 }
9035 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9036 constant but we can't do arithmetic on them. */
9038 {
9041 {
9045 }
9046 }
9048 /* If this is a commutative operation, and ARG0 is a constant, move it
9049 to ARG1 to reduce the number of tests below. */
9054 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9055 to ARG1 to reduce the number of tests below. */
9064 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9066 First check for cases where an arithmetic operation is applied to a
9067 compound, conditional, or comparison operation. Push the arithmetic
9068 operation inside the compound or conditional to see if any folding
9069 can then be done. Convert comparison to conditional for this purpose.
9070 The also optimizes non-constant cases that used to be done in
9071 expand_expr.
9073 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9074 one of the operands is a comparison and the other is a comparison, a
9075 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9076 code below would make the expression more complex. Change it to a
9077 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9078 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9091 {
9095 boolean_type_node,
9103 }
9107 {
9109 {
9114 tem);
9115 }
9118 {
9123 tem);
9124 }
9129 {
9135 }
9140 {
9146 }
9147 }
9150 {
9152 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9155 {
9161 }
9163 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9166 {
9167 tree base;
9168 HOST_WIDE_INT coffset;
9177 }
9182 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9188 arg1),
9190 arg0)));
9196 {
9197 /* X + (X / CST) * -CST is X % CST. */
9202 {
9211 cst0));
9212 }
9213 }
9215 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9216 one. Make sure the type is not saturating and has the signedness of
9217 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9218 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9225 {
9229 }
9232 {
9233 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9234 (plus (plus (mult) (mult)) (foo)) so that we can
9235 take advantage of the factoring cases below. */
9244 {
9250 else
9263 parg0),
9265 marg)),
9269 return
9275 parg1)));
9276 }
9277 }
9278 else
9279 {
9280 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9281 to __complex__ ( x, y ). This is not the same for SNaNs or
9282 if signed zeros are involved. */
9286 {
9293 {
9297 {
9303 }
9305 {
9311 }
9312 }
9313 }
9321 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9322 We associate floats only if the user has specified
9323 -fassociative-math. */
9327 {
9332 {
9333 tree tree0;
9336 }
9337 }
9338 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9339 We associate floats only if the user has specified
9340 -fassociative-math. */
9344 {
9349 {
9350 tree tree0;
9353 }
9354 }
9355 }
9357 bit_rotate:
9358 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9359 is a rotate of A by C1 bits. */
9360 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9361 is a rotate of A by B bits. */
9362 {
9364 tree rtype;
9373 /* Only create rotates in complete modes. Other cases are not
9374 expanded properly. */
9377 {
9391 {
9395 code0 == LSHIFT_EXPR
9399 }
9401 {
9409 element_precision
9413 return
9416 ? LROTATE_EXPR
9421 }
9423 {
9431 element_precision
9435 return fold_convert_loc
9438 ? LROTATE_EXPR
9442 }
9443 }
9444 }
9446 associate:
9447 /* In most languages, can't associate operations on floats through
9448 parentheses. Rather than remember where the parentheses were, we
9449 don't associate floats at all, unless the user has specified
9450 -fassociative-math.
9451 And, we need to make sure type is not saturating. */
9455 {
9461 /* Split both trees into variables, constants, and literals. Then
9462 associate each group together, the constants with literals,
9463 then the result with variables. This increases the chances of
9464 literals being recombined later and of generating relocatable
9465 expressions for the sum of a constant and literal. */
9470 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9474 /* With undefined overflow prefer doing association in a type
9475 which wraps on overflow, if that is one of the operand types. */
9478 {
9486 }
9488 /* With undefined overflow we can only associate constants with one
9489 variable, and constants whose association doesn't overflow. */
9492 {
9494 {
9500 {
9503 }
9510 {
9513 }
9519 /* The only case we can still associate with two variables
9520 is if they cancel out. */
9524 }
9525 }
9527 /* Only do something if we found more than two objects. Otherwise,
9528 nothing has changed and we risk infinite recursion. */
9534 {
9546 /* Preserve the MINUS_EXPR if the negative part of the literal is
9547 greater than the positive part. Otherwise, the multiplicative
9548 folding code (i.e extract_muldiv) may be fooled in case
9549 unsigned constants are subtracted, like in the following
9550 example: ((X*2 + 4) - 8U)/2. */
9552 {
9556 {
9560 }
9561 else
9562 {
9566 }
9567 }
9569 /* Don't introduce overflows through reassociation. */
9576 {
9578 return
9582 else
9583 {
9586 return
9590 }
9591 }
9594 return
9597 }
9598 }
9603 /* Pointer simplifications for subtraction, simple reassociations. */
9605 {
9606 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
9609 {
9619 }
9620 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
9622 {
9629 }
9630 /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
9631 simplifies. */
9633 {
9640 arg10);
9643 }
9644 }
9645 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9656 {
9657 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
9658 any power of 2 minus 1. */
9663 {
9669 {
9673 }
9674 }
9675 }
9677 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9678 __complex__ ( x, -y ). This is not the same for SNaNs or if
9679 signed zeros are involved. */
9683 {
9690 {
9694 {
9696 arg1r ? arg1r
9701 }
9703 {
9707 arg1i ? arg1i
9710 }
9711 }
9712 }
9714 /* A - B -> A + (-B) if B is easily negatable. */
9718 /* Avoid this transformation if B is a positive REAL_CST. */
9727 /* Fold &a[i] - &a[j] to i-j. */
9732 {
9738 }
9741 && flag_unsafe_math_optimizations
9747 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9748 one. Make sure the type is not saturating and has the signedness of
9749 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9750 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9757 {
9761 }
9766 /* (-A) * (-B) -> A * B */
9781 {
9782 /* Transform x * -C into -x * C if x is easily negatable. */
9791 tem);
9793 /* (a * (1 << b)) is (a << b) */
9803 /* (A + A) * C -> A * 2 * C */
9815 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
9816 sign-changing only. */
9826 {
9829 "occur when simplifying "
9831 WARN_STRICT_OVERFLOW_MISC);
9833 }
9835 /* Optimize z * conj(z) for integer complex numbers. */
9842 }
9843 else
9844 {
9845 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
9846 the result for floating point types due to rounding so it is applied
9847 only if -fassociative-math was specify. */
9852 {
9854 arg1);
9858 }
9860 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
9862 {
9865 {
9868 }
9869 }
9871 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9872 This is not the same for NaNs or if signed zeros are
9873 involved. */
9879 {
9882 return
9888 return
9893 }
9895 /* Optimize z * conj(z) for floating point complex numbers.
9896 Guarded by flag_unsafe_math_optimizations as non-finite
9897 imaginary components don't produce scalar results. */
9908 {
9910 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
9912 && optimize
9914 {
9918 {
9921 }
9922 }
9923 }
9924 }
9928 /* Canonicalize (X & C1) | C2. */
9932 {
9937 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9945 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9950 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9951 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9952 mode which allows further optimizations. */
9957 {
9961 {
9964 }
9965 }
9972 c3)),
9973 arg1);
9974 }
9976 /* (X & ~Y) | (~X & Y) is X ^ Y */
9979 {
9996 }
9998 /* See if this can be simplified into a rotate first. If that
9999 is unsuccessful continue in the association code. */
10003 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10011 /* See if this can be simplified into a rotate first. If that
10012 is unsuccessful continue in the association code. */
10016 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
10024 /* X & ~X , X & (X == 0), and X & !X are always zero. */
10032 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10037 {
10038 tree tem2;
10045 }
10046 /* Fold ~X & 1 as (X & 1) == 0. */
10050 {
10051 tree tem2;
10058 }
10059 /* Fold !X & 1 as X == 0. */
10062 {
10066 }
10068 /* Fold (X ^ Y) & Y as ~X & Y. */
10071 {
10076 }
10077 /* Fold (X ^ Y) & X as ~Y & X. */
10081 {
10086 }
10087 /* Fold X & (X ^ Y) as X & ~Y. */
10090 {
10095 }
10096 /* Fold X & (Y ^ X) as ~Y & X. */
10100 {
10105 }
10107 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10108 multiple of 1 << CST. */
10110 {
10117 }
10119 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10120 bits from CST2. */
10124 {
10132 {
10133 /* Avoid the transform if arg1 is a mask of some
10134 mode which allows further optimizations. */
10141 }
10142 }
10144 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10145 ((A & N) + B) & M -> (A + B) & M
10146 Similarly if (N & M) == 0,
10147 ((A | N) + B) & M -> (A + B) & M
10148 and for - instead of + (or unary - instead of +)
10149 and/or ^ instead of |.
10150 If B is constant and (B & M) == 0, fold into A & M. */
10152 {
10161 {
10164 wide_int cst0;
10166 /* Now we know that arg0 is (C + D) or (C - D) or
10167 -C and arg1 (M) is == (1LL << cst) - 1.
10168 Store C into PMOP[0] and D into PMOP[1]. */
10172 {
10175 }
10182 {
10192 {
10195 }
10198 /* If C or D is of the form (A & N) where
10199 (N & M) == M, or of the form (A | N) or
10200 (A ^ N) where (N & M) == 0, replace it with A. */
10204 /* If C or D is a N where (N & M) == 0, it can be
10205 omitted (assumed 0). */
10213 }
10215 /* Only build anything new if we optimized one or both arguments
10216 above. */
10220 {
10223 {
10224 /* Perform the operations in a type that has defined
10225 overflow behavior. */
10231 }
10236 {
10244 else
10246 }
10249 else
10252 /* TEM is now the new binary +, - or unary - replacement. */
10256 }
10257 }
10258 }
10260 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10263 {
10268 return
10270 }
10275 /* Don't touch a floating-point divide by zero unless the mode
10276 of the constant can represent infinity. */
10282 /* (-A) / (-B) -> A / B */
10292 /* Convert A/B/C to A/(B*C). */
10299 /* Convert A/(B/C) to (A/B)*C. */
10307 /* Convert C1/(X*C2) into (C1/C2)/X. */
10312 {
10318 }
10323 /* Optimize (X & (-A)) / A where A is a power of 2,
10324 to X >> log2(A) */
10328 {
10336 }
10337 }
10339 /* Fall through */
10342 /* Simplify A / (B << N) where A and B are positive and B is
10343 a power of 2, to A >> (N + log2(B)). */
10348 {
10351 {
10359 WARN_STRICT_OVERFLOW_MISC);
10365 }
10366 }
10368 /* Fall through */
10376 /* Convert -A / -B to A / B when the type is signed and overflow is
10377 undefined. */
10381 {
10384 "when distributing negation across "
10386 WARN_STRICT_OVERFLOW_MISC);
10392 }
10396 {
10399 "when distributing negation across "
10401 WARN_STRICT_OVERFLOW_MISC);
10407 }
10409 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10410 operation, EXACT_DIV_EXPR.
10412 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10413 At one time others generated faster code, it's not clear if they do
10414 after the last round to changes to the DIV code in expmed.c. */
10425 {
10429 WARN_STRICT_OVERFLOW_MISC);
10431 }
10443 {
10447 WARN_STRICT_OVERFLOW_MISC);
10449 }
10457 /* Since negative shift count is not well-defined,
10458 don't try to compute it in the compiler. */
10464 /* If we have a rotate of a bit operation with the rotate count and
10465 the second operand of the bit operation both constant,
10466 permute the two operations. */
10478 /* Two consecutive rotates adding up to the some integer
10479 multiple of the precision of the type can be ignored. */
10502 /* Note that the operands of this must be ints
10503 and their values must be 0 or 1.
10504 ("true" is a fixed value perhaps depending on the language.) */
10505 /* If first arg is constant zero, return it. */
10509 /* If either arg is constant true, drop it. */
10513 /* Preserve sequence points. */
10516 /* If second arg is constant zero, result is zero, but first arg
10517 must be evaluated. */
10520 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10521 case will be handled here. */
10525 /* !X && X is always false. */
10529 /* X && !X is always false. */
10534 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10535 means A >= Y && A != MAX, but in this case we know that
10536 A < X <= MAX. */
10540 {
10548 }
10557 /* Note that the operands of this must be ints
10558 and their values must be 0 or true.
10559 ("true" is a fixed value perhaps depending on the language.) */
10560 /* If first arg is constant true, return it. */
10564 /* If either arg is constant zero, drop it. */
10568 /* Preserve sequence points. */
10571 /* If second arg is constant true, result is true, but we must
10572 evaluate first arg. */
10575 /* Likewise for first arg, but note this only occurs here for
10576 TRUTH_OR_EXPR. */
10580 /* !X || X is always true. */
10584 /* X || !X is always true. */
10589 /* (X && !Y) || (!X && Y) is X ^ Y */
10592 {
10609 }
10618 /* If the second arg is constant zero, drop it. */
10621 /* If the second arg is constant true, this is a logical inversion. */
10623 {
10626 }
10627 /* Identical arguments cancel to zero. */
10631 /* !X ^ X is always true. */
10636 /* X ^ !X is always true. */
10652 /* bool_var != 1 becomes !bool_var. */
10659 /* bool_var == 0 becomes !bool_var. */
10666 /* !exp != 0 becomes !exp */
10671 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10680 {
10684 val,
10688 }
10690 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10697 {
10699 code == NE_EXPR
10702 }
10704 /* If this is an EQ or NE comparison with zero and ARG0 is
10705 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10706 two operations, but the latter can be done in one less insn
10707 on machines that have only two-operand insns or on which a
10708 constant cannot be the first operand. */
10711 {
10716 {
10723 arg1);
10724 }
10727 {
10734 arg1);
10735 }
10736 }
10738 /* If this is an NE or EQ comparison of zero against the result of a
10739 signed MOD operation whose second operand is a power of 2, make
10740 the MOD operation unsigned since it is simpler and equivalent. */
10748 {
10758 }
10760 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10761 C1 is a valid shift constant, and C2 is a power of two, i.e.
10762 a single bit. */
10766 == INTEGER_CST
10769 {
10774 /* Check for a valid shift count. */
10776 {
10780 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10781 can be rewritten as (X & (C2 << C1)) != 0. */
10783 {
10788 }
10789 /* Otherwise, for signed (arithmetic) shifts,
10790 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10791 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10795 /* Otherwise, of unsigned (logical) shifts,
10796 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10797 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10798 else
10802 arg000);
10803 }
10804 }
10806 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10807 Similarly for NE_EXPR. */
10811 {
10815 tree dandnotc
10818 notc);
10822 }
10824 /* If this is a comparison of a field, we may be able to simplify it. */
10827 /* Handle the constant case even without -O
10828 to make sure the warnings are given. */
10830 {
10834 }
10836 /* Optimize comparisons of strlen vs zero to a compare of the
10837 first character of the string vs zero. To wit,
10838 strlen(ptr) == 0 => *ptr == 0
10839 strlen(ptr) != 0 => *ptr != 0
10840 Other cases should reduce to one of these two (or a constant)
10841 due to the return value of strlen being unsigned. */
10844 {
10852 {
10857 }
10858 }
10860 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10861 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10865 {
10870 {
10872 {
10875 }
10878 }
10879 }
10881 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10882 (X & C) == 0 when C is a single bit. */
10887 {
10894 arg1));
10895 }
10897 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10898 constant C is a power of two, i.e. a single bit. */
10905 {
10909 }
10911 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10912 when is C is a power of two, i.e. a single bit. */
10919 {
10925 }
10929 {
10932 }
10934 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10937 {
10950 arg01),
10959 arg01),
10968 arg00),
10977 arg00),
10979 }
10983 {
10990 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10991 operand_equal_p guarantees no side-effects so we don't need
10992 to use omit_one_operand on Z. */
10996 arg10));
11000 arg11));
11004 arg10));
11008 arg11));
11010 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
11013 {
11019 }
11020 }
11022 /* Attempt to simplify equality/inequality comparisons of complex
11023 values. Only lower the comparison if the result is known or
11024 can be simplified to a single scalar comparison. */
11029 {
11034 {
11037 }
11038 else
11039 {
11042 }
11045 {
11048 }
11049 else
11050 {
11053 }
11057 {
11059 {
11064 }
11065 else
11066 {
11071 }
11072 }
11076 {
11078 {
11083 }
11084 else
11085 {
11090 }
11091 }
11092 }
11104 /* Transform comparisons of the form X +- C CMP X. */
11111 {
11118 else
11121 /* (X - c) > X becomes false. */
11125 {
11129 "occur when assuming that (X - c) > X "
11131 WARN_STRICT_OVERFLOW_ALL);
11133 }
11135 /* Likewise (X + c) < X becomes false. */
11139 {
11143 "occur when assuming that "
11145 WARN_STRICT_OVERFLOW_ALL);
11147 }
11149 /* Convert (X - c) <= X to true. */
11154 {
11158 "occur when assuming that "
11160 WARN_STRICT_OVERFLOW_ALL);
11162 }
11164 /* Convert (X + c) >= X to true. */
11169 {
11173 "occur when assuming that "
11175 WARN_STRICT_OVERFLOW_ALL);
11177 }
11180 {
11181 /* Convert X + c > X and X - c < X to true for integers. */
11185 {
11188 "not occur when assuming that "
11190 WARN_STRICT_OVERFLOW_ALL);
11192 }
11197 {
11200 "not occur when assuming that "
11202 WARN_STRICT_OVERFLOW_ALL);
11204 }
11206 /* Convert X + c <= X and X - c >= X to false for integers. */
11210 {
11213 "not occur when assuming that "
11215 WARN_STRICT_OVERFLOW_ALL);
11217 }
11222 {
11225 "not occur when assuming that "
11227 WARN_STRICT_OVERFLOW_ALL);
11229 }
11230 }
11231 }
11233 /* If we are comparing an ABS_EXPR with a constant, we can
11234 convert all the cases into explicit comparisons, but they may
11235 well not be faster than doing the ABS and one comparison.
11236 But ABS (X) <= C is a range comparison, which becomes a subtraction
11237 and a comparison, and is probably faster. */
11251 /* Convert ABS_EXPR<x> >= 0 to true. */
11258 {
11261 "when simplifying comparison of "
11263 WARN_STRICT_OVERFLOW_CONDITIONAL);
11266 arg0);
11267 }
11269 /* Convert ABS_EXPR<x> < 0 to false. */
11274 {
11277 "when simplifying comparison of "
11279 WARN_STRICT_OVERFLOW_CONDITIONAL);
11282 arg0);
11283 }
11285 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11286 and similarly for >= into !=. */
11296 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11297 otherwise Y might be >= # of bits in X's type and thus e.g.
11298 (unsigned char) (1 << Y) for Y 15 might be 0.
11299 If the cast is widening, then 1 << Y should have unsigned type,
11300 otherwise if Y is number of bits in the signed shift type minus 1,
11301 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11302 31 might be 0xffffffff80000000. */
11313 {
11319 }
11331 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11332 {
11344 }
11349 /* When pedantic, a compound expression can be neither an lvalue
11350 nor an integer constant expression. */
11353 /* Don't let (0, 0) be null pointer constant. */
11359 /* An ASSERT_EXPR should never be passed to fold_binary. */
11365 }
11367 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11368 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11369 of GOTO_EXPR. */
11371 static tree
11373 {
11375 {
11382 /* ... fall through ... */
11386 }
11387 }
11389 /* Return whether the sub-tree ST contains a label which is accessible from
11390 outside the sub-tree. */
11392 static bool
11394 {
11395 return
11397 }
11399 /* Fold a ternary expression of code CODE and type TYPE with operands
11400 OP0, OP1, and OP2. Return the folded expression if folding is
11401 successful. Otherwise, return NULL_TREE. */
11403 tree
11406 {
11407 tree tem;
11414 /* If this is a commutative operation, and OP0 is a constant, move it
11415 to OP1 to reduce the number of tests below. */
11424 /* Strip any conversions that don't change the mode. This is safe
11425 for every expression, except for a comparison expression because
11426 its signedness is derived from its operands. So, in the latter
11427 case, only strip conversions that don't change the signedness.
11429 Note that this is done as an internal manipulation within the
11430 constant folder, in order to find the simplest representation of
11431 the arguments so that their form can be studied. In any cases,
11432 the appropriate type conversions should be put back in the tree
11433 that will get out of the constant folder. */
11435 {
11438 }
11441 {
11444 }
11447 {
11450 }
11453 {
11457 {
11463 }
11468 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11469 so all simple results must be passed through pedantic_non_lvalue. */
11471 {
11474 /* Only optimize constant conditions when the selected branch
11475 has the same type as the COND_EXPR. This avoids optimizing
11476 away "c ? x : throw", where the throw has a void type.
11477 Avoid throwing away that operand which contains label. */
11484 }
11486 {
11491 {
11496 {
11504 }
11508 }
11509 }
11511 /* If we have A op B ? A : C, we may be able to convert this to a
11512 simpler expression, depending on the operation and the values
11513 of B and C. Signed zeros prevent all of these transformations,
11514 for reasons given above each one.
11516 Also try swapping the arguments and inverting the conditional. */
11521 {
11525 }
11529 op2,
11532 {
11536 {
11540 }
11541 }
11543 /* If the second operand is simpler than the third, swap them
11544 since that produces better jump optimization results. */
11547 {
11549 /* See if this can be inverted. If it can't, possibly because
11550 it was a floating-point inequality comparison, don't do
11551 anything. */
11555 }
11557 /* Convert A ? 1 : 0 to simply A. */
11562 /* If we try to convert OP0 to our type, the
11563 call to fold will try to move the conversion inside
11564 a COND, which will recurse. In that case, the COND_EXPR
11565 is probably the best choice, so leave it alone. */
11569 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11570 over COND_EXPR in cases such as floating point comparisons. */
11579 arg0)));
11581 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11586 {
11587 /* sign_bit_p looks through both zero and sign extensions,
11588 but for this optimization only sign extensions are
11589 usable. */
11592 {
11595 {
11598 }
11600 }
11601 /* sign_bit_p only checks ARG1 bits within A's precision.
11602 If <sign bit of A> has wider type than A, bits outside
11603 of A's precision in <sign bit of A> need to be checked.
11604 If they are all 0, this optimization needs to be done
11605 in unsigned A's type, if they are all 1 in signed A's type,
11606 otherwise this can't be done. */
11612 {
11614 tree tem_type;
11627 {
11630 }
11632 {
11635 }
11636 else
11638 }
11641 return
11647 arg1)));
11648 }
11650 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11651 already handled above. */
11656 {
11665 }
11667 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11668 is probably obsolete because the first operand should be a
11669 truth value (that's why we have the two cases above), but let's
11670 leave it in until we can confirm this for all front-ends. */
11682 /* Disable the transformations below for vectors, since
11683 fold_binary_op_with_conditional_arg may undo them immediately,
11684 yielding an infinite loop. */
11688 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11697 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11702 {
11704 /* Only perform transformation if ARG0 is easily inverted. */
11708 ? BIT_IOR_EXPR
11711 arg1);
11712 }
11714 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11719 {
11721 /* Only perform transformation if ARG0 is easily inverted. */
11727 op2);
11728 }
11730 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11742 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11743 of fold_ternary on them. */
11753 {
11763 {
11768 {
11776 }
11778 /* Constructor elements can be subvectors. */
11781 {
11785 }
11787 /* We keep an exact subset of the constructor elements. */
11789 {
11795 {
11799 }
11807 CONSTRUCTOR_ELT
11810 }
11811 /* The bitfield references a single constructor element. */
11813 {
11818 else
11822 }
11823 }
11824 }
11826 /* A bit-field-ref that referenced the full argument can be stripped. */
11832 /* On constants we can use native encode/interpret to constant
11833 fold (nearly) all BIT_FIELD_REFs. */
11837 /* This limitation should not be necessary, we just need to
11838 round this up to mode size. */
11840 /* Need bit-shifting of the buffer to relax the following. */
11842 {
11847 /* ??? We cannot tell native_encode_expr to start at
11848 some random byte only. So limit us to a reasonable amount
11849 of work. */
11851 {
11856 {
11862 }
11863 }
11864 }
11869 /* For integers we can decompose the FMA if possible. */
11881 {
11897 {
11902 /* Make sure that the perm value is in an acceptable
11903 range. */
11912 else
11917 }
11920 {
11925 }
11930 {
11935 }
11941 {
11945 }
11950 /* Some targets are deficient and fail to expand a single
11951 argument permutation while still allowing an equivalent
11952 2-argument version. */
11956 {
11959 }
11962 {
11969 }
11973 }
11979 }
11981 /* Perform constant folding and related simplification of EXPR.
11982 The related simplifications include x*1 => x, x*0 => 0, etc.,
11983 and application of the associative law.
11984 NOP_EXPR conversions may be removed freely (as long as we
11985 are careful not to change the type of the overall expression).
11986 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11987 but we can constant-fold them if they have constant operands. */
11989 #ifdef ENABLE_FOLD_CHECKING
11990 # define fold(x) fold_1 (x)
11992 static
11993 #endif
11994 tree
11996 {
12000 tree tem;
12003 /* Return right away if a constant. */
12007 /* CALL_EXPR-like objects with variable numbers of operands are
12008 treated specially. */
12010 {
12012 {
12015 }
12017 }
12020 {
12025 {
12043 }
12044 }
12047 {
12049 {
12056 {
12061 /* Find a matching index by means of a binary search. */
12063 {
12079 else
12081 }
12082 }
12085 }
12087 /* Return a VECTOR_CST if possible. */
12089 {
12096 tree value;
12099 {
12103 {
12106 }
12107 else
12109 }
12114 }
12122 }
12124 #ifdef ENABLE_FOLD_CHECKING
12125 #undef fold
12132 /* When --enable-checking=fold, compute a digest of expr before
12133 and after actual fold call to see if fold did not accidentally
12134 change original expr. */
12136 tree
12138 {
12139 tree ret;
12159 }
12161 void
12163 {
12174 }
12176 static void
12178 {
12180 }
12182 static void
12185 {
12191 recursive_label:
12201 {
12202 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12207 }
12214 {
12215 /* Allow these fields to be modified. */
12216 tree tmp;
12224 {
12227 }
12228 }
12239 {
12242 {
12257 }
12261 {
12274 }
12291 {
12297 }
12300 {
12302 {
12305 }
12307 }
12318 {
12321 }
12331 }
12332 }
12334 /* Helper function for outputting the checksum of a tree T. When
12335 debugging with gdb, you can "define mynext" to be "next" followed
12336 by "call debug_fold_checksum (op0)", then just trace down till the
12337 outputs differ. */
12339 DEBUG_FUNCTION void
12341 {
12356 }
12358 #endif
12360 /* Fold a unary tree expression with code CODE of type TYPE with an
12361 operand OP0. LOC is the location of the resulting expression.
12362 Return a folded expression if successful. Otherwise, return a tree
12363 expression with code CODE of type TYPE with an operand OP0. */
12365 tree
12368 {
12369 tree tem;
12370 #ifdef ENABLE_FOLD_CHECKING
12379 #endif
12385 #ifdef ENABLE_FOLD_CHECKING
12392 #endif
12394 }
12396 /* Fold a binary tree expression with code CODE of type TYPE with
12397 operands OP0 and OP1. LOC is the location of the resulting
12398 expression. Return a folded expression if successful. Otherwise,
12399 return a tree expression with code CODE of type TYPE with operands
12400 OP0 and OP1. */
12402 tree
12405 MEM_STAT_DECL)
12406 {
12407 tree tem;
12408 #ifdef ENABLE_FOLD_CHECKING
12425 #endif
12431 #ifdef ENABLE_FOLD_CHECKING
12446 #endif
12448 }
12450 /* Fold a ternary tree expression with code CODE of type TYPE with
12451 operands OP0, OP1, and OP2. Return a folded expression if
12452 successful. Otherwise, return a tree expression with code CODE of
12453 type TYPE with operands OP0, OP1, and OP2. */
12455 tree
12458 {
12459 tree tem;
12460 #ifdef ENABLE_FOLD_CHECKING
12484 #endif
12491 #ifdef ENABLE_FOLD_CHECKING
12514 #endif
12516 }
12518 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12519 arguments in ARGARRAY, and a null static chain.
12520 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12521 of type TYPE from the given operands as constructed by build_call_array. */
12523 tree
12526 {
12527 tree tem;
12528 #ifdef ENABLE_FOLD_CHECKING
12547 #endif
12553 #ifdef ENABLE_FOLD_CHECKING
12569 #endif
12571 }
12573 /* Perform constant folding and related simplification of initializer
12574 expression EXPR. These behave identically to "fold_buildN" but ignore
12575 potential run-time traps and exceptions that fold must preserve. */
12577 #define START_FOLD_INIT \
12578 int saved_signaling_nans = flag_signaling_nans;\
12579 int saved_trapping_math = flag_trapping_math;\
12580 int saved_rounding_math = flag_rounding_math;\
12581 int saved_trapv = flag_trapv;\
12582 int saved_folding_initializer = folding_initializer;\
12583 flag_signaling_nans = 0;\
12584 flag_trapping_math = 0;\
12585 flag_rounding_math = 0;\
12586 flag_trapv = 0;\
12587 folding_initializer = 1;
12589 #define END_FOLD_INIT \
12590 flag_signaling_nans = saved_signaling_nans;\
12591 flag_trapping_math = saved_trapping_math;\
12592 flag_rounding_math = saved_rounding_math;\
12593 flag_trapv = saved_trapv;\
12594 folding_initializer = saved_folding_initializer;
12596 tree
12599 {
12600 tree result;
12601 START_FOLD_INIT;
12605 END_FOLD_INIT;
12607 }
12609 tree
12612 {
12613 tree result;
12614 START_FOLD_INIT;
12618 END_FOLD_INIT;
12620 }
12622 tree
12625 {
12626 tree result;
12627 START_FOLD_INIT;
12631 END_FOLD_INIT;
12633 }
12635 #undef START_FOLD_INIT
12636 #undef END_FOLD_INIT
12638 /* Determine if first argument is a multiple of second argument. Return 0 if
12639 it is not, or we cannot easily determined it to be.
12641 An example of the sort of thing we care about (at this point; this routine
12642 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12643 fold cases do now) is discovering that
12645 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12647 is a multiple of
12649 SAVE_EXPR (J * 8)
12651 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12653 This code also handles discovering that
12655 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12657 is a multiple of 8 so we don't have to worry about dealing with a
12658 possible remainder.
12660 Note that we *look* inside a SAVE_EXPR only to determine how it was
12661 calculated; it is not safe for fold to do much of anything else with the
12662 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12663 at run time. For example, the latter example above *cannot* be implemented
12664 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12665 evaluation time of the original SAVE_EXPR is not necessarily the same at
12666 the time the new expression is evaluated. The only optimization of this
12667 sort that would be valid is changing
12669 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12671 divided by 8 to
12673 SAVE_EXPR (I) * SAVE_EXPR (J)
12675 (where the same SAVE_EXPR (J) is used in the original and the
12676 transformed version). */
12678 int
12680 {
12688 {
12690 /* Bitwise and provides a power of two multiple. If the mask is
12691 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12694 /* FALLTHRU */
12707 {
12711 /* const_binop may not detect overflow correctly,
12712 so check for it explicitly here. */
12716 size_one_node,
12717 op1)))
12720 }
12724 /* Can't handle conversions from non-integral or wider integral type. */
12730 /* .. fall through ... */
12747 SIGNED);
12751 }
12752 }
12754 #define tree_expr_nonnegative_warnv_p(X, Y) \
12757 #define RECURSE(X) \
12758 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12760 /* Return true if CODE or TYPE is known to be non-negative. */
12762 static bool
12764 {
12767 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12768 have a signed:1 type (where the value is -1 and 0). */
12771 }
12773 /* Return true if (CODE OP0) is known to be non-negative. If the return
12774 value is based on the assumption that signed overflow is undefined,
12775 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12776 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12778 bool
12781 {
12786 {
12788 /* We can't return 1 if flag_wrapv is set because
12789 ABS_EXPR<INT_MIN> = INT_MIN. */
12793 {
12796 }
12804 CASE_CONVERT:
12805 {
12810 {
12814 {
12818 }
12819 }
12821 {
12827 }
12828 }
12833 }
12835 /* We don't know sign of `t', so be conservative and return false. */
12837 }
12839 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12840 value is based on the assumption that signed overflow is undefined,
12841 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12842 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12844 bool
12848 {
12853 {
12859 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12860 both unsigned and at least 2 bits shorter than the result. */
12864 {
12869 {
12873 }
12874 }
12879 {
12880 /* x * x is always non-negative for floating point x
12881 or without overflow. */
12884 {
12889 }
12890 }
12892 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12893 both unsigned and their total bits is shorter than the result. */
12897 {
12916 {
12926 }
12927 }
12952 }
12954 /* We don't know sign of `t', so be conservative and return false. */
12956 }
12958 /* Return true if SSA name T is known to be non-negative. If the return
12959 value is based on the assumption that signed overflow is undefined,
12960 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12961 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12963 static bool
12965 {
12966 /* Limit the depth of recursion to avoid quadratic behavior.
12967 This is expected to catch almost all occurrences in practice.
12968 If this code misses important cases that unbounded recursion
12969 would not, passes that need this information could be revised
12970 to provide it through dataflow propagation. */
12975 }
12977 /* Return true if T is known to be non-negative. If the return
12978 value is based on the assumption that signed overflow is undefined,
12979 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12980 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12982 bool
12984 {
12989 {
13007 }
13008 }
13010 /* Return true if T is known to be non-negative. If the return
13011 value is based on the assumption that signed overflow is undefined,
13012 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13013 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13015 bool
13018 {
13021 {
13041 /* Always true. */
13045 /* sqrt(-0.0) is -0.0. */
13085 /* True if the 1st argument is nonnegative. */
13089 /* True if the 1st OR 2nd arguments are nonnegative. */
13093 /* True if the 1st AND 2nd arguments are nonnegative. */
13097 /* True if the 2nd argument is nonnegative. */
13101 /* True if the 1st argument is nonnegative or the second
13102 argument is an even integer. */
13109 /* True if the 1st argument is nonnegative or the second
13110 argument is an even integer valued real. */
13112 {
13113 REAL_VALUE_TYPE c;
13114 HOST_WIDE_INT n;
13119 {
13120 REAL_VALUE_TYPE cint;
13124 }
13125 }
13130 }
13132 }
13134 /* Return true if T is known to be non-negative. If the return
13135 value is based on the assumption that signed overflow is undefined,
13136 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13137 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13139 static bool
13141 {
13147 {
13149 {
13153 /* If the initializer is non-void, then it's a normal expression
13154 that will be assigned to the slot. */
13158 /* Otherwise, the initializer sets the slot in some way. One common
13159 way is an assignment statement at the end of the initializer. */
13161 {
13169 else
13171 }
13177 }
13180 {
13186 arg0,
13187 arg1,
13189 }
13202 }
13203 }
13205 #undef RECURSE
13206 #undef tree_expr_nonnegative_warnv_p
13208 /* Return true if T is known to be non-negative. If the return
13209 value is based on the assumption that signed overflow is undefined,
13210 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13211 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13213 bool
13215 {
13222 {
13244 }
13247 {
13273 }
13274 }
13276 /* Return true if `t' is known to be non-negative. Handle warnings
13277 about undefined signed overflow. */
13279 bool
13281 {
13288 "determining that expression is always "
13290 WARN_STRICT_OVERFLOW_MISC);
13292 }
13295 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13296 For floating point we further ensure that T is not denormal.
13297 Similar logic is present in nonzero_address in rtlanal.h.
13299 If the return value is based on the assumption that signed overflow
13300 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13301 change *STRICT_OVERFLOW_P. */
13303 bool
13306 {
13308 {
13311 strict_overflow_p);
13314 {
13320 strict_overflow_p));
13321 }
13326 strict_overflow_p);
13330 }
13333 }
13335 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13336 For floating point we further ensure that T is not denormal.
13337 Similar logic is present in nonzero_address in rtlanal.h.
13339 If the return value is based on the assumption that signed overflow
13340 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13341 change *STRICT_OVERFLOW_P. */
13343 bool
13345 tree type,
13346 tree op0,
13348 {
13351 {
13355 {
13356 /* With the presence of negative values it is hard
13357 to say something. */
13364 /* One of operands must be positive and the other non-negative. */
13365 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13366 overflows, on a twos-complement machine the sum of two
13367 nonnegative numbers can never be zero. */
13369 strict_overflow_p)
13371 strict_overflow_p));
13372 }
13377 {
13379 strict_overflow_p)
13381 strict_overflow_p))
13382 {
13385 }
13386 }
13395 {
13398 }
13405 {
13409 /* When both operands are nonzero, then MAX must be too. */
13411 strict_overflow_p))
13414 /* MAX where operand 0 is positive is positive. */
13416 strict_overflow_p);
13417 }
13418 /* MAX where operand 1 is positive is positive. */
13423 {
13427 }
13432 strict_overflow_p)
13434 strict_overflow_p));
13438 }
13441 }
13443 /* Return true when T is an address and is known to be nonzero.
13444 For floating point we further ensure that T is not denormal.
13445 Similar logic is present in nonzero_address in rtlanal.h.
13447 If the return value is based on the assumption that signed overflow
13448 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13449 change *STRICT_OVERFLOW_P. */
13451 bool
13453 {
13456 {
13461 {
13470 /* For objects in symbol table check if we know they are non-zero.
13471 Don't do anything for variables and functions before symtab is built;
13472 it is quite possible that they will be declared weak later. */
13474 {
13480 else
13482 }
13484 /* Function local objects are never NULL. */
13491 /* Constants are never weak. */
13496 }
13504 {
13508 }
13513 }
13515 }
13517 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13518 attempt to fold the expression to a constant without modifying TYPE,
13519 OP0 or OP1.
13521 If the expression could be simplified to a constant, then return
13522 the constant. If the expression would not be simplified to a
13523 constant, then return NULL_TREE. */
13525 tree
13527 {
13530 }
13532 /* Given the components of a unary expression CODE, TYPE and OP0,
13533 attempt to fold the expression to a constant without modifying
13534 TYPE or OP0.
13536 If the expression could be simplified to a constant, then return
13537 the constant. If the expression would not be simplified to a
13538 constant, then return NULL_TREE. */
13540 tree
13542 {
13545 }
13547 /* If EXP represents referencing an element in a constant string
13548 (either via pointer arithmetic or array indexing), return the
13549 tree representing the value accessed, otherwise return NULL. */
13551 tree
13553 {
13557 {
13559 tree index;
13560 tree string;
13565 else
13566 {
13570 /* Optimize the special-case of a zero lower bound.
13572 We convert the low_bound to sizetype to avoid some problems
13573 with constant folding. (E.g. suppose the lower bound is 1,
13574 and its mode is QI. Without the conversion,l (ARRAY
13575 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13576 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13582 }
13595 }
13597 }
13599 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13600 an integer constant, real, or fixed-point constant.
13602 TYPE is the type of the result. */
13604 static tree
13606 {
13610 {
13612 {
13619 }
13626 {
13627 FIXED_VALUE_TYPE f;
13632 /* Propagate overflow flags. */
13636 }
13640 }
13643 }
13645 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13646 an integer constant or real constant.
13648 TYPE is the type of the result. */
13650 tree
13652 {
13656 {
13658 {
13659 /* If the value is unsigned or non-negative, then the absolute value
13660 is the same as the ordinary value. */
13664 /* If the value is negative, then the absolute value is
13665 its negation. */
13666 else
13667 {
13672 }
13673 }
13679 else
13685 }
13688 }
13690 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13691 constant. TYPE is the type of the result. */
13693 static tree
13695 {
13699 }
13701 /* Given CODE, a relational operator, the target type, TYPE and two
13702 constant operands OP0 and OP1, return the result of the
13703 relational operation. If the result is not a compile time
13704 constant, then return NULL_TREE. */
13706 static tree
13708 {
13711 /* From here on, the only cases we handle are when the result is
13712 known to be a constant. */
13715 {
13719 /* Handle the cases where either operand is a NaN. */
13721 {
13723 {
13751 }
13754 }
13757 }
13760 {
13764 }
13766 /* Handle equality/inequality of complex constants. */
13768 {
13779 else
13781 }
13784 {
13791 {
13803 }
13806 }
13808 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13810 To compute GT, swap the arguments and do LT.
13811 To compute GE, do LT and invert the result.
13812 To compute LE, swap the arguments, do LT and invert the result.
13813 To compute NE, do EQ and invert the result.
13815 Therefore, the code below must handle only EQ and LT. */
13818 {
13821 }
13823 /* Note that it is safe to invert for real values here because we
13824 have already handled the one case that it matters. */
13828 {
13831 }
13833 /* Compute a result for LT or EQ if args permit;
13834 Otherwise return T. */
13836 {
13839 else
13841 }
13842 else
13848 }
13850 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13851 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13852 itself. */
13854 tree
13856 {
13857 /* If the expression does not have side effects then we don't have to wrap
13858 it with a cleanup point expression. */
13862 /* If the expression is a return, check to see if the expression inside the
13863 return has no side effects or the right hand side of the modify expression
13864 inside the return. If either don't have side effects set we don't need to
13865 wrap the expression in a cleanup point expression. Note we don't check the
13866 left hand side of the modify because it should always be a return decl. */
13868 {
13875 }
13878 }
13880 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13881 of an indirection through OP0, or NULL_TREE if no simplification is
13882 possible. */
13884 tree
13886 {
13888 tree subtype;
13896 {
13899 /* *&CONST_DECL -> to the value of the const decl. */
13902 /* *&p => p; make sure to handle *&"str"[cst] here. */
13904 {
13908 else
13910 }
13911 /* *(foo *)&fooarray => fooarray[0] */
13914 && (!in_gimple_form
13916 {
13926 }
13927 /* *(foo *)&complexfoo => __real__ complexfoo */
13931 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
13934 {
13938 }
13939 }
13943 {
13949 {
13950 tree op00type;
13954 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
13957 {
13969 }
13970 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
13973 {
13977 }
13978 /* ((foo *)&fooarray)[1] => fooarray[1] */
13981 {
13991 }
13992 }
13993 }
13995 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
13998 && (!in_gimple_form
14000 {
14001 tree type_domain;
14011 NULL_TREE);
14012 }
14015 }
14017 /* Builds an expression for an indirection through T, simplifying some
14018 cases. */
14020 tree
14022 {
14030 }
14032 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14034 tree
14036 {
14041 else
14043 }
14045 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14046 whose result is ignored. The type of the returned tree need not be
14047 the same as the original expression. */
14049 tree
14051 {
14057 {
14068 else
14074 {
14090 }
14095 }
14096 }
14098 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14100 tree
14102 {
14108 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14109 have to do anything. Only do this when we are not given a const,
14110 because in that case, this check is more expensive than just
14111 doing it. */
14113 {
14118 }
14120 /* If divisor is a power of two, simplify this to bit manipulation. */
14122 {
14124 {
14138 }
14139 else
14140 {
14141 tree t;
14147 }
14148 }
14149 else
14150 {
14155 }
14158 }
14160 /* Likewise, but round down. */
14162 tree
14164 {
14171 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14172 have to do anything. Only do this when we are not given a const,
14173 because in that case, this check is more expensive than just
14174 doing it. */
14176 {
14181 }
14183 /* If divisor is a power of two, simplify this to bit manipulation. */
14185 {
14186 tree t;
14190 }
14191 else
14192 {
14197 }
14200 }
14202 /* Returns the pointer to the base of the object addressed by EXP and
14203 extracts the information about the offset of the access, storing it
14204 to PBITPOS and POFFSET. */
14206 static tree
14209 {
14210 tree core;
14211 machine_mode mode;
14213 HOST_WIDE_INT bitsize;
14217 {
14222 }
14223 else
14224 {
14228 }
14231 }
14233 /* Returns true if addresses of E1 and E2 differ by a constant, false
14234 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14236 bool
14238 {
14252 {
14262 }
14264 {
14265 /* If only one of the offsets is non-constant, the difference cannot
14266 be a constant. */
14268 }
14269 else
14274 }
14276 /* Simplify the floating point expression EXP when the sign of the
14277 result is not significant. Return NULL_TREE if no simplification
14278 is possible. */
14280 tree
14282 {
14287 {
14323 {
14326 {
14328 /* Strip copysign function call, return the 1st argument. */
14334 /* Strip sign ops from the argument of "odd" math functions. */
14336 {
14340 }
14342 }
14343 }
14348 }
14350 }
14352 /* Return OFF converted to a pointer offset type suitable as offset for
14353 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14354 tree
14356 {
14358 }
14360 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14361 tree
14363 {
14366 }
14368 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14369 tree
14371 {
14374 }