| blob | 5576d592988fdae47a1b77f64bce4cd3057489a9 |
1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2017 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 /* Nonzero if we are folding constants inside an initializer; zero
84 otherwise. */
87 /* The following constants represent a bit based encoding of GCC's
88 comparison operators. This encoding simplifies transformations
89 on relational comparison operators, such as AND and OR. */
107 };
144 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
145 Otherwise, return LOC. */
147 static location_t
149 {
152 }
154 /* Similar to protected_set_expr_location, but never modify x in place,
155 if location can and needs to be set, unshare it. */
159 {
165 {
168 }
170 }
171 \f
172 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
173 division and returns the quotient. Otherwise returns
174 NULL_TREE. */
176 tree
178 {
179 widest_int quo;
186 }
187 \f
188 /* This is nonzero if we should defer warnings about undefined
189 overflow. This facility exists because these warnings are a
190 special case. The code to estimate loop iterations does not want
191 to issue any warnings, since it works with expressions which do not
192 occur in user code. Various bits of cleanup code call fold(), but
193 only use the result if it has certain characteristics (e.g., is a
194 constant); that code only wants to issue a warning if the result is
195 used. */
199 /* If a warning about undefined overflow is deferred, this is the
200 warning. Note that this may cause us to turn two warnings into
201 one, but that is fine since it is sufficient to only give one
202 warning per expression. */
206 /* If a warning about undefined overflow is deferred, this is the
207 level at which the warning should be emitted. */
211 /* Start deferring overflow warnings. We could use a stack here to
212 permit nested calls, but at present it is not necessary. */
214 void
216 {
218 }
220 /* Stop deferring overflow warnings. If there is a pending warning,
221 and ISSUE is true, then issue the warning if appropriate. STMT is
222 the statement with which the warning should be associated (used for
223 location information); STMT may be NULL. CODE is the level of the
224 warning--a warn_strict_overflow_code value. This function will use
225 the smaller of CODE and the deferred code when deciding whether to
226 issue the warning. CODE may be zero to mean to always use the
227 deferred code. */
229 void
231 {
233 location_t locus;
238 {
244 }
255 /* Use the smallest code level when deciding to issue the
256 warning. */
265 else
268 }
270 /* Stop deferring overflow warnings, ignoring any deferred
271 warnings. */
273 void
275 {
277 }
279 /* Whether we are deferring overflow warnings. */
281 bool
283 {
285 }
287 /* This is called when we fold something based on the fact that signed
288 overflow is undefined. */
290 void
292 {
294 {
297 {
300 }
301 }
304 }
305 \f
306 /* Return true if the built-in mathematical function specified by CODE
307 is odd, i.e. -f(x) == f(-x). */
309 bool
311 {
313 {
314 CASE_CFN_ASIN:
315 CASE_CFN_ASINH:
316 CASE_CFN_ATAN:
317 CASE_CFN_ATANH:
318 CASE_CFN_CASIN:
319 CASE_CFN_CASINH:
320 CASE_CFN_CATAN:
321 CASE_CFN_CATANH:
322 CASE_CFN_CBRT:
323 CASE_CFN_CPROJ:
324 CASE_CFN_CSIN:
325 CASE_CFN_CSINH:
326 CASE_CFN_CTAN:
327 CASE_CFN_CTANH:
328 CASE_CFN_ERF:
329 CASE_CFN_LLROUND:
330 CASE_CFN_LROUND:
331 CASE_CFN_ROUND:
332 CASE_CFN_SIN:
333 CASE_CFN_SINH:
334 CASE_CFN_TAN:
335 CASE_CFN_TANH:
336 CASE_CFN_TRUNC:
339 CASE_CFN_LLRINT:
340 CASE_CFN_LRINT:
341 CASE_CFN_NEARBYINT:
342 CASE_CFN_RINT:
347 }
349 }
351 /* Check whether we may negate an integer constant T without causing
352 overflow. */
354 bool
356 {
357 tree type;
366 }
368 /* Determine whether an expression T can be cheaply negated using
369 the function negate_expr without introducing undefined overflow. */
371 static bool
373 {
374 tree type;
383 {
388 /* Check that -CST will not overflow type. */
401 /* We want to canonicalize to positive real constants. Pretend
402 that only negative ones can be easily negated. */
410 {
421 }
436 /* -(A + B) -> (-B) - A. */
439 /* -(A + B) -> (-A) - B. */
443 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
452 /* INT_MIN/n * n doesn't overflow while negating one operand it does
453 if n is a (negative) power of two. */
462 /* Fall through. */
477 /* In general we can't negate B in 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. */
488 /* Negate -((double)float) as (double)(-float). */
490 {
494 }
498 /* Negate -f(x) as f(-x). */
504 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
506 {
510 }
515 }
517 }
519 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
520 simplification is possible.
521 If negate_expr_p would return true for T, NULL_TREE will never be
522 returned. */
524 static tree
526 {
528 tree tem;
531 {
532 /* Convert - (~A) to A + 1. */
558 {
563 }
567 {
572 {
576 }
579 }
602 {
603 /* -(A + B) -> (-B) - A. */
605 {
609 }
611 /* -(A + B) -> (-A) - B. */
613 {
617 }
618 }
622 /* - (A - B) -> B - A */
633 /* Fall through. */
637 {
646 }
658 /* In general we can't negate B in A / B, because if A is INT_MIN and
659 B is 1, we may turn this into INT_MIN / -1 which is undefined
660 and actually traps on some architectures. */
672 /* Convert -((double)float) into (double)(-float). */
674 {
678 }
682 /* Negate -f(x) as f(-x). */
685 {
691 }
695 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
697 {
700 {
707 }
708 }
713 }
716 }
718 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
719 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
720 return NULL_TREE. */
722 static tree
724 {
726 location_t loc;
739 }
740 \f
741 /* Split a tree IN into a constant, literal and variable parts that could be
742 combined with CODE to make IN. "constant" means an expression with
743 TREE_CONSTANT but that isn't an actual constant. CODE must be a
744 commutative arithmetic operation. Store the constant part into *CONP,
745 the literal in *LITP and return the variable part. If a part isn't
746 present, set it to null. If the tree does not decompose in this way,
747 return the entire tree as the variable part and the other parts as null.
749 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
750 case, we negate an operand that was subtracted. Except if it is a
751 literal for which we use *MINUS_LITP instead.
753 If NEGATE_P is true, we are negating all of IN, again except a literal
754 for which we use *MINUS_LITP instead. If a variable part is of pointer
755 type, it is negated after converting to TYPE. This prevents us from
756 generating illegal MINUS pointer expression. LOC is the location of
757 the converted variable part.
759 If IN is itself a literal or constant, return it as appropriate.
761 Note that we do not guarantee that any of the three values will be the
762 same type as IN, but they will have the same signedness and mode. */
764 static tree
767 {
774 /* Strip any conversions that don't change the machine mode or signedness. */
783 /* We can associate addition and subtraction together (even
784 though the C standard doesn't say so) for integers because
785 the value is not affected. For reals, the value might be
786 affected, so we can't. */
789 {
795 /* First see if either of the operands is a literal, then a constant. */
808 /* If we haven't dealt with either operand, this is not a case we can
809 decompose. Otherwise, VAR is either of the ones remaining, if any. */
814 else
817 /* Now do any needed negations. */
823 {
824 /* Convert to TYPE before negating. */
827 }
828 }
833 {
834 /* -X - 1 is folded to ~X, undo that here. Do _not_ do this
835 when IN is constant. */
838 }
839 else
843 {
850 {
851 /* Convert to TYPE before negating. */
854 }
855 }
858 }
860 /* Re-associate trees split by the above function. T1 and T2 are
861 either expressions to associate or null. Return the new
862 expression, if any. LOC is the location of the new expression. If
863 we build an operation, do it in TYPE and with CODE. */
865 static tree
867 {
873 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
874 try to fold this since we will have infinite recursion. But do
875 deal with any NEGATE_EXPRs. */
878 {
880 {
893 }
895 {
898 }
902 }
906 }
907 \f
908 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
909 for use in int_const_binop, size_binop and size_diffop. */
911 static bool
913 {
920 {
929 }
934 }
937 /* Combine two integer constants ARG1 and ARG2 under operation CODE
938 to produce a new constant. Return NULL_TREE if we don't know how
939 to evaluate CODE at compile-time. */
941 static tree
944 {
945 wide_int res;
946 tree t;
954 {
970 {
974 else
976 }
979 /* It's unclear from the C standard whether shifts can overflow.
980 The following code ignores overflow; perhaps a C standard
981 interpretation ruling is needed. */
983 else
990 {
994 else
996 }
1000 else
1079 }
1087 }
1089 tree
1091 {
1093 }
1095 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1096 constant. We assume ARG1 and ARG2 have the same data type, or at least
1097 are the same kind of constant and the same machine mode. Return zero if
1098 combining the constants is not allowed in the current operating mode. */
1100 static tree
1102 {
1103 /* Sanity check for the recursive cases. */
1111 {
1117 }
1120 {
1121 machine_mode mode;
1122 REAL_VALUE_TYPE d1;
1123 REAL_VALUE_TYPE d2;
1124 REAL_VALUE_TYPE value;
1125 REAL_VALUE_TYPE result;
1129 /* The following codes are handled by real_arithmetic. */
1131 {
1142 }
1150 /* Don't perform operation if we honor signaling NaNs and
1151 either operand is a signaling NaN. */
1157 /* Don't perform operation if it would raise a division
1158 by zero exception. */
1164 /* If either operand is a NaN, just return it. Otherwise, set up
1165 for floating-point trap; we return an overflow. */
1167 {
1168 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1169 is off. */
1173 }
1175 {
1176 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1177 is off. */
1181 }
1186 /* Don't constant fold this floating point operation if
1187 the result has overflowed and flag_trapping_math. */
1195 /* Don't constant fold this floating point operation if the
1196 result may dependent upon the run-time rounding mode and
1197 flag_rounding_math is set, or if GCC's software emulation
1198 is unable to accurately represent the result. */
1208 }
1211 {
1212 FIXED_VALUE_TYPE f1;
1213 FIXED_VALUE_TYPE f2;
1214 FIXED_VALUE_TYPE result;
1219 /* The following codes are handled by fixed_arithmetic. */
1221 {
1233 {
1240 }
1245 }
1252 /* Propagate overflow flags. */
1256 }
1259 {
1268 {
1279 mpc_mul);
1293 mpc_div);
1294 /* Fallthru. */
1300 {
1301 /* Keep this algorithm in sync with
1302 tree-complex.c:expand_complex_div_straight().
1304 Expand complex division to scalars, straightforward algorithm.
1305 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1306 t = br*br + bi*bi
1307 */
1308 tree magsquared
1312 tree t1
1316 tree t2
1323 }
1324 else
1325 {
1326 /* Keep this algorithm in sync with
1327 tree-complex.c:expand_complex_div_wide().
1329 Expand complex division to scalars, modified algorithm to minimize
1330 overflow with wide input ranges. */
1336 {
1337 /* In the TRUE branch, we compute
1338 ratio = br/bi;
1339 div = (br * ratio) + bi;
1340 tr = (ar * ratio) + ai;
1341 ti = (ai * ratio) - ar;
1342 tr = tr / div;
1343 ti = ti / div; */
1354 }
1355 else
1356 {
1357 /* In the FALSE branch, we compute
1358 ratio = d/c;
1359 divisor = (d * ratio) + c;
1360 tr = (b * ratio) + a;
1361 ti = b - (a * ratio);
1362 tr = tr / div;
1363 ti = ti / div; */
1375 }
1376 }
1381 }
1385 }
1389 {
1395 {
1401 /* It is possible that const_binop cannot handle the given
1402 code and return NULL_TREE */
1405 }
1408 }
1410 /* Shifts allow a scalar offset for a vector. */
1413 {
1419 {
1424 /* It is possible that const_binop cannot handle the given
1425 code and return NULL_TREE. */
1428 }
1431 }
1433 }
1435 /* Overload that adds a TYPE parameter to be able to dispatch
1436 to fold_relational_const. */
1438 tree
1440 {
1444 /* ??? Until we make the const_binop worker take the type of the
1445 result as argument put those cases that need it here. */
1447 {
1458 {
1474 {
1480 }
1483 }
1489 {
1514 {
1527 }
1530 }
1533 }
1538 /* Make sure type and arg0 have the same saturating flag. */
1543 }
1545 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1546 Return zero if computing the constants is not possible. */
1548 tree
1550 {
1551 /* Don't perform the operation, other than NEGATE and ABS, if
1552 flag_signaling_nans is on and the operand is a signaling NaN. */
1561 {
1562 CASE_CONVERT:
1569 /* If the source address is 0, and the source address space
1570 cannot have a valid object at 0, fold to dest type null. */
1581 {
1582 /* Can't call fold_negate_const directly here as that doesn't
1583 handle all cases and we might not be able to negate some
1584 constants. */
1589 }
1598 {
1602 }
1608 /* Perform BIT_NOT_EXPR on each element individually. */
1610 {
1612 tree elem;
1617 {
1623 }
1626 }
1648 {
1667 else
1671 {
1675 }
1678 }
1683 {
1697 {
1702 }
1705 {
1709 }
1712 }
1716 }
1719 }
1721 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1722 indicates which particular sizetype to create. */
1724 tree
1726 {
1728 }
1729 \f
1730 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1731 is a tree code. The type of the result is taken from the operands.
1732 Both must be equivalent integer types, ala int_binop_types_match_p.
1733 If the operands are constant, so is the result. */
1735 tree
1737 {
1746 /* Handle the special case of two integer constants faster. */
1748 {
1749 /* And some specific cases even faster than that. */
1751 {
1756 }
1758 {
1761 }
1763 {
1766 }
1768 /* Handle general case of two integer constants. For sizetype
1769 constant calculations we always want to know about overflow,
1770 even in the unsigned case. */
1772 }
1775 }
1777 /* Given two values, either both of sizetype or both of bitsizetype,
1778 compute the difference between the two values. Return the value
1779 in signed type corresponding to the type of the operands. */
1781 tree
1783 {
1785 tree ctype;
1790 /* If the type is already signed, just do the simple thing. */
1798 else
1801 /* If either operand is not a constant, do the conversions to the signed
1802 type and subtract. The hardware will do the right thing with any
1803 overflow in the subtraction. */
1809 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1810 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1811 overflow) and negate (which can't either). Special-case a result
1812 of zero while we're here. */
1818 else
1822 MINUS_EXPR,
1824 }
1825 \f
1826 /* A subroutine of fold_convert_const handling conversions of an
1827 INTEGER_CST to another integer type. */
1829 static tree
1831 {
1832 /* Given an integer constant, make new constant with new type,
1833 appropriately sign-extended or truncated. Use widest_int
1834 so that any extension is done according ARG1's type. */
1838 }
1840 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1841 to an integer type. */
1843 static tree
1845 {
1847 tree t;
1849 /* The following code implements the floating point to integer
1850 conversion rules required by the Java Language Specification,
1851 that IEEE NaNs are mapped to zero and values that overflow
1852 the target precision saturate, i.e. values greater than
1853 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1854 are mapped to INT_MIN. These semantics are allowed by the
1855 C and C++ standards that simply state that the behavior of
1856 FP-to-integer conversion is unspecified upon overflow. */
1858 wide_int val;
1859 REAL_VALUE_TYPE r;
1863 {
1870 }
1872 /* If R is NaN, return zero and show we have an overflow. */
1874 {
1877 }
1879 /* See if R is less than the lower bound or greater than the
1880 upper bound. */
1883 {
1887 {
1890 }
1891 }
1894 {
1897 {
1900 {
1903 }
1904 }
1905 }
1912 }
1914 /* A subroutine of fold_convert_const handling conversions of a
1915 FIXED_CST to an integer type. */
1917 static tree
1919 {
1920 tree t;
1924 /* Right shift FIXED_CST to temp by fbit. */
1928 {
1930 HOST_BITS_PER_DOUBLE_INT,
1933 /* Left shift temp to temp_trunc by fbit. */
1935 HOST_BITS_PER_DOUBLE_INT,
1937 }
1938 else
1939 {
1942 }
1944 /* If FIXED_CST is negative, we need to round the value toward 0.
1945 By checking if the fractional bits are not zero to add 1 to temp. */
1951 /* Given a fixed-point constant, make new constant with new type,
1952 appropriately sign-extended or truncated. */
1960 }
1962 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1963 to another floating point type. */
1965 static tree
1967 {
1968 REAL_VALUE_TYPE value;
1969 tree t;
1971 /* Don't perform the operation if flag_signaling_nans is on
1972 and the operand is a signaling NaN. */
1980 /* If converting an infinity or NAN to a representation that doesn't
1981 have one, set the overflow bit so that we can produce some kind of
1982 error message at the appropriate point if necessary. It's not the
1983 most user-friendly message, but it's better than nothing. */
1990 /* Regular overflow, conversion produced an infinity in a mode that
1991 can't represent them. */
1996 else
1999 }
2001 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2002 to a floating point type. */
2004 static tree
2006 {
2007 REAL_VALUE_TYPE value;
2008 tree t;
2015 }
2017 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2018 to another fixed-point type. */
2020 static tree
2022 {
2023 FIXED_VALUE_TYPE value;
2024 tree t;
2031 /* Propagate overflow flags. */
2035 }
2037 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2038 to a fixed-point type. */
2040 static tree
2042 {
2043 FIXED_VALUE_TYPE value;
2044 tree t;
2046 double_int di;
2053 else
2061 /* Propagate overflow flags. */
2065 }
2067 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2068 to a fixed-point type. */
2070 static tree
2072 {
2073 FIXED_VALUE_TYPE value;
2074 tree t;
2082 /* Propagate overflow flags. */
2086 }
2088 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2089 type TYPE. If no simplification can be done return NULL_TREE. */
2091 static tree
2093 {
2099 {
2106 }
2108 {
2115 }
2117 {
2124 }
2126 {
2129 {
2134 {
2140 }
2142 }
2143 }
2145 }
2147 /* Construct a vector of zero elements of vector type TYPE. */
2149 static tree
2151 {
2152 tree t;
2156 }
2158 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2160 bool
2162 {
2177 {
2192 }
2193 }
2195 /* Convert expression ARG to type TYPE. Used by the middle-end for
2196 simple conversions in preference to calling the front-end's convert. */
2198 tree
2200 {
2202 tree tem;
2213 {
2216 /* Handle conversions between pointers to different address spaces. */
2221 /* fall through */
2226 {
2230 }
2244 {
2248 }
2250 {
2254 }
2256 {
2260 }
2263 {
2281 }
2286 {
2290 }
2293 {
2307 }
2311 {
2320 integer_zero_node));
2322 {
2326 {
2332 }
2340 }
2344 }
2362 }
2363 fold_convert_exit:
2366 }
2367 \f
2368 /* Return false if expr can be assumed not to be an lvalue, true
2369 otherwise. */
2371 static bool
2373 {
2374 /* We only need to wrap lvalue tree codes. */
2376 {
2407 /* Assume the worst for front-end tree codes. */
2411 }
2414 }
2416 /* Return an expr equal to X but certainly not valid as an lvalue. */
2418 tree
2420 {
2421 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2422 us. */
2429 }
2431 /* When pedantic, return an expr equal to X but certainly not valid as a
2432 pedantic lvalue. Otherwise, return X. */
2434 static tree
2436 {
2438 }
2439 \f
2440 /* Given a tree comparison code, return the code that is the logical inverse.
2441 It is generally not safe to do this for floating-point comparisons, except
2442 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2443 ERROR_MARK in this case. */
2445 enum tree_code
2447 {
2453 {
2484 }
2485 }
2487 /* Similar, but return the comparison that results if the operands are
2488 swapped. This is safe for floating-point. */
2490 enum tree_code
2492 {
2494 {
2520 }
2521 }
2524 /* Convert a comparison tree code from an enum tree_code representation
2525 into a compcode bit-based encoding. This function is the inverse of
2526 compcode_to_comparison. */
2528 static enum comparison_code
2530 {
2532 {
2563 }
2564 }
2566 /* Convert a compcode bit-based encoding of a comparison operator back
2567 to GCC's enum tree_code representation. This function is the
2568 inverse of comparison_to_compcode. */
2570 static enum tree_code
2572 {
2574 {
2605 }
2606 }
2608 /* Return a tree for the comparison which is the combination of
2609 doing the AND or OR (depending on CODE) of the two operations LCODE
2610 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2611 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2612 if this makes the transformation invalid. */
2614 tree
2619 {
2626 {
2637 }
2640 {
2641 /* Eliminate unordered comparisons, as well as LTGT and ORD
2642 which are not used unless the mode has NaNs. */
2648 }
2650 {
2651 /* Check that the original operation and the optimized ones will trap
2652 under the same condition. */
2663 /* In a short-circuited boolean expression the LHS might be
2664 such that the RHS, if evaluated, will never trap. For
2665 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2666 if neither x nor y is NaN. (This is a mixed blessing: for
2667 example, the expression above will never trap, hence
2668 optimizing it to x < y would be invalid). */
2673 /* If the comparison was short-circuited, and only the RHS
2674 trapped, we may now generate a spurious trap. */
2679 /* If we changed the conditions that cause a trap, we lose. */
2682 }
2688 else
2689 {
2694 }
2695 }
2696 \f
2697 /* Return nonzero if two operands (typically of the same tree node)
2698 are necessarily equal. FLAGS modifies behavior as follows:
2700 If OEP_ONLY_CONST is set, only return nonzero for constants.
2701 This function tests whether the operands are indistinguishable;
2702 it does not test whether they are equal using C's == operation.
2703 The distinction is important for IEEE floating point, because
2704 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2705 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2707 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2708 even though it may hold multiple values during a function.
2709 This is because a GCC tree node guarantees that nothing else is
2710 executed between the evaluation of its "operands" (which may often
2711 be evaluated in arbitrary order). Hence if the operands themselves
2712 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2713 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2714 unset means assuming isochronic (or instantaneous) tree equivalence.
2715 Unless comparing arbitrary expression trees, such as from different
2716 statements, this flag can usually be left unset.
2718 If OEP_PURE_SAME is set, then pure functions with identical arguments
2719 are considered the same. It is used when the caller has other ways
2720 to ensure that global memory is unchanged in between.
2722 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2723 not values of expressions.
2725 If OEP_LEXICOGRAPHIC is set, then also handle expressions with side-effects
2726 such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
2728 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2729 any operand with side effect. This is unnecesarily conservative in the
2730 case we know that arg0 and arg1 are in disjoint code paths (such as in
2731 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2732 addresses with TREE_CONSTANT flag set so we know that &var == &var
2733 even if var is volatile. */
2735 int
2737 {
2738 /* When checking, verify at the outermost operand_equal_p call that
2739 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2740 hash value. */
2742 {
2744 {
2746 {
2753 }
2755 }
2756 else
2758 }
2760 /* If either is ERROR_MARK, they aren't equal. */
2766 /* Similar, if either does not have a type (like a released SSA name),
2767 they aren't equal. */
2771 /* We cannot consider pointers to different address space equal. */
2778 /* Check equality of integer constants before bailing out due to
2779 precision differences. */
2781 {
2782 /* Address of INTEGER_CST is not defined; check that we did not forget
2783 to drop the OEP_ADDRESS_OF flags. */
2786 }
2789 {
2790 /* If both types don't have the same signedness, then we can't consider
2791 them equal. We must check this before the STRIP_NOPS calls
2792 because they may change the signedness of the arguments. As pointers
2793 strictly don't have a signedness, require either two pointers or
2794 two non-pointers as well. */
2800 /* If both types don't have the same precision, then it is not safe
2801 to strip NOPs. */
2808 }
2809 #if 0
2810 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2811 sanity check once the issue is solved. */
2812 else
2813 /* Addresses of conversions and SSA_NAMEs (and many other things)
2814 are not defined. Check that we did not forget to drop the
2815 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2818 #endif
2820 /* In case both args are comparisons but with different comparison
2821 code, try to swap the comparison operands of one arg to produce
2822 a match and compare that variant. */
2826 {
2834 }
2837 {
2838 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2840 ;
2842 {
2843 /* If we are interested in comparing addresses ignore
2844 MEM_REF wrappings of the base that can appear just for
2845 TBAA reasons. */
2859 }
2860 else
2862 }
2864 /* When not checking adddresses, this is needed for conversions and for
2865 COMPONENT_REF. Might as well play it safe and always test this. */
2872 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2873 We don't care about side effects in that case because the SAVE_EXPR
2874 takes care of that for us. In all other cases, two expressions are
2875 equal if they have no side effects. If we have two identical
2876 expressions with side effects that should be treated the same due
2877 to the only side effects being identical SAVE_EXPR's, that will
2878 be detected in the recursive calls below.
2879 If we are taking an invariant address of two identical objects
2880 they are necessarily equal as well. */
2887 /* Next handle constant cases, those for which we can return 1 even
2888 if ONLY_CONST is set. */
2891 {
2905 {
2906 /* If we do not distinguish between signed and unsigned zero,
2907 consider them equal. */
2910 }
2914 {
2921 {
2925 }
2927 }
2931 flags)
2933 flags));
2944 flags | OEP_ADDRESS_OF
2947 /* In GIMPLE empty constructors are allowed in initializers of
2948 aggregates. */
2952 }
2957 /* Define macros to test an operand from arg0 and arg1 for equality and a
2958 variant that allows null and views null as being different from any
2959 non-null value. In the latter case, if either is null, the both
2960 must be; otherwise, do the normal comparison. */
2961 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2962 TREE_OPERAND (arg1, N), flags)
2964 #define OP_SAME_WITH_NULL(N) \
2965 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2966 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2969 {
2971 /* Two conversions are equal only if signedness and modes match. */
2973 {
2974 CASE_CONVERT:
2982 }
2992 /* For commutative ops, allow the other order. */
3000 /* If either of the pointer (or reference) expressions we are
3001 dereferencing contain a side effect, these cannot be equal,
3002 but their addresses can be. */
3009 {
3019 /* Require the same offset. */
3025 /* Fallthru. */
3033 {
3034 /* Require equal access sizes */
3040 flags)))
3042 /* Verify that access happens in similar types. */
3045 /* Verify that accesses are TBAA compatible. */
3054 /* Verify that alignment is compatible. */
3058 }
3061 /* TARGET_MEM_REF require equal extra operands. */
3072 /* Compare the array index by value if it is constant first as we
3073 may have different types but same value here. */
3079 /* Compare low bound and element size as with OEP_ADDRESS_OF
3080 we have to account for the offset of the ref. */
3085 array_ref_low_bound
3089 array_ref_element_size
3091 flags))));
3094 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3095 may be NULL when we're called to compare MEM_EXPRs. */
3110 }
3114 {
3116 /* Be sure we pass right ADDRESS_OF flag. */
3134 /* The multiplcation operands are commutative. */
3135 /* FALLTHRU */
3143 /* Otherwise take into account this is a commutative operation. */
3179 }
3183 {
3187 /* If not both CALL_EXPRs are either internal or normal function
3188 functions, then they are not equal. */
3191 {
3192 /* If the CALL_EXPRs call different internal functions, then they
3193 are not equal. */
3196 }
3197 else
3198 {
3199 /* If the CALL_EXPRs call different functions, then they are not
3200 equal. */
3202 flags))
3204 }
3206 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3207 {
3211 else
3215 }
3217 /* Now see if all the arguments are the same. */
3218 {
3229 /* If we get here and both argument lists are exhausted
3230 then the CALL_EXPRs are equal. */
3232 }
3235 }
3238 /* Consider __builtin_sqrt equal to sqrt. */
3246 {
3247 /* In GIMPLE constructors are used only to build vectors from
3248 elements. Individual elements in the constructor must be
3249 indexed in increasing order and form an initial sequence.
3251 We make no effort to compare constructors in generic.
3252 (see sem_variable::equals in ipa-icf which can do so for
3253 constants). */
3258 /* Be sure that vectors constructed have the same representation.
3259 We only tested element precision and modes to match.
3260 Vectors may be BLKmode and thus also check that the number of
3261 parts match. */
3274 {
3279 /* In GIMPLE the indexes can be either NULL or matching i.
3280 Double check this so we won't get false
3281 positives for GENERIC. */
3289 }
3291 }
3294 {
3295 /* Compare the STATEMENT_LISTs. */
3301 {
3302 /* The lists don't have the same number of statements. */
3308 OEP_LEXICOGRAPHIC))
3310 }
3311 }
3316 {
3323 }
3327 }
3329 #undef OP_SAME
3330 #undef OP_SAME_WITH_NULL
3331 }
3332 \f
3333 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3334 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3336 When in doubt, return 0. */
3338 static int
3340 {
3352 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3353 and see if the inner values are the same. This removes any
3354 signedness comparison, which doesn't matter here. */
3361 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3362 actual comparison operand, ARG0.
3364 First throw away any conversions to wider types
3365 already present in the operands. */
3374 {
3377 /* Make sure shorter operand is extended the right way
3378 to match the longer operand. */
3384 }
3387 }
3388 \f
3389 /* See if ARG is an expression that is either a comparison or is performing
3390 arithmetic on comparisons. The comparisons must only be comparing
3391 two different values, which will be stored in *CVAL1 and *CVAL2; if
3392 they are nonzero it means that some operands have already been found.
3393 No variables may be used anywhere else in the expression except in the
3394 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3395 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3397 If this is true, return 1. Otherwise, return zero. */
3399 static int
3401 {
3405 /* We can handle some of the tcc_expression cases here. */
3415 {
3416 /* If we've already found a CVAL1 or CVAL2, this expression is
3417 two complex to handle. */
3423 }
3426 {
3449 /* First see if we can handle the first operand, then the second. For
3450 the second operand, we know *CVAL1 can't be zero. It must be that
3451 one side of the comparison is each of the values; test for the
3452 case where this isn't true by failing if the two operands
3453 are the same. */
3462 ;
3466 ;
3467 else
3471 ;
3475 ;
3476 else
3483 }
3484 }
3485 \f
3486 /* ARG is a tree that is known to contain just arithmetic operations and
3487 comparisons. Evaluate the operations in the tree substituting NEW0 for
3488 any occurrence of OLD0 as an operand of a comparison and likewise for
3489 NEW1 and OLD1. */
3491 static tree
3494 {
3499 /* We can handle some of the tcc_expression cases here. */
3507 {
3522 {
3541 }
3542 /* Fall through - ??? */
3545 {
3549 /* We need to check both for exact equality and tree equality. The
3550 former will be true if the operand has a side-effect. In that
3551 case, we know the operand occurred exactly once. */
3564 }
3568 }
3569 }
3570 \f
3571 /* Return a tree for the case when the result of an expression is RESULT
3572 converted to TYPE and OMITTED was previously an operand of the expression
3573 but is now not needed (e.g., we folded OMITTED * 0).
3575 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3576 the conversion of RESULT to TYPE. */
3578 tree
3580 {
3583 /* If the resulting operand is an empty statement, just return the omitted
3584 statement casted to void. */
3594 }
3596 /* Return a tree for the case when the result of an expression is RESULT
3597 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3598 of the expression but are now not needed.
3600 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3601 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3602 evaluated before OMITTED2. Otherwise, if neither has side effects,
3603 just do the conversion of RESULT to TYPE. */
3605 tree
3608 {
3617 }
3619 \f
3620 /* Return a simplified tree node for the truth-negation of ARG. This
3621 never alters ARG itself. We assume that ARG is an operation that
3622 returns a truth value (0 or 1).
3624 FIXME: one would think we would fold the result, but it causes
3625 problems with the dominator optimizer. */
3627 static tree
3629 {
3634 /* If this is a comparison, we can simply invert it, except for
3635 floating-point non-equality comparisons, in which case we just
3636 enclose a TRUTH_NOT_EXPR around what we have. */
3639 {
3642 && flag_trapping_math
3656 }
3659 {
3678 /* Here we can invert either operand. We invert the first operand
3679 unless the second operand is a TRUTH_NOT_EXPR in which case our
3680 result is the XOR of the first operand with the inside of the
3681 negation of the second operand. */
3686 else
3709 {
3716 /* A COND_EXPR may have a throw as one operand, which
3717 then has void type. Just leave void operands
3718 as they are. */
3724 }
3736 CASE_CONVERT:
3740 /* fall through */
3762 }
3763 }
3765 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3766 assume that ARG is an operation that returns a truth value (0 or 1
3767 for scalars, 0 or -1 for vectors). Return the folded expression if
3768 folding is successful. Otherwise, return NULL_TREE. */
3770 static tree
3772 {
3775 ? BIT_NOT_EXPR
3778 }
3780 /* Return a simplified tree node for the truth-negation of ARG. This
3781 never alters ARG itself. We assume that ARG is an operation that
3782 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3784 tree
3786 {
3792 ? BIT_NOT_EXPR
3795 }
3797 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3798 with code CODE. This optimization is unsafe. */
3799 static tree
3802 {
3806 /* (A / C) +- (B / C) -> (A +- B) / C. */
3816 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3821 {
3833 }
3836 }
3837 \f
3838 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3839 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3840 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3841 is the original memory reference used to preserve the alias set of
3842 the access. */
3844 static tree
3848 {
3858 {
3865 }
3880 }
3882 /* Optimize a bit-field compare.
3884 There are two cases: First is a compare against a constant and the
3885 second is a comparison of two items where the fields are at the same
3886 bit position relative to the start of a chunk (byte, halfword, word)
3887 large enough to contain it. In these cases we can avoid the shift
3888 implicit in bitfield extractions.
3890 For constants, we emit a compare of the shifted constant with the
3891 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3892 compared. For two fields at the same position, we do the ANDs with the
3893 similar mask and compare the result of the ANDs.
3895 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3896 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3897 are the left and right operands of the comparison, respectively.
3899 If the optimization described above can be done, we return the resulting
3900 tree. Otherwise we return zero. */
3902 static tree
3905 {
3908 tree unsigned_type;
3915 tree mask;
3916 tree offset;
3918 /* Get all the information about the extractions being done. If the bit size
3919 if the same as the size of the underlying object, we aren't doing an
3920 extraction at all and so can do nothing. We also don't want to
3921 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3922 then will no longer be able to replace it. */
3931 else
3932 {
3933 /* If this is not a constant, we can only do something if bit positions,
3934 sizes, signedness and storage order are the same. */
3935 rinner
3943 }
3945 /* Honor the C++ memory model and mimic what RTL expansion does. */
3949 {
3953 }
3955 /* See if we can find a mode to refer to this field. We should be able to,
3956 but fail if we can't. */
3965 /* Set signed and unsigned types of the precision of this mode for the
3966 shifts below. */
3969 /* Compute the bit position and size for the new reference and our offset
3970 within it. If the new reference is the same size as the original, we
3971 won't optimize anything, so return zero. */
3981 /* Make the mask to be used against the extracted field. */
3988 /* If not comparing with constant, just rework the comparison
3989 and return. */
3993 unsigned_type,
3996 mask),
3999 unsigned_type,
4002 mask));
4004 /* Otherwise, we are handling the constant case. See if the constant is too
4005 big for the field. Warn and return a tree for 0 (false) if so. We do
4006 this not only for its own sake, but to avoid having to test for this
4007 error case below. If we didn't, we might generate wrong code.
4009 For unsigned fields, the constant shifted right by the field length should
4010 be all zero. For signed fields, the high-order bits should agree with
4011 the sign bit. */
4014 {
4016 {
4020 }
4021 }
4022 else
4023 {
4026 {
4030 }
4031 }
4033 /* Single-bit compares should always be against zero. */
4035 {
4038 }
4040 /* Make a new bitfield reference, shift the constant over the
4041 appropriate number of bits and mask it with the computed mask
4042 (in case this was a signed field). If we changed it, make a new one. */
4050 mask);
4055 }
4056 \f
4057 /* Subroutine for fold_truth_andor_1: decode a field reference.
4059 If EXP is a comparison reference, we return the innermost reference.
4061 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4062 set to the starting bit number.
4064 If the innermost field can be completely contained in a mode-sized
4065 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4067 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4068 otherwise it is not changed.
4070 *PUNSIGNEDP is set to the signedness of the field.
4072 *PREVERSEP is set to the storage order of the field.
4074 *PMASK is set to the mask used. This is either contained in a
4075 BIT_AND_EXPR or derived from the width of the field.
4077 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4079 Return 0 if this is not a component reference or is one that we can't
4080 do anything with. */
4082 static tree
4087 {
4092 tree unsigned_type;
4095 /* All the optimizations using this function assume integer fields.
4096 There are problems with FP fields since the type_for_size call
4097 below can fail for, e.g., XFmode. */
4101 /* We are interested in the bare arrangement of bits, so strip everything
4102 that doesn't affect the machine mode. However, record the type of the
4103 outermost expression if it may matter below. */
4110 {
4116 }
4127 /* If the number of bits in the reference is the same as the bitsize of
4128 the outer type, then the outer type gives the signedness. Otherwise
4129 (in case of a small bitfield) the signedness is unchanged. */
4133 /* Compute the mask to access the bitfield. */
4142 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4150 }
4152 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4153 bit positions and MASK is SIGNED. */
4155 static int
4157 {
4161 /* If this function returns true when the type of the mask is
4162 UNSIGNED, then there will be errors. In particular see
4163 gcc.c-torture/execute/990326-1.c. There does not appear to be
4164 any documentation paper trail as to why this is so. But the pre
4165 wide-int worked with that restriction and it has been preserved
4166 here. */
4171 }
4173 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4174 represents the sign bit of EXP's type. If EXP represents a sign
4175 or zero extension, also test VAL against the unextended type.
4176 The return value is the (sub)expression whose sign bit is VAL,
4177 or NULL_TREE otherwise. */
4179 tree
4181 {
4183 tree t;
4185 /* Tree EXP must have an integral type. */
4190 /* Tree VAL must be an integer constant. */
4199 /* Handle extension from a narrower type. */
4205 }
4207 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4208 to be evaluated unconditionally. */
4210 static int
4212 {
4213 /* Strip any conversions that don't change the machine mode. */
4222 /* Don't regard global variables as simple. They may be
4223 allocated in ways unknown to the compiler (shared memory,
4224 #pragma weak, etc). */
4227 /* Weakrefs are not safe to be read, since they can be NULL.
4228 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4229 have DECL_WEAK flag set. */
4231 /* Loading a static variable is unduly expensive, but global
4232 registers aren't expensive. */
4234 }
4236 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4237 to be evaluated unconditionally.
4238 I addition to simple_operand_p, we assume that comparisons, conversions,
4239 and logic-not operations are simple, if their operands are simple, too. */
4241 static bool
4243 {
4263 }
4265 \f
4266 /* The following functions are subroutines to fold_range_test and allow it to
4267 try to change a logical combination of comparisons into a range test.
4269 For example, both
4270 X == 2 || X == 3 || X == 4 || X == 5
4271 and
4272 X >= 2 && X <= 5
4273 are converted to
4274 (unsigned) (X - 2) <= 3
4276 We describe each set of comparisons as being either inside or outside
4277 a range, using a variable named like IN_P, and then describe the
4278 range with a lower and upper bound. If one of the bounds is omitted,
4279 it represents either the highest or lowest value of the type.
4281 In the comments below, we represent a range by two numbers in brackets
4282 preceded by a "+" to designate being inside that range, or a "-" to
4283 designate being outside that range, so the condition can be inverted by
4284 flipping the prefix. An omitted bound is represented by a "-". For
4285 example, "- [-, 10]" means being outside the range starting at the lowest
4286 possible value and ending at 10, in other words, being greater than 10.
4287 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4288 always false.
4290 We set up things so that the missing bounds are handled in a consistent
4291 manner so neither a missing bound nor "true" and "false" need to be
4292 handled using a special case. */
4294 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4295 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4296 and UPPER1_P are nonzero if the respective argument is an upper bound
4297 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4298 must be specified for a comparison. ARG1 will be converted to ARG0's
4299 type if both are specified. */
4301 static tree
4304 {
4305 tree tem;
4309 /* If neither arg represents infinity, do the normal operation.
4310 Else, if not a comparison, return infinity. Else handle the special
4311 comparison rules. Note that most of the cases below won't occur, but
4312 are handled for consistency. */
4315 {
4320 }
4325 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4326 for neither. In real maths, we cannot assume open ended ranges are
4327 the same. But, this is computer arithmetic, where numbers are finite.
4328 We can therefore make the transformation of any unbounded range with
4329 the value Z, Z being greater than any representable number. This permits
4330 us to treat unbounded ranges as equal. */
4334 {
4355 }
4358 }
4359 \f
4360 /* Helper routine for make_range. Perform one step for it, return
4361 new expression if the loop should continue or NULL_TREE if it should
4362 stop. */
4364 tree
4368 {
4374 {
4376 /* We can only do something if the range is testing for zero. */
4385 /* We can only do something if the range is testing for zero
4386 and if the second operand is an integer constant. Note that
4387 saying something is "in" the range we make is done by
4388 complementing IN_P since it will set in the initial case of
4389 being not equal to zero; "out" is leaving it alone. */
4396 {
4417 }
4419 /* If this is an unsigned comparison, we also know that EXP is
4420 greater than or equal to zero. We base the range tests we make
4421 on that fact, so we record it here so we can parse existing
4422 range tests. We test arg0_type since often the return type
4423 of, e.g. EQ_EXPR, is boolean. */
4425 {
4429 NULL_TREE))
4434 /* If the high bound is missing, but we have a nonzero low
4435 bound, reverse the range so it goes from zero to the low bound
4436 minus 1. */
4438 {
4443 }
4444 }
4452 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4453 low and high are non-NULL, then normalize will DTRT. */
4456 {
4461 }
4463 /* (-x) IN [a,b] -> x in [-b, -a] */
4475 /* ~ X -> -X - 1 */
4484 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4485 move a constant to the other side. */
4490 /* If EXP is signed, any overflow in the computation is undefined,
4491 so we don't worry about it so long as our computations on
4492 the bounds don't overflow. For unsigned, overflow is defined
4493 and this is exactly the right thing. */
4505 normalize:
4506 /* Check for an unsigned range which has wrapped around the maximum
4507 value thus making n_high < n_low, and normalize it. */
4509 {
4515 /* If the range is of the form +/- [ x+1, x ], we won't
4516 be able to normalize it. But then, it represents the
4517 whole range or the empty set, so make it
4518 +/- [ -, - ]. */
4522 else
4524 }
4525 else
4533 CASE_CONVERT:
4551 /* If we're converting arg0 from an unsigned type, to exp,
4552 a signed type, we will be doing the comparison as unsigned.
4553 The tests above have already verified that LOW and HIGH
4554 are both positive.
4556 So we have to ensure that we will handle large unsigned
4557 values the same way that the current signed bounds treat
4558 negative values. */
4561 {
4562 tree high_positive;
4563 tree equiv_type;
4564 /* For fixed-point modes, we need to pass the saturating flag
4565 as the 2nd parameter. */
4567 equiv_type
4570 else
4571 equiv_type
4574 /* A range without an upper bound is, naturally, unbounded.
4575 Since convert would have cropped a very large value, use
4576 the max value for the destination type. */
4577 high_positive
4584 high_positive),
4587 /* If the low bound is specified, "and" the range with the
4588 range for which the original unsigned value will be
4589 positive. */
4591 {
4594 integer_zero_node),
4595 high_positive))
4599 }
4600 else
4601 {
4602 /* Otherwise, "or" the range with the range of the input
4603 that will be interpreted as negative. */
4606 integer_zero_node),
4607 high_positive))
4611 }
4612 }
4621 }
4622 }
4624 /* Given EXP, a logical expression, set the range it is testing into
4625 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4626 actually being tested. *PLOW and *PHIGH will be made of the same
4627 type as the returned expression. If EXP is not a comparison, we
4628 will most likely not be returning a useful value and range. Set
4629 *STRICT_OVERFLOW_P to true if the return value is only valid
4630 because signed overflow is undefined; otherwise, do not change
4631 *STRICT_OVERFLOW_P. */
4633 tree
4636 {
4644 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4645 and see if we can refine the range. Some of the cases below may not
4646 happen, but it doesn't seem worth worrying about this. We "continue"
4647 the outer loop when we've changed something; otherwise we "break"
4648 the switch, which will "break" the while. */
4654 {
4660 {
4668 }
4677 }
4679 /* If EXP is a constant, we can evaluate whether this is true or false. */
4681 {
4688 }
4692 }
4693 \f
4694 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4695 type, TYPE, return an expression to test if EXP is in (or out of, depending
4696 on IN_P) the range. Return 0 if the test couldn't be created. */
4698 tree
4701 {
4704 /* Disable this optimization for function pointer expressions
4705 on targets that require function pointer canonicalization. */
4712 {
4718 }
4736 {
4738 {
4742 }
4744 }
4746 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4748 {
4752 {
4754 {
4757 etype
4759 else
4762 }
4765 }
4766 }
4768 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4769 This requires wrap-around arithmetics for the type of the expression.
4770 First make sure that arithmetics in this type is valid, then make sure
4771 that it wraps around. */
4777 {
4780 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4781 for the type in question, as we rely on this here. */
4791 else
4793 }
4803 {
4805 {
4810 }
4812 }
4820 }
4821 \f
4822 /* Return the predecessor of VAL in its type, handling the infinite case. */
4824 static tree
4826 {
4832 else
4835 }
4837 /* Return the successor of VAL in its type, handling the infinite case. */
4839 static tree
4841 {
4847 else
4850 }
4852 /* Given two ranges, see if we can merge them into one. Return 1 if we
4853 can, 0 if we can't. Set the output range into the specified parameters. */
4855 bool
4858 {
4862 tree tem;
4872 /* Make range 0 be the range that starts first, or ends last if they
4873 start at the same value. Swap them if it isn't. */
4876 || (lowequal
4879 {
4883 }
4885 /* Now flag two cases, whether the ranges are disjoint or whether the
4886 second range is totally subsumed in the first. Note that the tests
4887 below are simplified by the ones above. */
4893 /* We now have four cases, depending on whether we are including or
4894 excluding the two ranges. */
4896 {
4897 /* If they don't overlap, the result is false. If the second range
4898 is a subset it is the result. Otherwise, the range is from the start
4899 of the second to the end of the first. */
4904 else
4906 }
4909 {
4910 /* If they don't overlap, the result is the first range. If they are
4911 equal, the result is false. If the second range is a subset of the
4912 first, and the ranges begin at the same place, we go from just after
4913 the end of the second range to the end of the first. If the second
4914 range is not a subset of the first, or if it is a subset and both
4915 ranges end at the same place, the range starts at the start of the
4916 first range and ends just before the second range.
4917 Otherwise, we can't describe this as a single range. */
4923 {
4928 {
4929 /* We are in the weird situation where high0 > high1 but
4930 high1 has no successor. Punt. */
4932 }
4933 }
4935 {
4940 {
4941 /* low0 < low1 but low1 has no predecessor. Punt. */
4943 }
4944 }
4945 else
4947 }
4950 {
4951 /* If they don't overlap, the result is the second range. If the second
4952 is a subset of the first, the result is false. Otherwise,
4953 the range starts just after the first range and ends at the
4954 end of the second. */
4959 else
4960 {
4965 {
4966 /* high1 > high0 but high0 has no successor. Punt. */
4968 }
4969 }
4970 }
4972 else
4973 {
4974 /* The case where we are excluding both ranges. Here the complex case
4975 is if they don't overlap. In that case, the only time we have a
4976 range is if they are adjacent. If the second is a subset of the
4977 first, the result is the first. Otherwise, the range to exclude
4978 starts at the beginning of the first range and ends at the end of the
4979 second. */
4981 {
4986 else
4987 {
4988 /* Canonicalize - [min, x] into - [-, x]. */
4991 {
4996 /* FALLTHROUGH */
5009 }
5011 /* Canonicalize - [x, max] into - [x, -]. */
5014 {
5019 /* FALLTHROUGH */
5035 }
5037 /* The ranges might be also adjacent between the maximum and
5038 minimum values of the given type. For
5039 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5040 return + [x + 1, y - 1]. */
5042 {
5049 }
5050 else
5052 }
5053 }
5056 else
5058 }
5062 }
5063 \f
5065 /* Subroutine of fold, looking inside expressions of the form
5066 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5067 of the COND_EXPR. This function is being used also to optimize
5068 A op B ? C : A, by reversing the comparison first.
5070 Return a folded expression whose code is not a COND_EXPR
5071 anymore, or NULL_TREE if no folding opportunity is found. */
5073 static tree
5076 {
5081 tree tem;
5086 /* If we have A op 0 ? A : -A, consider applying the following
5087 transformations:
5089 A == 0? A : -A same as -A
5090 A != 0? A : -A same as A
5091 A >= 0? A : -A same as abs (A)
5092 A > 0? A : -A same as abs (A)
5093 A <= 0? A : -A same as -abs (A)
5094 A < 0? A : -A same as -abs (A)
5096 None of these transformations work for modes with signed
5097 zeros. If A is +/-0, the first two transformations will
5098 change the sign of the result (from +0 to -0, or vice
5099 versa). The last four will fix the sign of the result,
5100 even though the original expressions could be positive or
5101 negative, depending on the sign of A.
5103 Note that all these transformations are correct if A is
5104 NaN, since the two alternatives (A and -A) are also NaNs. */
5111 /* In the case that A is of the form X-Y, '-A' (arg2) may
5112 have already been folded to Y-X, check for that. */
5120 {
5132 /* Fall through. */
5143 /* FALLTHRU */
5153 }
5155 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5156 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5157 both transformations are correct when A is NaN: A != 0
5158 is then true, and A == 0 is false. */
5162 {
5167 }
5169 /* Try some transformations of A op B ? A : B.
5171 A == B? A : B same as B
5172 A != B? A : B same as A
5173 A >= B? A : B same as max (A, B)
5174 A > B? A : B same as max (B, A)
5175 A <= B? A : B same as min (A, B)
5176 A < B? A : B same as min (B, A)
5178 As above, these transformations don't work in the presence
5179 of signed zeros. For example, if A and B are zeros of
5180 opposite sign, the first two transformations will change
5181 the sign of the result. In the last four, the original
5182 expressions give different results for (A=+0, B=-0) and
5183 (A=-0, B=+0), but the transformed expressions do not.
5185 The first two transformations are correct if either A or B
5186 is a NaN. In the first transformation, the condition will
5187 be false, and B will indeed be chosen. In the case of the
5188 second transformation, the condition A != B will be true,
5189 and A will be chosen.
5191 The conversions to max() and min() are not correct if B is
5192 a number and A is not. The conditions in the original
5193 expressions will be false, so all four give B. The min()
5194 and max() versions would give a NaN instead. */
5197 /* Avoid these transformations if the COND_EXPR may be used
5198 as an lvalue in the C++ front-end. PR c++/19199. */
5199 && (in_gimple_form
5205 {
5211 {
5220 /* In C++ a ?: expression can be an lvalue, so put the
5221 operand which will be used if they are equal first
5222 so that we can convert this back to the
5223 corresponding COND_EXPR. */
5225 {
5233 }
5240 {
5248 }
5261 }
5262 }
5265 }
5268 \f
5269 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5270 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5271 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5272 false) >= 2)
5273 #endif
5275 /* EXP is some logical combination of boolean tests. See if we can
5276 merge it into some range test. Return the new tree if so. */
5278 static tree
5281 {
5297 /* If this is an OR operation, invert both sides; we will invert
5298 again at the end. */
5302 /* If both expressions are the same, if we can merge the ranges, and we
5303 can build the range test, return it or it inverted. If one of the
5304 ranges is always true or always false, consider it to be the same
5305 expression as the other. */
5313 {
5317 }
5319 /* On machines where the branch cost is expensive, if this is a
5320 short-circuited branch and the underlying object on both sides
5321 is the same, make a non-short-circuit operation. */
5327 {
5328 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5329 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5330 which cases we can't do this. */
5338 {
5347 {
5350 WARN_STRICT_OVERFLOW_COMPARISON);
5354 }
5355 }
5356 }
5359 }
5360 \f
5361 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5362 bit value. Arrange things so the extra bits will be set to zero if and
5363 only if C is signed-extended to its full width. If MASK is nonzero,
5364 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5366 static tree
5368 {
5371 tree temp;
5376 /* We work by getting just the sign bit into the low-order bit, then
5377 into the high-order bit, then sign-extend. We then XOR that value
5378 with C. */
5381 /* We must use a signed type in order to get an arithmetic right shift.
5382 However, we must also avoid introducing accidental overflows, so that
5383 a subsequent call to integer_zerop will work. Hence we must
5384 do the type conversion here. At this point, the constant is either
5385 zero or one, and the conversion to a signed type can never overflow.
5386 We could get an overflow if this conversion is done anywhere else. */
5395 /* If necessary, convert the type back to match the type of C. */
5400 }
5401 \f
5402 /* For an expression that has the form
5403 (A && B) || ~B
5404 or
5405 (A || B) && ~B,
5406 we can drop one of the inner expressions and simplify to
5407 A || ~B
5408 or
5409 A && ~B
5410 LOC is the location of the resulting expression. OP is the inner
5411 logical operation; the left-hand side in the examples above, while CMPOP
5412 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5413 removing a condition that guards another, as in
5414 (A != NULL && A->...) || A == NULL
5415 which we must not transform. If RHS_ONLY is true, only eliminate the
5416 right-most operand of the inner logical operation. */
5418 static tree
5421 {
5439 {
5442 {
5445 }
5446 }
5448 {
5451 {
5454 }
5455 }
5470 }
5472 /* Find ways of folding logical expressions of LHS and RHS:
5473 Try to merge two comparisons to the same innermost item.
5474 Look for range tests like "ch >= '0' && ch <= '9'".
5475 Look for combinations of simple terms on machines with expensive branches
5476 and evaluate the RHS unconditionally.
5478 For example, if we have p->a == 2 && p->b == 4 and we can make an
5479 object large enough to span both A and B, we can do this with a comparison
5480 against the object ANDed with the a mask.
5482 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5483 operations to do this with one comparison.
5485 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5486 function and the one above.
5488 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5489 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5491 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5492 two operands.
5494 We return the simplified tree or 0 if no optimization is possible. */
5496 static tree
5499 {
5500 /* If this is the "or" of two comparisons, we can do something if
5501 the comparisons are NE_EXPR. If this is the "and", we can do something
5502 if the comparisons are EQ_EXPR. I.e.,
5503 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5505 WANTED_CODE is this operation code. For single bit fields, we can
5506 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5507 comparison for one-bit fields. */
5528 /* Start by getting the comparison codes. Fail if anything is volatile.
5529 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5530 it were surrounded with a NE_EXPR. */
5539 {
5543 }
5546 {
5550 }
5561 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5564 {
5567 {
5572 }
5575 {
5581 }
5582 }
5587 /* If the RHS can be evaluated unconditionally and its operands are
5588 simple, it wins to evaluate the RHS unconditionally on machines
5589 with expensive branches. In this case, this isn't a comparison
5590 that can be merged. */
5597 {
5598 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5609 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5619 }
5621 /* See if the comparisons can be merged. Then get all the parameters for
5622 each side. */
5647 /* It must be true that the inner operation on the lhs of each
5648 comparison must be the same if we are to be able to do anything.
5649 Then see if we have constants. If not, the same must be true for
5650 the rhs's. */
5659 {
5662 }
5667 else
5670 /* If either comparison code is not correct for our logical operation,
5671 fail. However, we can convert a one-bit comparison against zero into
5672 the opposite comparison against that bit being set in the field. */
5676 {
5678 {
5679 /* Make the left operand unsigned, since we are only interested
5680 in the value of one bit. Otherwise we are doing the wrong
5681 thing below. */
5684 }
5685 else
5687 }
5689 /* This is analogous to the code for l_const above. */
5691 {
5693 {
5696 }
5697 else
5699 }
5701 /* See if we can find a mode that contains both fields being compared on
5702 the left. If we can't, fail. Otherwise, update all constants and masks
5703 to be relative to a field of that size. */
5708 volatilep);
5718 {
5721 }
5729 {
5736 {
5740 }
5741 }
5743 {
5750 {
5754 }
5755 }
5757 /* If the right sides are not constant, do the same for it. Also,
5758 disallow this optimization if a size or signedness mismatch occurs
5759 between the left and right sides. */
5761 {
5764 /* Make sure the two fields on the right
5765 correspond to the left without being swapped. */
5773 volatilep);
5783 {
5786 }
5795 /* Make a mask that corresponds to both fields being compared.
5796 Do this for both items being compared. If the operands are the
5797 same size and the bits being compared are in the same position
5798 then we can do this by masking both and comparing the masked
5799 results. */
5803 {
5817 }
5819 /* There is still another way we can do something: If both pairs of
5820 fields being compared are adjacent, we may be able to make a wider
5821 field containing them both.
5823 Note that we still must mask the lhs/rhs expressions. Furthermore,
5824 the mask must be shifted to account for the shift done by
5825 make_bit_field_ref. */
5830 {
5831 tree type;
5847 /* Convert to the smaller type before masking out unwanted bits. */
5850 {
5852 {
5856 }
5858 {
5862 }
5863 }
5872 }
5875 }
5877 /* Handle the case of comparisons with constants. If there is something in
5878 common between the masks, those bits of the constants must be the same.
5879 If not, the condition is always false. Test for this to avoid generating
5880 incorrect code below. */
5885 {
5887 {
5890 }
5891 else
5892 {
5895 }
5896 }
5898 /* Construct the expression we will return. First get the component
5899 reference we will make. Unless the mask is all ones the width of
5900 that field, perform the mask operation. Then compare with the
5901 merged constant. */
5912 }
5913 \f
5914 /* T is an integer expression that is being multiplied, divided, or taken a
5915 modulus (CODE says which and what kind of divide or modulus) by a
5916 constant C. See if we can eliminate that operation by folding it with
5917 other operations already in T. WIDE_TYPE, if non-null, is a type that
5918 should be used for the computation if wider than our type.
5920 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5921 (X * 2) + (Y * 4). We must, however, be assured that either the original
5922 expression would not overflow or that overflow is undefined for the type
5923 in the language in question.
5925 If we return a non-null expression, it is an equivalent form of the
5926 original computation, but need not be in the original type.
5928 We set *STRICT_OVERFLOW_P to true if the return values depends on
5929 signed overflow being undefined. Otherwise we do not change
5930 *STRICT_OVERFLOW_P. */
5932 static tree
5935 {
5936 /* To avoid exponential search depth, refuse to allow recursion past
5937 three levels. Beyond that (1) it's highly unlikely that we'll find
5938 something interesting and (2) we've probably processed it before
5939 when we built the inner expression. */
5942 tree ret;
5947 depth++;
5949 depth--;
5952 }
5954 static tree
5957 {
5968 /* Don't deal with constants of zero here; they confuse the code below. */
5978 /* Note that we need not handle conditional operations here since fold
5979 already handles those cases. So just do arithmetic here. */
5981 {
5983 /* For a constant, we can always simplify if we are a multiply
5984 or (for divide and modulus) if it is a multiple of our constant. */
5987 {
5990 /* If the multiplication overflowed, we lost information on it.
5991 See PR68142 and PR69845. */
5995 }
5999 /* If op0 is an expression ... */
6005 /* ... and has wrapping overflow, and its type is smaller
6006 than ctype, then we cannot pass through as widening. */
6011 /* ... or this is a truncation (t is narrower than op0),
6012 then we cannot pass through this narrowing. */
6015 /* ... or signedness changes for division or modulus,
6016 then we cannot pass through this conversion. */
6020 /* ... or has undefined overflow while the converted to
6021 type has not, we cannot do the operation in the inner type
6022 as that would introduce undefined overflow. */
6028 /* Pass the constant down and see if we can make a simplification. If
6029 we can, replace this expression with the inner simplification for
6030 possible later conversion to our or some other type. */
6035 code == MULT_EXPR
6037 strict_overflow_p))))
6042 /* If widening the type changes it from signed to unsigned, then we
6043 must avoid building ABS_EXPR itself as unsigned. */
6045 {
6049 {
6052 }
6054 }
6055 /* If the constant is negative, we cannot simplify this. */
6058 /* FALLTHROUGH */
6060 /* For division and modulus, type can't be unsigned, as e.g.
6061 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6062 For signed types, even with wrapping overflow, this is fine. */
6071 /* If widening the type changes the signedness, then we can't perform
6072 this optimization as that changes the result. */
6076 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6082 {
6089 }
6093 /* If the second operand is constant, this is a multiplication
6094 or floor division, by a power of two, so we can treat it that
6095 way unless the multiplier or divisor overflows. Signed
6096 left-shift overflow is implementation-defined rather than
6097 undefined in C90, so do not convert signed left shift into
6098 multiplication. */
6101 /* const_binop may not detect overflow correctly,
6102 so check for it explicitly here. */
6106 size_one_node,
6107 op1)))
6111 ctype,
6113 t1),
6118 /* See if we can eliminate the operation on both sides. If we can, we
6119 can return a new PLUS or MINUS. If we can't, the only remaining
6120 cases where we can do anything are if the second operand is a
6121 constant. */
6127 /* If not multiplication, we can only do this if both operands
6128 are divisible by c. */
6131 {
6136 }
6138 /* If this was a subtraction, negate OP1 and set it to be an addition.
6139 This simplifies the logic below. */
6141 {
6143 /* If OP1 was not easily negatable, the constant may be OP0. */
6145 {
6148 }
6149 }
6154 /* If either OP1 or C are negative, this optimization is not safe for
6155 some of the division and remainder types while for others we need
6156 to change the code. */
6158 {
6166 }
6168 /* If it's a multiply or a division/modulus operation of a multiple
6169 of our constant, do the operation and verify it doesn't overflow. */
6172 {
6175 /* We allow the constant to overflow with wrapping semantics. */
6179 }
6180 else
6183 /* If we have an unsigned type, we cannot widen the operation since it
6184 will change the result if the original computation overflowed. */
6188 /* If we were able to eliminate our operation from the first side,
6189 apply our operation to the second side and reform the PLUS. */
6193 /* The last case is if we are a multiply. In that case, we can
6194 apply the distributive law to commute the multiply and addition
6195 if the multiplication of the constants doesn't overflow
6196 and overflow is defined. With undefined overflow
6197 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6203 op1);
6208 /* We have a special case here if we are doing something like
6209 (C * 8) % 4 since we know that's zero. */
6212 /* If the multiplication can overflow we cannot optimize this. */
6216 {
6219 }
6221 /* ... fall through ... */
6225 /* If we can extract our operation from the LHS, do so and return a
6226 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6227 do something only if the second operand is a constant. */
6241 /* If these are the same operation types, we can associate them
6242 assuming no overflow. */
6244 {
6259 }
6261 /* If these operations "cancel" each other, we have the main
6262 optimizations of this pass, which occur when either constant is a
6263 multiple of the other, in which case we replace this with either an
6264 operation or CODE or TCODE.
6266 If we have an unsigned type, we cannot do this since it will change
6267 the result if the original computation overflowed. */
6274 {
6276 {
6283 }
6285 {
6292 }
6293 }
6298 }
6301 }
6302 \f
6303 /* Return a node which has the indicated constant VALUE (either 0 or
6304 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6305 and is of the indicated TYPE. */
6307 tree
6309 {
6318 else
6320 }
6323 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6324 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6325 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6326 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6327 COND is the first argument to CODE; otherwise (as in the example
6328 given here), it is the second argument. TYPE is the type of the
6329 original expression. Return NULL_TREE if no simplification is
6330 possible. */
6332 static tree
6337 {
6347 {
6351 /* If this operand throws an expression, then it does not make
6352 sense to try to perform a logical or arithmetic operation
6353 involving it. */
6358 }
6361 {
6366 }
6367 else
6368 /* Detect the case of mixing vector and scalar types - bail out. */
6374 /* This transformation is only worthwhile if we don't have to wrap ARG
6375 in a SAVE_EXPR and the operation can be simplified without recursing
6376 on at least one of the branches once its pushed inside the COND_EXPR. */
6385 {
6389 else
6391 }
6393 {
6397 else
6399 }
6401 /* Check that we have simplified at least one of the branches. */
6406 }
6408 \f
6409 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6411 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6412 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6413 ADDEND is the same as X.
6415 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6416 and finite. The problematic cases are when X is zero, and its mode
6417 has signed zeros. In the case of rounding towards -infinity,
6418 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6419 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6421 bool
6423 {
6427 /* Don't allow the fold with -fsignaling-nans. */
6431 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6435 /* In a vector or complex, we would need to check the sign of all zeros. */
6439 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6443 /* The mode has signed zeros, and we have to honor their sign.
6444 In this situation, there is only one case we can return true for.
6445 X - 0 is the same as X unless rounding towards -infinity is
6446 supported. */
6448 }
6450 /* Subroutine of fold() that optimizes comparisons of a division by
6451 a nonzero integer constant against an integer constant, i.e.
6452 X/C1 op C2.
6454 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6455 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6456 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6458 The function returns the constant folded tree if a simplification
6459 can be made, and NULL_TREE otherwise. */
6461 static tree
6464 {
6472 /* We have to do this the hard way to detect unsigned overflow.
6473 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6479 {
6484 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6488 }
6490 {
6494 {
6513 }
6514 }
6515 else
6516 {
6517 /* A negative divisor reverses the relational operators. */
6523 {
6542 }
6543 }
6546 {
6567 {
6570 }
6575 {
6578 }
6583 {
6586 }
6591 {
6594 }
6599 }
6602 }
6605 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6606 equality/inequality test, then return a simplified form of the test
6607 using a sign testing. Otherwise return NULL. TYPE is the desired
6608 result type. */
6610 static tree
6613 tree result_type)
6614 {
6615 /* If this is testing a single bit, we can optimize the test. */
6619 {
6620 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6621 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6625 /* This is only a win if casting to a signed type is cheap,
6626 i.e. when arg00's type is not a partial mode. */
6629 {
6632 result_type,
6635 }
6636 }
6639 }
6641 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6642 equality/inequality test, then return a simplified form of
6643 the test using shifts and logical operations. Otherwise return
6644 NULL. TYPE is the desired result type. */
6646 tree
6649 {
6650 /* If this is testing a single bit, we can optimize the test. */
6654 {
6663 /* First, see if we can fold the single bit test into a sign-bit
6664 test. */
6666 result_type);
6670 /* Otherwise we have (A & C) != 0 where C is a single bit,
6671 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6672 Similarly for (A & C) == 0. */
6674 /* If INNER is a right shift of a constant and it plus BITNUM does
6675 not overflow, adjust BITNUM and INNER. */
6681 {
6684 }
6686 /* If we are going to be able to omit the AND below, we must do our
6687 operations as unsigned. If we must use the AND, we have a choice.
6688 Normally unsigned is faster, but for some machines signed is. */
6706 /* Put the AND last so it can combine with more things. */
6709 /* Make sure to return the proper type. */
6713 }
6715 }
6717 /* Test whether it is preferable two swap two operands, ARG0 and
6718 ARG1, for example because ARG0 is an integer constant and ARG1
6719 isn't. */
6721 bool
6723 {
6737 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6738 for commutative and comparison operators. Ensuring a canonical
6739 form allows the optimizers to find additional redundancies without
6740 having to explicitly check for both orderings. */
6746 /* Put SSA_NAMEs last. */
6752 /* Put variables last. */
6759 }
6762 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6763 means A >= Y && A != MAX, but in this case we know that
6764 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6766 static tree
6768 {
6775 else
6784 {
6787 }
6789 {
6792 }
6793 else
6800 {
6801 /* Convert the pointer types into integer before taking the difference. */
6805 }
6806 else
6813 }
6815 /* Fold a sum or difference of at least one multiplication.
6816 Returns the folded tree or NULL if no simplification could be made. */
6818 static tree
6821 {
6825 /* (A * C) +- (B * C) -> (A+-B) * C.
6826 (A * C) +- A -> A * (C+-1).
6827 We are most concerned about the case where C is a constant,
6828 but other combinations show up during loop reduction. Since
6829 it is not difficult, try all four possibilities. */
6832 {
6835 }
6837 {
6840 }
6841 else
6842 {
6843 /* We cannot generate constant 1 for fract. */
6848 }
6850 {
6853 }
6855 {
6857 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6858 the purpose of this canonicalization. */
6862 {
6865 }
6866 else
6868 }
6869 else
6870 {
6871 /* We cannot generate constant 1 for fract. */
6876 }
6888 /* No identical multiplicands; see if we can find a common
6889 power-of-two factor in non-power-of-two multiplies. This
6890 can help in multi-dimensional array access. */
6893 {
6896 tree maybe_same;
6900 /* Move min of absolute values to int11. */
6902 {
6907 }
6908 else
6912 /* The remainder should not be a constant, otherwise we
6913 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6914 increased the number of multiplications necessary. */
6916 {
6924 }
6925 }
6935 }
6937 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
6938 specified by EXPR into the buffer PTR of length LEN bytes.
6939 Return the number of bytes placed in the buffer, or zero
6940 upon failure. */
6942 static int
6944 {
6958 {
6960 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
6961 number of bytes. */
6965 {
6972 else
6974 }
6975 else
6980 }
6982 }
6985 /* Subroutine of native_encode_expr. Encode the FIXED_CST
6986 specified by EXPR into the buffer PTR of length LEN bytes.
6987 Return the number of bytes placed in the buffer, or zero
6988 upon failure. */
6990 static int
6992 {
6996 FIXED_VALUE_TYPE value;
7012 }
7015 /* Subroutine of native_encode_expr. Encode the REAL_CST
7016 specified by EXPR into the buffer PTR of length LEN bytes.
7017 Return the number of bytes placed in the buffer, or zero
7018 upon failure. */
7020 static int
7022 {
7028 /* There are always 32 bits in each long, no matter the size of
7029 the hosts long. We handle floating point representations with
7030 up to 192 bits. */
7044 {
7049 {
7056 else
7058 }
7059 else
7060 {
7063 {
7064 /* Reverse bytes within each long, or within the entire float
7065 if it's smaller than a long (for HFmode). */
7068 }
7069 }
7074 }
7076 }
7078 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7079 specified by EXPR into the buffer PTR of length LEN bytes.
7080 Return the number of bytes placed in the buffer, or zero
7081 upon failure. */
7083 static int
7085 {
7087 tree part;
7102 }
7105 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7106 specified by EXPR into the buffer PTR of length LEN bytes.
7107 Return the number of bytes placed in the buffer, or zero
7108 upon failure. */
7110 static int
7112 {
7122 {
7124 {
7127 }
7138 }
7140 }
7143 /* Subroutine of native_encode_expr. Encode the STRING_CST
7144 specified by EXPR into the buffer PTR of length LEN bytes.
7145 Return the number of bytes placed in the buffer, or zero
7146 upon failure. */
7148 static int
7150 {
7152 HOST_WIDE_INT total_bytes;
7166 {
7169 {
7172 }
7175 }
7176 else
7179 }
7182 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7183 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7184 buffer PTR of length LEN bytes. If OFF is not -1 then start
7185 the encoding at byte offset OFF and encode at most LEN bytes.
7186 Return the number of bytes placed in the buffer, or zero upon failure. */
7188 int
7190 {
7191 /* We don't support starting at negative offset and -1 is special. */
7196 {
7217 }
7218 }
7221 /* Subroutine of native_interpret_expr. Interpret the contents of
7222 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7223 If the buffer cannot be interpreted, return NULL_TREE. */
7225 static tree
7227 {
7237 }
7240 /* Subroutine of native_interpret_expr. Interpret the contents of
7241 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7242 If the buffer cannot be interpreted, return NULL_TREE. */
7244 static tree
7246 {
7248 double_int result;
7249 FIXED_VALUE_TYPE fixed_value;
7259 }
7262 /* Subroutine of native_interpret_expr. Interpret the contents of
7263 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7264 If the buffer cannot be interpreted, return NULL_TREE. */
7266 static tree
7268 {
7272 /* There are always 32 bits in each long, no matter the size of
7273 the hosts long. We handle floating point representations with
7274 up to 192 bits. */
7275 REAL_VALUE_TYPE r;
7286 {
7287 /* Both OFFSET and BYTE index within a long;
7288 bitpos indexes the whole float. */
7291 {
7298 else
7300 }
7301 else
7302 {
7305 {
7306 /* Reverse bytes within each long, or within the entire float
7307 if it's smaller than a long (for HFmode). */
7310 }
7311 }
7315 }
7319 }
7322 /* Subroutine of native_interpret_expr. Interpret the contents of
7323 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7324 If the buffer cannot be interpreted, return NULL_TREE. */
7326 static tree
7328 {
7343 }
7346 /* Subroutine of native_interpret_expr. Interpret the contents of
7347 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7348 If the buffer cannot be interpreted, return NULL_TREE. */
7350 static tree
7352 {
7365 {
7370 }
7372 }
7375 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7376 the buffer PTR of length LEN as a constant of type TYPE. For
7377 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7378 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7379 return NULL_TREE. */
7381 tree
7383 {
7385 {
7407 }
7408 }
7410 /* Returns true if we can interpret the contents of a native encoding
7411 as TYPE. */
7413 static bool
7415 {
7417 {
7430 }
7431 }
7433 /* Return true iff a constant of type TYPE is accepted by
7434 native_encode_expr. */
7436 bool
7438 {
7440 {
7450 }
7451 }
7453 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7454 TYPE at compile-time. If we're unable to perform the conversion
7455 return NULL_TREE. */
7457 static tree
7459 {
7460 /* We support up to 512-bit values (for V8DFmode). */
7464 /* Check that the host and target are sane. */
7473 }
7475 /* Build an expression for the address of T. Folds away INDIRECT_REF
7476 to avoid confusing the gimplify process. */
7478 tree
7480 {
7481 /* The size of the object is not relevant when talking about its address. */
7486 {
7491 }
7501 {
7506 }
7507 else
7511 }
7513 /* Build an expression for the address of T. */
7515 tree
7517 {
7521 }
7523 /* Fold a unary expression of code CODE and type TYPE with operand
7524 OP0. Return the folded expression if folding is successful.
7525 Otherwise, return NULL_TREE. */
7527 tree
7529 {
7530 tree tem;
7531 tree arg0;
7539 {
7542 {
7543 /* Don't use STRIP_NOPS, because signedness of argument type
7544 matters. */
7546 }
7547 else
7548 {
7549 /* Strip any conversions that don't change the mode. This
7550 is safe for every expression, except for a comparison
7551 expression because its signedness is derived from its
7552 operands.
7554 Note that this is done as an internal manipulation within
7555 the constant folder, in order to find the simplest
7556 representation of the arguments so that their form can be
7557 studied. In any cases, the appropriate type conversions
7558 should be put back in the tree that will get out of the
7559 constant folder. */
7561 }
7564 {
7567 {
7571 }
7572 }
7573 }
7580 {
7587 {
7601 /* If this was a conversion, and all we did was to move into
7602 inside the COND_EXPR, bring it back out. But leave it if
7603 it is a conversion from integer to integer and the
7604 result precision is no wider than a word since such a
7605 conversion is cheap and may be optimized away by combine,
7606 while it couldn't if it were outside the COND_EXPR. Then return
7607 so we don't get into an infinite recursion loop taking the
7608 conversion out and then back in. */
7620 && (INTEGRAL_TYPE_P
7633 }
7634 }
7637 {
7643 CASE_CONVERT:
7647 {
7648 /* If we have (type) (a CMP b) and type is an integral type, return
7649 new expression involving the new type. Canonicalize
7650 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7651 non-integral type.
7652 Do not fold the result as that would not simplify further, also
7653 folding again results in recursions. */
7663 }
7665 /* Handle (T *)&A.B.C for A being of type T and B and C
7666 living at offset zero. This occurs frequently in
7667 C++ upcasting and then accessing the base. */
7671 {
7673 tree offset;
7674 machine_mode mode;
7676 tree base
7680 /* If the reference was to a (constant) zero offset, we can use
7681 the address of the base if it has the same base type
7682 as the result type and the pointer type is unqualified. */
7689 }
7693 /* Detect assigning a bitfield. */
7695 && DECL_BIT_FIELD
7697 {
7698 /* Don't leave an assignment inside a conversion
7699 unless assigning a bitfield. */
7701 /* First do the assignment, then return converted constant. */
7706 }
7708 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7709 constants (if x has signed type, the sign bit cannot be set
7710 in c). This folds extension into the BIT_AND_EXPR.
7711 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7712 very likely don't have maximal range for their precision and this
7713 transformation effectively doesn't preserve non-maximal ranges. */
7717 {
7728 <= HOST_BITS_PER_WIDE_INT
7730 {
7734 cst &= HOST_WIDE_INT_M1U
7738 && !flag_syntax_only
7741 {
7745 }
7746 }
7748 {
7753 }
7754 }
7756 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7757 cast (T1)X will fold away. We assume that this happens when X itself
7758 is a cast. */
7762 {
7766 return fold_build_pointer_plus_loc
7768 }
7770 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7771 of the same precision, and X is an integer type not narrower than
7772 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7778 {
7784 }
7786 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7787 type of X and Y (integer types only). */
7792 {
7793 /* Be careful not to introduce new overflows. */
7794 tree mult_type;
7797 else
7801 {
7808 }
7809 }
7815 {
7822 }
7833 /* Convert fabs((double)float) into (double)fabsf(float). */
7836 {
7842 targ0));
7843 }
7847 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7866 /* Note that the operand of this must be an int
7867 and its values must be 0 or 1.
7868 ("true" is a fixed value perhaps depending on the language,
7869 but we don't handle values other than 1 correctly yet.) */
7876 /* Fold *&X to X if X is an lvalue. */
7878 {
7885 }
7891 }
7894 /* If the operation was a conversion do _not_ mark a resulting constant
7895 with TREE_OVERFLOW if the original constant was not. These conversions
7896 have implementation defined behavior and retaining the TREE_OVERFLOW
7897 flag here would confuse later passes such as VRP. */
7898 tree
7901 {
7910 }
7912 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7913 operands OP0 and OP1. LOC is the location of the resulting expression.
7914 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7915 Return the folded expression if folding is successful. Otherwise,
7916 return NULL_TREE. */
7917 static tree
7920 {
7921 tree tem;
7923 /* We only do these simplifications if we are optimizing. */
7927 /* Check for things like (A || B) && (A || C). We can convert this
7928 to A || (B && C). Note that either operator can be any of the four
7929 truth and/or operations and the transformation will still be
7930 valid. Also note that we only care about order for the
7931 ANDIF and ORIF operators. If B contains side effects, this
7932 might change the truth-value of A. */
7939 {
7959 /* This case if tricky because we must either have commutative
7960 operators or else A10 must not have side-effects. */
7966 a01);
7967 }
7969 /* See if we can build a range comparison. */
7975 {
7979 }
7983 {
7987 }
7989 /* Check for the possibility of merging component references. If our
7990 lhs is another similar operation, try to merge its rhs with our
7991 rhs. Then try to merge our lhs and rhs. */
8005 {
8012 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8013 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8014 We don't want to pack more than two leafs to a non-IF AND/OR
8015 expression.
8016 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8017 equal to IF-CODE, then we don't want to add right-hand operand.
8018 If the inner right-hand side of left-hand operand has
8019 side-effects, or isn't simple, then we can't add to it,
8020 as otherwise we might destroy if-sequence. */
8023 /* Needed for sequence points to handle trappings, and
8024 side-effects. */
8026 {
8028 arg1);
8030 tem);
8031 }
8032 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8033 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8036 /* Needed for sequence points to handle trappings, and
8037 side-effects. */
8039 {
8044 }
8045 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8046 into (A OR B).
8047 For sequence point consistancy, we need to check for trapping,
8048 and side-effects. */
8052 }
8055 }
8057 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8058 by changing CODE to reduce the magnitude of constants involved in
8059 ARG0 of the comparison.
8060 Returns a canonicalized comparison tree if a simplification was
8061 possible, otherwise returns NULL_TREE.
8062 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8063 valid if signed overflow is undefined. */
8065 static tree
8069 {
8074 /* Match A +- CST code arg1. We can change this only if overflow
8075 is undefined. */
8078 /* In principle pointers also have undefined overflow behavior,
8079 but that causes problems elsewhere. */
8086 /* Identify the constant in arg0 and its sign. */
8090 /* Overflowed constants and zero will cause problems. */
8095 /* See if we can reduce the magnitude of the constant in
8096 arg0 by changing the comparison code. */
8097 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8101 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8105 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8109 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8113 else
8117 /* Now build the constant reduced in magnitude. But not if that
8118 would produce one outside of its types range. */
8134 }
8136 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8137 overflow further. Try to decrease the magnitude of constants involved
8138 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8139 and put sole constants at the second argument position.
8140 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8142 static tree
8145 {
8146 tree t;
8151 /* Try canonicalization by simplifying arg0. */
8156 {
8160 }
8162 /* Try canonicalization by simplifying arg1 using the swapped
8163 comparison. */
8171 }
8173 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8174 space. This is used to avoid issuing overflow warnings for
8175 expressions like &p->x which can not wrap. */
8177 static bool
8179 {
8186 wide_int wi_offset;
8192 else
8208 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8209 array. */
8211 {
8212 HOST_WIDE_INT base_size;
8217 }
8220 }
8222 /* Return a positive integer when the symbol DECL is known to have
8223 a nonzero address, zero when it's known not to (e.g., it's a weak
8224 symbol), and a negative integer when the symbol is not yet in the
8225 symbol table and so whether or not its address is zero is unknown.
8226 For function local objects always return positive integer. */
8227 static int
8229 {
8234 /* Function local objects are never NULL. */
8242 }
8244 /* Subroutine of fold_binary. This routine performs all of the
8245 transformations that are common to the equality/inequality
8246 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8247 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8248 fold_binary should call fold_binary. Fold a comparison with
8249 tree code CODE and type TYPE with operands OP0 and OP1. Return
8250 the folded comparison or NULL_TREE. */
8252 static tree
8255 {
8265 /* For comparisons of pointers we can decompose it to a compile time
8266 comparison of the base objects and the offsets into the object.
8267 This requires at least one operand being an ADDR_EXPR or a
8268 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8274 {
8277 machine_mode mode;
8281 /* Get base and offset for the access. Strip ADDR_EXPR for
8282 get_inner_reference, but put it back by stripping INDIRECT_REF
8283 off the base object if possible. indirect_baseN will be true
8284 if baseN is not an address but refers to the object itself. */
8287 {
8288 base0
8294 else
8296 }
8298 {
8302 {
8303 base0
8309 else
8311 }
8314 else
8318 {
8324 {
8327 }
8328 }
8329 }
8333 {
8334 base1
8340 else
8342 }
8344 {
8348 {
8349 base1
8355 else
8357 }
8360 else
8364 {
8370 {
8373 }
8374 }
8375 }
8377 /* If we have equivalent bases we might be able to simplify. */
8381 {
8382 /* We can fold this expression to a constant if the non-constant
8383 offset parts are equal. */
8387 && (equality_code
8388 || (indirect_base0
8392 {
8398 "occur when comparing P +- C1 with "
8400 WARN_STRICT_OVERFLOW_CONDITIONAL);
8403 {
8417 }
8418 }
8419 /* We can simplify the comparison to a comparison of the variable
8420 offset parts if the constant offset parts are equal.
8421 Be careful to use signed sizetype here because otherwise we
8422 mess with array offsets in the wrong way. This is possible
8423 because pointer arithmetic is restricted to retain within an
8424 object and overflow on pointer differences is undefined as of
8425 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8427 && (equality_code
8428 || (indirect_base0
8431 {
8432 /* By converting to signed sizetype we cover middle-end pointer
8433 arithmetic which operates on unsigned pointer types of size
8434 type size and ARRAY_REF offsets which are properly sign or
8435 zero extended from their type in case it is narrower than
8436 sizetype. */
8439 else
8443 else
8450 "occur when comparing P +- C1 with "
8452 WARN_STRICT_OVERFLOW_COMPARISON);
8455 }
8456 }
8457 /* For equal offsets we can simplify to a comparison of the
8458 base addresses. */
8460 && (indirect_base0
8462 && (indirect_base1
8467 {
8473 }
8474 /* Comparison between an ordinary (non-weak) symbol and a null
8475 pointer can be eliminated since such symbols must have a non
8476 null address. In C, relational expressions between pointers
8477 to objects and null pointers are undefined. The results
8478 below follow the C++ rules with the additional property that
8479 every object pointer compares greater than a null pointer.
8480 */
8483 /* Avoid folding references to struct members at offset 0 to
8484 prevent tests like '&ptr->firstmember == 0' from getting
8485 eliminated. When ptr is null, although the -> expression
8486 is strictly speaking invalid, GCC retains it as a matter
8487 of QoI. See PR c/44555. */
8490 && indirect_base0
8491 /* The caller guarantees that when one of the arguments is
8492 constant (i.e., null in this case) it is second. */
8494 {
8496 {
8507 }
8508 }
8509 }
8511 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8512 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8513 the resulting offset is smaller in absolute value than the
8514 original one and has the same sign. */
8523 {
8528 tree cst;
8530 "occur when combining constants around "
8533 /* Put the constant on the side where it doesn't overflow and is
8534 of lower absolute value and of same sign than before. */
8541 {
8544 variable1,
8548 }
8556 {
8562 variable2);
8563 }
8564 }
8570 /* If we are comparing an expression that just has comparisons
8571 of two integer values, arithmetic expressions of those comparisons,
8572 and constants, we can simplify it. There are only three cases
8573 to check: the two values can either be equal, the first can be
8574 greater, or the second can be greater. Fold the expression for
8575 those three values. Since each value must be 0 or 1, we have
8576 eight possibilities, each of which corresponds to the constant 0
8577 or 1 or one of the six possible comparisons.
8579 This handles common cases like (a > b) == 0 but also handles
8580 expressions like ((x > y) - (y > x)) > 0, which supposedly
8581 occur in macroized code. */
8584 {
8589 /* Don't handle degenerate cases here; they should already
8590 have been handled anyway. */
8599 {
8603 /* We can't just pass T to eval_subst in case cval1 or cval2
8604 was the same as ARG1. */
8606 tree high_result
8610 arg1);
8611 tree equal_result
8615 arg1);
8616 tree low_result
8620 arg1);
8622 /* All three of these results should be 0 or 1. Confirm they are.
8623 Then use those values to select the proper code to use. */
8628 {
8629 /* Make a 3-bit mask with the high-order bit being the
8630 value for `>', the next for '=', and the low for '<'. */
8634 {
8636 /* Always false. */
8657 /* Always true. */
8659 }
8662 {
8666 }
8668 }
8669 }
8670 }
8672 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8673 into a single range test. */
8680 {
8684 }
8687 }
8690 /* Subroutine of fold_binary. Optimize complex multiplications of the
8691 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8692 argument EXPR represents the expression "z" of type TYPE. */
8694 static tree
8696 {
8701 {
8704 }
8706 {
8709 }
8710 else
8711 {
8715 }
8724 }
8727 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8728 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8730 static bool
8732 {
8736 {
8739 }
8741 {
8747 else
8749 }
8750 else
8756 }
8758 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8759 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8760 NULL_TREE otherwise. */
8762 static tree
8764 {
8781 {
8785 }
8788 {
8794 }
8795 else
8797 }
8799 /* Try to fold a pointer difference of type TYPE two address expressions of
8800 array references AREF0 and AREF1 using location LOC. Return a
8801 simplified expression for the difference or NULL_TREE. */
8803 static tree
8806 {
8811 /* If the bases are array references as well, recurse. If the bases
8812 are pointer indirections compute the difference of the pointers.
8813 If the bases are equal, we are set. */
8816 && (base_offset
8820 && (base_offset
8826 {
8832 base_offset,
8835 }
8837 }
8839 /* If the real or vector real constant CST of type TYPE has an exact
8840 inverse, return it, else return NULL. */
8842 tree
8844 {
8845 REAL_VALUE_TYPE r;
8847 machine_mode mode;
8851 {
8867 {
8872 }
8878 }
8879 }
8881 /* Mask out the tz least significant bits of X of type TYPE where
8882 tz is the number of trailing zeroes in Y. */
8883 static wide_int
8885 {
8890 }
8892 /* Return true when T is an address and is known to be nonzero.
8893 For floating point we further ensure that T is not denormal.
8894 Similar logic is present in nonzero_address in rtlanal.h.
8896 If the return value is based on the assumption that signed overflow
8897 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8898 change *STRICT_OVERFLOW_P. */
8900 static bool
8902 {
8906 /* Doing something useful for floating point would need more work. */
8912 {
8915 strict_overflow_p);
8921 strict_overflow_p);
8929 }
8932 {
8935 strict_overflow_p);
8943 strict_overflow_p);
8958 strict_overflow_p);
8962 strict_overflow_p);
8965 {
8977 }
8981 }
8983 }
8985 /* Return true when T is an address and is known to be nonzero.
8986 Handle warnings about undefined signed overflow. */
8988 bool
8990 {
8997 "determining that expression is always "
8999 WARN_STRICT_OVERFLOW_MISC);
9001 }
9003 /* Return true if T is known not to be equal to an integer W. */
9005 bool
9007 {
9009 value_range_type rtype;
9011 {
9020 {
9025 }
9030 /* If T has some known zero bits and W has any of those bits set,
9031 then T is known not to be equal to W. */
9039 }
9040 }
9042 /* Fold a binary expression of code CODE and type TYPE with operands
9043 OP0 and OP1. LOC is the location of the resulting expression.
9044 Return the folded expression if folding is successful. Otherwise,
9045 return NULL_TREE. */
9047 tree
9050 {
9065 /* Strip any conversions that don't change the mode. This is
9066 safe for every expression, except for a comparison expression
9067 because its signedness is derived from its operands. So, in
9068 the latter case, only strip conversions that don't change the
9069 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9070 preserved.
9072 Note that this is done as an internal manipulation within the
9073 constant folder, in order to find the simplest representation
9074 of the arguments so that their form can be studied. In any
9075 cases, the appropriate type conversions should be put back in
9076 the tree that will get out of the constant folder. */
9079 {
9082 }
9083 else
9084 {
9087 }
9089 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9090 constant but we can't do arithmetic on them. */
9092 {
9095 {
9099 }
9100 }
9102 /* If this is a commutative operation, and ARG0 is a constant, move it
9103 to ARG1 to reduce the number of tests below. */
9108 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9109 to ARG1 to reduce the number of tests below. */
9118 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9120 First check for cases where an arithmetic operation is applied to a
9121 compound, conditional, or comparison operation. Push the arithmetic
9122 operation inside the compound or conditional to see if any folding
9123 can then be done. Convert comparison to conditional for this purpose.
9124 The also optimizes non-constant cases that used to be done in
9125 expand_expr.
9127 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9128 one of the operands is a comparison and the other is a comparison, a
9129 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9130 code below would make the expression more complex. Change it to a
9131 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9132 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9145 {
9149 boolean_type_node,
9157 }
9161 {
9163 {
9168 tem);
9169 }
9171 {
9176 tem);
9177 }
9182 {
9188 }
9193 {
9199 }
9200 }
9203 {
9205 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9208 {
9214 }
9216 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9219 {
9220 tree base;
9221 HOST_WIDE_INT coffset;
9230 }
9235 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9241 arg1),
9243 arg0)));
9249 {
9250 /* X + (X / CST) * -CST is X % CST. */
9255 {
9264 cst0));
9265 }
9266 }
9268 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9269 one. Make sure the type is not saturating and has the signedness of
9270 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9271 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9278 {
9282 }
9285 {
9286 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9287 (plus (plus (mult) (mult)) (foo)) so that we can
9288 take advantage of the factoring cases below. */
9297 {
9303 else
9316 parg0),
9318 marg)),
9322 return
9328 parg1)));
9329 }
9330 }
9331 else
9332 {
9333 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9334 to __complex__ ( x, y ). This is not the same for SNaNs or
9335 if signed zeros are involved. */
9339 {
9346 {
9350 {
9356 }
9358 {
9364 }
9365 }
9366 }
9374 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9375 We associate floats only if the user has specified
9376 -fassociative-math. */
9380 {
9385 {
9386 tree tree0;
9389 }
9390 }
9391 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9392 We associate floats only if the user has specified
9393 -fassociative-math. */
9397 {
9402 {
9403 tree tree0;
9406 }
9407 }
9408 }
9410 bit_rotate:
9411 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9412 is a rotate of A by C1 bits. */
9413 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9414 is a rotate of A by B bits. */
9415 {
9417 tree rtype;
9426 /* Only create rotates in complete modes. Other cases are not
9427 expanded properly. */
9430 {
9444 {
9448 code0 == LSHIFT_EXPR
9452 }
9454 {
9462 element_precision
9466 return
9469 ? LROTATE_EXPR
9474 }
9476 {
9484 element_precision
9488 return fold_convert_loc
9491 ? LROTATE_EXPR
9495 }
9496 }
9497 }
9499 associate:
9500 /* In most languages, can't associate operations on floats through
9501 parentheses. Rather than remember where the parentheses were, we
9502 don't associate floats at all, unless the user has specified
9503 -fassociative-math.
9504 And, we need to make sure type is not saturating. */
9508 {
9514 /* Split both trees into variables, constants, and literals. Then
9515 associate each group together, the constants with literals,
9516 then the result with variables. This increases the chances of
9517 literals being recombined later and of generating relocatable
9518 expressions for the sum of a constant and literal. */
9524 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9528 /* With undefined overflow prefer doing association in a type
9529 which wraps on overflow, if that is one of the operand types. */
9532 {
9540 }
9542 /* With undefined overflow we can only associate constants with one
9543 variable, and constants whose association doesn't overflow. */
9546 {
9548 {
9554 {
9557 }
9564 {
9567 }
9573 /* The only case we can still associate with two variables
9574 is if they cancel out. */
9578 }
9579 }
9581 /* Only do something if we found more than two objects. Otherwise,
9582 nothing has changed and we risk infinite recursion. */
9588 {
9600 /* Preserve the MINUS_EXPR if the negative part of the literal is
9601 greater than the positive part. Otherwise, the multiplicative
9602 folding code (i.e extract_muldiv) may be fooled in case
9603 unsigned constants are subtracted, like in the following
9604 example: ((X*2 + 4) - 8U)/2. */
9606 {
9610 {
9614 }
9615 else
9616 {
9620 }
9621 }
9623 /* Don't introduce overflows through reassociation. */
9630 {
9632 return
9636 else
9637 {
9640 return
9644 }
9645 }
9648 return
9651 }
9652 }
9657 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9665 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9666 __complex__ ( x, -y ). This is not the same for SNaNs or if
9667 signed zeros are involved. */
9671 {
9678 {
9682 {
9684 arg1r ? arg1r
9689 }
9691 {
9695 arg1i ? arg1i
9698 }
9699 }
9700 }
9702 /* A - B -> A + (-B) if B is easily negatable. */
9706 /* Avoid this transformation if B is a positive REAL_CST. */
9714 /* Fold &a[i] - &a[j] to i-j. */
9719 {
9725 }
9728 && flag_unsafe_math_optimizations
9734 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9735 one. Make sure the type is not saturating and has the signedness of
9736 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9737 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9744 {
9748 }
9754 {
9755 /* Transform x * -C into -x * C if x is easily negatable. */
9769 {
9772 "occur when simplifying "
9774 WARN_STRICT_OVERFLOW_MISC);
9776 }
9778 /* Optimize z * conj(z) for integer complex numbers. */
9785 }
9786 else
9787 {
9788 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9789 This is not the same for NaNs or if signed zeros are
9790 involved. */
9796 {
9799 return
9805 return
9810 }
9812 /* Optimize z * conj(z) for floating point complex numbers.
9813 Guarded by flag_unsafe_math_optimizations as non-finite
9814 imaginary components don't produce scalar results. */
9823 }
9827 /* Canonicalize (X & C1) | C2. */
9831 {
9836 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9844 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9849 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9850 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9851 mode which allows further optimizations. */
9856 {
9860 {
9863 }
9864 }
9871 c3)),
9872 arg1);
9873 }
9875 /* See if this can be simplified into a rotate first. If that
9876 is unsuccessful continue in the association code. */
9880 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
9888 /* See if this can be simplified into a rotate first. If that
9889 is unsuccessful continue in the association code. */
9893 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
9898 {
9899 tree tem2;
9906 }
9907 /* Fold ~X & 1 as (X & 1) == 0. */
9911 {
9912 tree tem2;
9919 }
9920 /* Fold !X & 1 as X == 0. */
9923 {
9927 }
9929 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
9930 multiple of 1 << CST. */
9932 {
9939 }
9941 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
9942 bits from CST2. */
9946 {
9954 {
9955 /* Avoid the transform if arg1 is a mask of some
9956 mode which allows further optimizations. */
9963 }
9964 }
9966 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
9967 ((A & N) + B) & M -> (A + B) & M
9968 Similarly if (N & M) == 0,
9969 ((A | N) + B) & M -> (A + B) & M
9970 and for - instead of + (or unary - instead of +)
9971 and/or ^ instead of |.
9972 If B is constant and (B & M) == 0, fold into A & M. */
9974 {
9983 {
9986 wide_int cst0;
9988 /* Now we know that arg0 is (C + D) or (C - D) or
9989 -C and arg1 (M) is == (1LL << cst) - 1.
9990 Store C into PMOP[0] and D into PMOP[1]. */
9994 {
9997 }
10004 {
10014 {
10017 }
10020 /* If C or D is of the form (A & N) where
10021 (N & M) == M, or of the form (A | N) or
10022 (A ^ N) where (N & M) == 0, replace it with A. */
10026 /* If C or D is a N where (N & M) == 0, it can be
10027 omitted (assumed 0). */
10035 }
10037 /* Only build anything new if we optimized one or both arguments
10038 above. */
10042 {
10045 {
10046 /* Perform the operations in a type that has defined
10047 overflow behavior. */
10053 }
10058 {
10066 else
10068 }
10071 else
10074 /* TEM is now the new binary +, - or unary - replacement. */
10078 }
10079 }
10080 }
10082 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10085 {
10090 return
10092 }
10097 /* Don't touch a floating-point divide by zero unless the mode
10098 of the constant can represent infinity. */
10104 /* (-A) / (-B) -> A / B */
10116 /* Fall through */
10119 /* Simplify A / (B << N) where A and B are positive and B is
10120 a power of 2, to A >> (N + log2(B)). */
10125 {
10128 {
10136 WARN_STRICT_OVERFLOW_MISC);
10142 }
10143 }
10145 /* Fall through */
10153 /* Convert -A / -B to A / B when the type is signed and overflow is
10154 undefined. */
10158 {
10161 "when distributing negation across "
10163 WARN_STRICT_OVERFLOW_MISC);
10168 }
10172 {
10175 "when distributing negation across "
10177 WARN_STRICT_OVERFLOW_MISC);
10182 }
10184 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10185 operation, EXACT_DIV_EXPR.
10187 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10188 At one time others generated faster code, it's not clear if they do
10189 after the last round to changes to the DIV code in expmed.c. */
10200 {
10204 WARN_STRICT_OVERFLOW_MISC);
10206 }
10218 {
10222 WARN_STRICT_OVERFLOW_MISC);
10224 }
10232 /* Since negative shift count is not well-defined,
10233 don't try to compute it in the compiler. */
10239 /* If we have a rotate of a bit operation with the rotate count and
10240 the second operand of the bit operation both constant,
10241 permute the two operations. */
10247 {
10255 }
10257 /* Two consecutive rotates adding up to the some integer
10258 multiple of the precision of the type can be ignored. */
10273 /* Note that the operands of this must be ints
10274 and their values must be 0 or 1.
10275 ("true" is a fixed value perhaps depending on the language.) */
10276 /* If first arg is constant zero, return it. */
10279 /* FALLTHRU */
10281 /* If either arg is constant true, drop it. */
10285 /* Preserve sequence points. */
10288 /* If second arg is constant zero, result is zero, but first arg
10289 must be evaluated. */
10292 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10293 case will be handled here. */
10297 /* !X && X is always false. */
10301 /* X && !X is always false. */
10306 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10307 means A >= Y && A != MAX, but in this case we know that
10308 A < X <= MAX. */
10312 {
10320 }
10329 /* Note that the operands of this must be ints
10330 and their values must be 0 or true.
10331 ("true" is a fixed value perhaps depending on the language.) */
10332 /* If first arg is constant true, return it. */
10335 /* FALLTHRU */
10337 /* If either arg is constant zero, drop it. */
10341 /* Preserve sequence points. */
10344 /* If second arg is constant true, result is true, but we must
10345 evaluate first arg. */
10348 /* Likewise for first arg, but note this only occurs here for
10349 TRUTH_OR_EXPR. */
10353 /* !X || X is always true. */
10357 /* X || !X is always true. */
10362 /* (X && !Y) || (!X && Y) is X ^ Y */
10365 {
10382 }
10391 /* If the second arg is constant zero, drop it. */
10394 /* If the second arg is constant true, this is a logical inversion. */
10396 {
10399 }
10400 /* Identical arguments cancel to zero. */
10404 /* !X ^ X is always true. */
10409 /* X ^ !X is always true. */
10425 /* bool_var != 1 becomes !bool_var. */
10432 /* bool_var == 0 becomes !bool_var. */
10439 /* !exp != 0 becomes !exp */
10444 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10453 {
10459 }
10461 /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
10470 {
10476 }
10478 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10486 code == NE_EXPR
10490 /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
10498 code == NE_EXPR
10502 /* If this is an EQ or NE comparison with zero and ARG0 is
10503 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10504 two operations, but the latter can be done in one less insn
10505 on machines that have only two-operand insns or on which a
10506 constant cannot be the first operand. */
10509 {
10514 {
10521 arg1);
10522 }
10525 {
10532 arg1);
10533 }
10534 }
10536 /* If this is an NE or EQ comparison of zero against the result of a
10537 signed MOD operation whose second operand is a power of 2, make
10538 the MOD operation unsigned since it is simpler and equivalent. */
10546 {
10556 }
10558 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10559 C1 is a valid shift constant, and C2 is a power of two, i.e.
10560 a single bit. */
10564 == INTEGER_CST
10567 {
10572 /* Check for a valid shift count. */
10574 {
10578 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10579 can be rewritten as (X & (C2 << C1)) != 0. */
10581 {
10586 }
10587 /* Otherwise, for signed (arithmetic) shifts,
10588 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10589 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10593 /* Otherwise, of unsigned (logical) shifts,
10594 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10595 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10596 else
10600 arg000);
10601 }
10602 }
10604 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10605 Similarly for NE_EXPR. */
10609 {
10613 tree dandnotc
10616 notc);
10620 }
10622 /* If this is a comparison of a field, we may be able to simplify it. */
10625 /* Handle the constant case even without -O
10626 to make sure the warnings are given. */
10628 {
10632 }
10634 /* Optimize comparisons of strlen vs zero to a compare of the
10635 first character of the string vs zero. To wit,
10636 strlen(ptr) == 0 => *ptr == 0
10637 strlen(ptr) != 0 => *ptr != 0
10638 Other cases should reduce to one of these two (or a constant)
10639 due to the return value of strlen being unsigned. */
10642 {
10650 {
10655 }
10656 }
10658 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10659 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10663 {
10668 {
10670 {
10673 }
10676 }
10677 }
10679 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10680 (X & C) == 0 when C is a single bit. */
10685 {
10692 arg1));
10693 }
10695 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10696 constant C is a power of two, i.e. a single bit. */
10703 {
10707 }
10709 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10710 when is C is a power of two, i.e. a single bit. */
10717 {
10723 }
10727 {
10730 }
10732 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10735 {
10748 arg01),
10757 arg01),
10766 arg00),
10775 arg00),
10777 }
10781 {
10788 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10789 operand_equal_p guarantees no side-effects so we don't need
10790 to use omit_one_operand on Z. */
10794 arg10));
10798 arg11));
10802 arg10));
10806 arg11));
10808 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10811 {
10817 }
10818 }
10820 /* Attempt to simplify equality/inequality comparisons of complex
10821 values. Only lower the comparison if the result is known or
10822 can be simplified to a single scalar comparison. */
10827 {
10832 {
10835 }
10836 else
10837 {
10840 }
10843 {
10846 }
10847 else
10848 {
10851 }
10855 {
10857 {
10862 }
10863 else
10864 {
10869 }
10870 }
10874 {
10876 {
10881 }
10882 else
10883 {
10888 }
10889 }
10890 }
10902 /* Transform comparisons of the form X +- C CMP X. */
10909 {
10916 else
10919 /* (X - c) > X becomes false. */
10923 {
10927 "occur when assuming that (X - c) > X "
10929 WARN_STRICT_OVERFLOW_ALL);
10931 }
10933 /* Likewise (X + c) < X becomes false. */
10937 {
10941 "occur when assuming that "
10943 WARN_STRICT_OVERFLOW_ALL);
10945 }
10947 /* Convert (X - c) <= X to true. */
10952 {
10956 "occur when assuming that "
10958 WARN_STRICT_OVERFLOW_ALL);
10960 }
10962 /* Convert (X + c) >= X to true. */
10967 {
10971 "occur when assuming that "
10973 WARN_STRICT_OVERFLOW_ALL);
10975 }
10978 {
10979 /* Convert X + c > X and X - c < X to true for integers. */
10983 {
10986 "not occur when assuming that "
10988 WARN_STRICT_OVERFLOW_ALL);
10990 }
10995 {
10998 "not occur when assuming that "
11000 WARN_STRICT_OVERFLOW_ALL);
11002 }
11004 /* Convert X + c <= X and X - c >= X to false for integers. */
11008 {
11011 "not occur when assuming that "
11013 WARN_STRICT_OVERFLOW_ALL);
11015 }
11020 {
11023 "not occur when assuming that "
11025 WARN_STRICT_OVERFLOW_ALL);
11027 }
11028 }
11029 }
11031 /* If we are comparing an ABS_EXPR with a constant, we can
11032 convert all the cases into explicit comparisons, but they may
11033 well not be faster than doing the ABS and one comparison.
11034 But ABS (X) <= C is a range comparison, which becomes a subtraction
11035 and a comparison, and is probably faster. */
11049 /* Convert ABS_EXPR<x> >= 0 to true. */
11056 {
11059 "when simplifying comparison of "
11061 WARN_STRICT_OVERFLOW_CONDITIONAL);
11064 arg0);
11065 }
11067 /* Convert ABS_EXPR<x> < 0 to false. */
11072 {
11075 "when simplifying comparison of "
11077 WARN_STRICT_OVERFLOW_CONDITIONAL);
11080 arg0);
11081 }
11083 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11084 and similarly for >= into !=. */
11094 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11095 otherwise Y might be >= # of bits in X's type and thus e.g.
11096 (unsigned char) (1 << Y) for Y 15 might be 0.
11097 If the cast is widening, then 1 << Y should have unsigned type,
11098 otherwise if Y is number of bits in the signed shift type minus 1,
11099 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11100 31 might be 0xffffffff80000000. */
11111 {
11117 }
11129 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11130 {
11142 }
11147 /* When pedantic, a compound expression can be neither an lvalue
11148 nor an integer constant expression. */
11151 /* Don't let (0, 0) be null pointer constant. */
11157 /* An ASSERT_EXPR should never be passed to fold_binary. */
11163 }
11165 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11166 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11167 of GOTO_EXPR. */
11169 static tree
11171 {
11173 {
11180 /* fall through */
11184 }
11185 }
11187 /* Return whether the sub-tree ST contains a label which is accessible from
11188 outside the sub-tree. */
11190 static bool
11192 {
11193 return
11195 }
11197 /* Fold a ternary expression of code CODE and type TYPE with operands
11198 OP0, OP1, and OP2. Return the folded expression if folding is
11199 successful. Otherwise, return NULL_TREE. */
11201 tree
11204 {
11205 tree tem;
11212 /* If this is a commutative operation, and OP0 is a constant, move it
11213 to OP1 to reduce the number of tests below. */
11222 /* Strip any conversions that don't change the mode. This is safe
11223 for every expression, except for a comparison expression because
11224 its signedness is derived from its operands. So, in the latter
11225 case, only strip conversions that don't change the signedness.
11227 Note that this is done as an internal manipulation within the
11228 constant folder, in order to find the simplest representation of
11229 the arguments so that their form can be studied. In any cases,
11230 the appropriate type conversions should be put back in the tree
11231 that will get out of the constant folder. */
11233 {
11236 }
11239 {
11242 }
11245 {
11248 }
11251 {
11255 {
11261 }
11266 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11267 so all simple results must be passed through pedantic_non_lvalue. */
11269 {
11272 /* Only optimize constant conditions when the selected branch
11273 has the same type as the COND_EXPR. This avoids optimizing
11274 away "c ? x : throw", where the throw has a void type.
11275 Avoid throwing away that operand which contains label. */
11282 }
11284 {
11289 {
11294 {
11302 }
11306 }
11307 }
11309 /* If we have A op B ? A : C, we may be able to convert this to a
11310 simpler expression, depending on the operation and the values
11311 of B and C. Signed zeros prevent all of these transformations,
11312 for reasons given above each one.
11314 Also try swapping the arguments and inverting the conditional. */
11319 {
11323 }
11327 op2,
11330 {
11334 {
11338 }
11339 }
11341 /* If the second operand is simpler than the third, swap them
11342 since that produces better jump optimization results. */
11345 {
11347 /* See if this can be inverted. If it can't, possibly because
11348 it was a floating-point inequality comparison, don't do
11349 anything. */
11353 }
11355 /* Convert A ? 1 : 0 to simply A. */
11360 /* If we try to convert OP0 to our type, the
11361 call to fold will try to move the conversion inside
11362 a COND, which will recurse. In that case, the COND_EXPR
11363 is probably the best choice, so leave it alone. */
11367 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11368 over COND_EXPR in cases such as floating point comparisons. */
11377 arg0)));
11379 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11384 {
11385 /* sign_bit_p looks through both zero and sign extensions,
11386 but for this optimization only sign extensions are
11387 usable. */
11390 {
11393 {
11396 }
11398 }
11399 /* sign_bit_p only checks ARG1 bits within A's precision.
11400 If <sign bit of A> has wider type than A, bits outside
11401 of A's precision in <sign bit of A> need to be checked.
11402 If they are all 0, this optimization needs to be done
11403 in unsigned A's type, if they are all 1 in signed A's type,
11404 otherwise this can't be done. */
11410 {
11412 tree tem_type;
11425 {
11428 }
11430 {
11433 }
11434 else
11436 }
11439 return
11445 arg1)));
11446 }
11448 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11449 already handled above. */
11454 {
11463 }
11465 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11466 is probably obsolete because the first operand should be a
11467 truth value (that's why we have the two cases above), but let's
11468 leave it in until we can confirm this for all front-ends. */
11480 /* Disable the transformations below for vectors, since
11481 fold_binary_op_with_conditional_arg may undo them immediately,
11482 yielding an infinite loop. */
11486 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11495 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11500 {
11502 /* Only perform transformation if ARG0 is easily inverted. */
11506 ? BIT_IOR_EXPR
11509 arg1);
11510 }
11512 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11517 {
11519 /* Only perform transformation if ARG0 is easily inverted. */
11525 op2);
11526 }
11528 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11540 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11541 of fold_ternary on them. */
11549 {
11559 {
11564 {
11572 }
11573 }
11574 }
11576 /* On constants we can use native encode/interpret to constant
11577 fold (nearly) all BIT_FIELD_REFs. */
11581 {
11584 /* Limit us to a reasonable amount of work. To relax the
11585 other limitations we need bit-shifting of the buffer
11586 and rounding up the size. */
11590 {
11592 unsigned HOST_WIDE_INT len
11597 {
11602 }
11603 }
11604 }
11609 /* For integers we can decompose the FMA if possible. */
11621 {
11637 {
11642 /* Make sure that the perm value is in an acceptable
11643 range. */
11652 else
11657 }
11660 {
11665 }
11670 {
11675 }
11681 {
11685 }
11690 /* Some targets are deficient and fail to expand a single
11691 argument permutation while still allowing an equivalent
11692 2-argument version. */
11696 {
11699 }
11702 {
11709 }
11713 }
11717 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11720 {
11726 wide_int tem2
11730 }
11735 {
11737 unsigned HOST_WIDE_INT elsize
11740 {
11744 else
11745 {
11751 }
11752 }
11753 }
11759 }
11761 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11762 of an array (or vector). */
11764 tree
11766 {
11771 {
11774 {
11775 /* Static constructors for variably sized objects makes no sense. */
11779 }
11780 }
11791 offset_int max_index;
11796 {
11797 /* Array constructor might explicitly set index, or specify a range,
11798 or leave index NULL meaning that it is next index after previous
11799 one. */
11801 {
11804 else
11805 {
11809 }
11810 }
11811 else
11812 {
11818 }
11820 /* Do we have match? */
11824 }
11826 }
11828 /* Perform constant folding and related simplification of EXPR.
11829 The related simplifications include x*1 => x, x*0 => 0, etc.,
11830 and application of the associative law.
11831 NOP_EXPR conversions may be removed freely (as long as we
11832 are careful not to change the type of the overall expression).
11833 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11834 but we can constant-fold them if they have constant operands. */
11836 #ifdef ENABLE_FOLD_CHECKING
11837 # define fold(x) fold_1 (x)
11839 static
11840 #endif
11841 tree
11843 {
11847 tree tem;
11850 /* Return right away if a constant. */
11854 /* CALL_EXPR-like objects with variable numbers of operands are
11855 treated specially. */
11857 {
11859 {
11862 }
11864 }
11867 {
11872 {
11890 }
11891 }
11894 {
11896 {
11903 {
11908 }
11911 }
11913 /* Return a VECTOR_CST if possible. */
11915 {
11921 tree val;
11927 }
11935 }
11937 #ifdef ENABLE_FOLD_CHECKING
11938 #undef fold
11945 /* When --enable-checking=fold, compute a digest of expr before
11946 and after actual fold call to see if fold did not accidentally
11947 change original expr. */
11949 tree
11951 {
11952 tree ret;
11972 }
11974 void
11976 {
11987 }
11989 static void
11991 {
11993 }
11995 static void
11998 {
12004 recursive_label:
12014 {
12015 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12020 }
12028 {
12029 /* Allow these fields to be modified. */
12030 tree tmp;
12039 {
12042 }
12043 }
12054 {
12057 {
12072 }
12076 {
12089 }
12106 {
12112 }
12115 {
12117 {
12120 }
12122 }
12133 {
12136 }
12146 }
12147 }
12149 /* Helper function for outputting the checksum of a tree T. When
12150 debugging with gdb, you can "define mynext" to be "next" followed
12151 by "call debug_fold_checksum (op0)", then just trace down till the
12152 outputs differ. */
12154 DEBUG_FUNCTION void
12156 {
12171 }
12173 #endif
12175 /* Fold a unary tree expression with code CODE of type TYPE with an
12176 operand OP0. LOC is the location of the resulting expression.
12177 Return a folded expression if successful. Otherwise, return a tree
12178 expression with code CODE of type TYPE with an operand OP0. */
12180 tree
12183 {
12184 tree tem;
12185 #ifdef ENABLE_FOLD_CHECKING
12194 #endif
12200 #ifdef ENABLE_FOLD_CHECKING
12207 #endif
12209 }
12211 /* Fold a binary tree expression with code CODE of type TYPE with
12212 operands OP0 and OP1. LOC is the location of the resulting
12213 expression. Return a folded expression if successful. Otherwise,
12214 return a tree expression with code CODE of type TYPE with operands
12215 OP0 and OP1. */
12217 tree
12220 MEM_STAT_DECL)
12221 {
12222 tree tem;
12223 #ifdef ENABLE_FOLD_CHECKING
12240 #endif
12246 #ifdef ENABLE_FOLD_CHECKING
12261 #endif
12263 }
12265 /* Fold a ternary tree expression with code CODE of type TYPE with
12266 operands OP0, OP1, and OP2. Return a folded expression if
12267 successful. Otherwise, return a tree expression with code CODE of
12268 type TYPE with operands OP0, OP1, and OP2. */
12270 tree
12273 {
12274 tree tem;
12275 #ifdef ENABLE_FOLD_CHECKING
12299 #endif
12306 #ifdef ENABLE_FOLD_CHECKING
12329 #endif
12331 }
12333 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12334 arguments in ARGARRAY, and a null static chain.
12335 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12336 of type TYPE from the given operands as constructed by build_call_array. */
12338 tree
12341 {
12342 tree tem;
12343 #ifdef ENABLE_FOLD_CHECKING
12362 #endif
12368 #ifdef ENABLE_FOLD_CHECKING
12384 #endif
12386 }
12388 /* Perform constant folding and related simplification of initializer
12389 expression EXPR. These behave identically to "fold_buildN" but ignore
12390 potential run-time traps and exceptions that fold must preserve. */
12392 #define START_FOLD_INIT \
12393 int saved_signaling_nans = flag_signaling_nans;\
12394 int saved_trapping_math = flag_trapping_math;\
12395 int saved_rounding_math = flag_rounding_math;\
12396 int saved_trapv = flag_trapv;\
12397 int saved_folding_initializer = folding_initializer;\
12398 flag_signaling_nans = 0;\
12399 flag_trapping_math = 0;\
12400 flag_rounding_math = 0;\
12401 flag_trapv = 0;\
12402 folding_initializer = 1;
12404 #define END_FOLD_INIT \
12405 flag_signaling_nans = saved_signaling_nans;\
12406 flag_trapping_math = saved_trapping_math;\
12407 flag_rounding_math = saved_rounding_math;\
12408 flag_trapv = saved_trapv;\
12409 folding_initializer = saved_folding_initializer;
12411 tree
12414 {
12415 tree result;
12416 START_FOLD_INIT;
12420 END_FOLD_INIT;
12422 }
12424 tree
12427 {
12428 tree result;
12429 START_FOLD_INIT;
12433 END_FOLD_INIT;
12435 }
12437 tree
12440 {
12441 tree result;
12442 START_FOLD_INIT;
12446 END_FOLD_INIT;
12448 }
12450 #undef START_FOLD_INIT
12451 #undef END_FOLD_INIT
12453 /* Determine if first argument is a multiple of second argument. Return 0 if
12454 it is not, or we cannot easily determined it to be.
12456 An example of the sort of thing we care about (at this point; this routine
12457 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12458 fold cases do now) is discovering that
12460 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12462 is a multiple of
12464 SAVE_EXPR (J * 8)
12466 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12468 This code also handles discovering that
12470 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12472 is a multiple of 8 so we don't have to worry about dealing with a
12473 possible remainder.
12475 Note that we *look* inside a SAVE_EXPR only to determine how it was
12476 calculated; it is not safe for fold to do much of anything else with the
12477 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12478 at run time. For example, the latter example above *cannot* be implemented
12479 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12480 evaluation time of the original SAVE_EXPR is not necessarily the same at
12481 the time the new expression is evaluated. The only optimization of this
12482 sort that would be valid is changing
12484 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12486 divided by 8 to
12488 SAVE_EXPR (I) * SAVE_EXPR (J)
12490 (where the same SAVE_EXPR (J) is used in the original and the
12491 transformed version). */
12493 int
12495 {
12506 {
12508 /* Bitwise and provides a power of two multiple. If the mask is
12509 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12512 /* FALLTHRU */
12519 /* It is impossible to prove if op0 - op1 is multiple of bottom
12520 precisely, so be conservative here checking if both op0 and op1
12521 are multiple of bottom. Note we check the second operand first
12522 since it's usually simpler. */
12527 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12528 as op0 - 3 if the expression has unsigned type. For example,
12529 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12539 {
12541 /* const_binop may not detect overflow correctly,
12542 so check for it explicitly here. */
12546 size_one_node,
12547 op1)))
12550 }
12554 /* Can't handle conversions from non-integral or wider integral type. */
12560 /* fall through */
12577 SIGNED);
12583 {
12586 /* Check for special cases to see if top is defined as multiple
12587 of bottom:
12589 top = (X & ~(bottom - 1) ; bottom is power of 2
12591 or
12593 Y = X % bottom
12594 top = X - Y. */
12613 }
12615 /* fall through */
12619 }
12620 }
12622 #define tree_expr_nonnegative_warnv_p(X, Y) \
12625 #define RECURSE(X) \
12626 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12628 /* Return true if CODE or TYPE is known to be non-negative. */
12630 static bool
12632 {
12635 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12636 have a signed:1 type (where the value is -1 and 0). */
12639 }
12641 /* Return true if (CODE OP0) is known to be non-negative. If the return
12642 value is based on the assumption that signed overflow is undefined,
12643 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12644 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12646 bool
12649 {
12654 {
12656 /* We can't return 1 if flag_wrapv is set because
12657 ABS_EXPR<INT_MIN> = INT_MIN. */
12661 {
12664 }
12672 CASE_CONVERT:
12673 {
12678 {
12682 {
12686 }
12687 }
12689 {
12695 }
12696 }
12701 }
12703 /* We don't know sign of `t', so be conservative and return false. */
12705 }
12707 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12708 value is based on the assumption that signed overflow is undefined,
12709 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12710 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12712 bool
12716 {
12721 {
12727 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12728 both unsigned and at least 2 bits shorter than the result. */
12732 {
12737 {
12741 }
12742 }
12747 {
12748 /* x * x is always non-negative for floating point x
12749 or without overflow. */
12752 {
12757 }
12758 }
12760 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12761 both unsigned and their total bits is shorter than the result. */
12765 {
12784 {
12794 }
12795 }
12822 }
12824 /* We don't know sign of `t', so be conservative and return false. */
12826 }
12828 /* Return true if T is known to be non-negative. If the return
12829 value is based on the assumption that signed overflow is undefined,
12830 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12831 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12833 bool
12835 {
12840 {
12854 /* Limit the depth of recursion to avoid quadratic behavior.
12855 This is expected to catch almost all occurrences in practice.
12856 If this code misses important cases that unbounded recursion
12857 would not, passes that need this information could be revised
12858 to provide it through dataflow propagation. */
12866 }
12867 }
12869 /* Return true if T is known to be non-negative. If the return
12870 value is based on the assumption that signed overflow is undefined,
12871 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12872 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12874 bool
12877 {
12879 {
12880 CASE_CFN_ACOS:
12881 CASE_CFN_ACOSH:
12882 CASE_CFN_CABS:
12883 CASE_CFN_COSH:
12884 CASE_CFN_ERFC:
12885 CASE_CFN_EXP:
12886 CASE_CFN_EXP10:
12887 CASE_CFN_EXP2:
12888 CASE_CFN_FABS:
12889 CASE_CFN_FDIM:
12890 CASE_CFN_HYPOT:
12891 CASE_CFN_POW10:
12892 CASE_CFN_FFS:
12893 CASE_CFN_PARITY:
12894 CASE_CFN_POPCOUNT:
12895 CASE_CFN_CLZ:
12896 CASE_CFN_CLRSB:
12899 /* Always true. */
12902 CASE_CFN_SQRT:
12903 /* sqrt(-0.0) is -0.0. */
12908 CASE_CFN_ASINH:
12909 CASE_CFN_ATAN:
12910 CASE_CFN_ATANH:
12911 CASE_CFN_CBRT:
12912 CASE_CFN_CEIL:
12913 CASE_CFN_ERF:
12914 CASE_CFN_EXPM1:
12915 CASE_CFN_FLOOR:
12916 CASE_CFN_FMOD:
12917 CASE_CFN_FREXP:
12918 CASE_CFN_ICEIL:
12919 CASE_CFN_IFLOOR:
12920 CASE_CFN_IRINT:
12921 CASE_CFN_IROUND:
12922 CASE_CFN_LCEIL:
12923 CASE_CFN_LDEXP:
12924 CASE_CFN_LFLOOR:
12925 CASE_CFN_LLCEIL:
12926 CASE_CFN_LLFLOOR:
12927 CASE_CFN_LLRINT:
12928 CASE_CFN_LLROUND:
12929 CASE_CFN_LRINT:
12930 CASE_CFN_LROUND:
12931 CASE_CFN_MODF:
12932 CASE_CFN_NEARBYINT:
12933 CASE_CFN_RINT:
12934 CASE_CFN_ROUND:
12935 CASE_CFN_SCALB:
12936 CASE_CFN_SCALBLN:
12937 CASE_CFN_SCALBN:
12938 CASE_CFN_SIGNBIT:
12939 CASE_CFN_SIGNIFICAND:
12940 CASE_CFN_SINH:
12941 CASE_CFN_TANH:
12942 CASE_CFN_TRUNC:
12943 /* True if the 1st argument is nonnegative. */
12946 CASE_CFN_FMAX:
12947 /* True if the 1st OR 2nd arguments are nonnegative. */
12950 CASE_CFN_FMIN:
12951 /* True if the 1st AND 2nd arguments are nonnegative. */
12954 CASE_CFN_COPYSIGN:
12955 /* True if the 2nd argument is nonnegative. */
12958 CASE_CFN_POWI:
12959 /* True if the 1st argument is nonnegative or the second
12960 argument is an even integer. */
12966 CASE_CFN_POW:
12967 /* True if the 1st argument is nonnegative or the second
12968 argument is an even integer valued real. */
12970 {
12971 REAL_VALUE_TYPE c;
12972 HOST_WIDE_INT n;
12977 {
12978 REAL_VALUE_TYPE cint;
12982 }
12983 }
12988 }
12990 }
12992 /* Return true if T is known to be non-negative. If the return
12993 value is based on the assumption that signed overflow is undefined,
12994 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12995 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12997 static bool
12999 {
13005 {
13007 {
13011 /* If the initializer is non-void, then it's a normal expression
13012 that will be assigned to the slot. */
13016 /* Otherwise, the initializer sets the slot in some way. One common
13017 way is an assignment statement at the end of the initializer. */
13019 {
13027 else
13029 }
13035 }
13038 {
13044 arg0,
13045 arg1,
13047 }
13060 }
13061 }
13063 #undef RECURSE
13064 #undef tree_expr_nonnegative_warnv_p
13066 /* Return true if T is known to be non-negative. If the return
13067 value is based on the assumption that signed overflow is undefined,
13068 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13069 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13071 bool
13073 {
13080 {
13102 }
13105 {
13131 }
13132 }
13134 /* Return true if `t' is known to be non-negative. Handle warnings
13135 about undefined signed overflow. */
13137 bool
13139 {
13146 "determining that expression is always "
13148 WARN_STRICT_OVERFLOW_MISC);
13150 }
13153 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13154 For floating point we further ensure that T is not denormal.
13155 Similar logic is present in nonzero_address in rtlanal.h.
13157 If the return value is based on the assumption that signed overflow
13158 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13159 change *STRICT_OVERFLOW_P. */
13161 bool
13164 {
13166 {
13169 strict_overflow_p);
13172 {
13178 strict_overflow_p));
13179 }
13184 strict_overflow_p);
13188 }
13191 }
13193 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13194 For floating point we further ensure that T is not denormal.
13195 Similar logic is present in nonzero_address in rtlanal.h.
13197 If the return value is based on the assumption that signed overflow
13198 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13199 change *STRICT_OVERFLOW_P. */
13201 bool
13203 tree type,
13204 tree op0,
13206 {
13209 {
13213 {
13214 /* With the presence of negative values it is hard
13215 to say something. */
13222 /* One of operands must be positive and the other non-negative. */
13223 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13224 overflows, on a twos-complement machine the sum of two
13225 nonnegative numbers can never be zero. */
13227 strict_overflow_p)
13229 strict_overflow_p));
13230 }
13235 {
13237 strict_overflow_p)
13239 strict_overflow_p))
13240 {
13243 }
13244 }
13253 {
13256 }
13263 {
13267 /* When both operands are nonzero, then MAX must be too. */
13269 strict_overflow_p))
13272 /* MAX where operand 0 is positive is positive. */
13274 strict_overflow_p);
13275 }
13276 /* MAX where operand 1 is positive is positive. */
13281 {
13285 }
13290 strict_overflow_p)
13292 strict_overflow_p));
13296 }
13299 }
13301 /* Return true when T is an address and is known to be nonzero.
13302 For floating point we further ensure that T is not denormal.
13303 Similar logic is present in nonzero_address in rtlanal.h.
13305 If the return value is based on the assumption that signed overflow
13306 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13307 change *STRICT_OVERFLOW_P. */
13309 bool
13311 {
13314 {
13319 {
13331 /* For objects in symbol table check if we know they are non-zero.
13332 Don't do anything for variables and functions before symtab is built;
13333 it is quite possible that they will be declared weak later. */
13338 /* Constants are never weak. */
13343 }
13351 {
13355 }
13360 }
13362 }
13364 #define integer_valued_real_p(X) \
13367 #define RECURSE(X) \
13368 ((integer_valued_real_p) (X, depth + 1))
13370 /* Return true if the floating point result of (CODE OP0) has an
13371 integer value. We also allow +Inf, -Inf and NaN to be considered
13372 integer values. Return false for signaling NaN.
13374 DEPTH is the current nesting depth of the query. */
13376 bool
13378 {
13380 {
13387 CASE_CONVERT:
13388 {
13395 }
13399 }
13401 }
13403 /* Return true if the floating point result of (CODE OP0 OP1) has an
13404 integer value. We also allow +Inf, -Inf and NaN to be considered
13405 integer values. Return false for signaling NaN.
13407 DEPTH is the current nesting depth of the query. */
13409 bool
13411 {
13413 {
13423 }
13425 }
13427 /* Return true if the floating point result of calling FNDECL with arguments
13428 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13429 considered integer values. Return false for signaling NaN. If FNDECL
13430 takes fewer than 2 arguments, the remaining ARGn are null.
13432 DEPTH is the current nesting depth of the query. */
13434 bool
13436 {
13438 {
13439 CASE_CFN_CEIL:
13440 CASE_CFN_FLOOR:
13441 CASE_CFN_NEARBYINT:
13442 CASE_CFN_RINT:
13443 CASE_CFN_ROUND:
13444 CASE_CFN_TRUNC:
13447 CASE_CFN_FMIN:
13448 CASE_CFN_FMAX:
13453 }
13455 }
13457 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13458 has an integer value. We also allow +Inf, -Inf and NaN to be
13459 considered integer values. Return false for signaling NaN.
13461 DEPTH is the current nesting depth of the query. */
13463 bool
13465 {
13467 {
13475 /* Limit the depth of recursion to avoid quadratic behavior.
13476 This is expected to catch almost all occurrences in practice.
13477 If this code misses important cases that unbounded recursion
13478 would not, passes that need this information could be revised
13479 to provide it through dataflow propagation. */
13483 depth));
13487 }
13489 }
13491 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13492 has an integer value. We also allow +Inf, -Inf and NaN to be
13493 considered integer values. Return false for signaling NaN.
13495 DEPTH is the current nesting depth of the query. */
13497 static bool
13499 {
13501 {
13512 }
13514 }
13516 #undef RECURSE
13517 #undef integer_valued_real_p
13519 /* Return true if the floating point expression T has an integer value.
13520 We also allow +Inf, -Inf and NaN to be considered integer values.
13521 Return false for signaling NaN.
13523 DEPTH is the current nesting depth of the query. */
13525 bool
13527 {
13533 {
13549 }
13552 {
13558 {
13567 }
13571 }
13572 }
13574 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13575 attempt to fold the expression to a constant without modifying TYPE,
13576 OP0 or OP1.
13578 If the expression could be simplified to a constant, then return
13579 the constant. If the expression would not be simplified to a
13580 constant, then return NULL_TREE. */
13582 tree
13584 {
13587 }
13589 /* Given the components of a unary expression CODE, TYPE and OP0,
13590 attempt to fold the expression to a constant without modifying
13591 TYPE or OP0.
13593 If the expression could be simplified to a constant, then return
13594 the constant. If the expression would not be simplified to a
13595 constant, then return NULL_TREE. */
13597 tree
13599 {
13602 }
13604 /* If EXP represents referencing an element in a constant string
13605 (either via pointer arithmetic or array indexing), return the
13606 tree representing the value accessed, otherwise return NULL. */
13608 tree
13610 {
13614 {
13616 tree index;
13617 tree string;
13622 else
13623 {
13627 /* Optimize the special-case of a zero lower bound.
13629 We convert the low_bound to sizetype to avoid some problems
13630 with constant folding. (E.g. suppose the lower bound is 1,
13631 and its mode is QI. Without the conversion,l (ARRAY
13632 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13633 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13639 }
13652 }
13654 }
13656 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13657 an integer constant, real, or fixed-point constant.
13659 TYPE is the type of the result. */
13661 static tree
13663 {
13667 {
13669 {
13676 }
13683 {
13684 FIXED_VALUE_TYPE f;
13689 /* Propagate overflow flags. */
13693 }
13697 }
13700 }
13702 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13703 an integer constant or real constant.
13705 TYPE is the type of the result. */
13707 tree
13709 {
13713 {
13715 {
13716 /* If the value is unsigned or non-negative, then the absolute value
13717 is the same as the ordinary value. */
13721 /* If the value is negative, then the absolute value is
13722 its negation. */
13723 else
13724 {
13729 }
13730 }
13736 else
13742 }
13745 }
13747 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13748 constant. TYPE is the type of the result. */
13750 static tree
13752 {
13756 }
13758 /* Given CODE, a relational operator, the target type, TYPE and two
13759 constant operands OP0 and OP1, return the result of the
13760 relational operation. If the result is not a compile time
13761 constant, then return NULL_TREE. */
13763 static tree
13765 {
13768 /* From here on, the only cases we handle are when the result is
13769 known to be a constant. */
13772 {
13776 /* Handle the cases where either operand is a NaN. */
13778 {
13780 {
13808 }
13811 }
13814 }
13817 {
13821 }
13823 /* Handle equality/inequality of complex constants. */
13825 {
13836 else
13838 }
13841 {
13843 {
13844 /* Have vector comparison with scalar boolean result. */
13848 {
13856 }
13858 }
13865 {
13877 }
13880 }
13882 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13884 To compute GT, swap the arguments and do LT.
13885 To compute GE, do LT and invert the result.
13886 To compute LE, swap the arguments, do LT and invert the result.
13887 To compute NE, do EQ and invert the result.
13889 Therefore, the code below must handle only EQ and LT. */
13892 {
13895 }
13897 /* Note that it is safe to invert for real values here because we
13898 have already handled the one case that it matters. */
13902 {
13905 }
13907 /* Compute a result for LT or EQ if args permit;
13908 Otherwise return T. */
13910 {
13913 else
13915 }
13916 else
13922 }
13924 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13925 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13926 itself. */
13928 tree
13930 {
13931 /* If the expression does not have side effects then we don't have to wrap
13932 it with a cleanup point expression. */
13936 /* If the expression is a return, check to see if the expression inside the
13937 return has no side effects or the right hand side of the modify expression
13938 inside the return. If either don't have side effects set we don't need to
13939 wrap the expression in a cleanup point expression. Note we don't check the
13940 left hand side of the modify because it should always be a return decl. */
13942 {
13949 }
13952 }
13954 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13955 of an indirection through OP0, or NULL_TREE if no simplification is
13956 possible. */
13958 tree
13960 {
13962 tree subtype;
13970 {
13973 /* *&CONST_DECL -> to the value of the const decl. */
13976 /* *&p => p; make sure to handle *&"str"[cst] here. */
13978 {
13982 else
13984 }
13985 /* *(foo *)&fooarray => fooarray[0] */
13988 && (!in_gimple_form
13990 {
14000 }
14001 /* *(foo *)&complexfoo => __real__ complexfoo */
14005 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14008 {
14012 }
14013 }
14017 {
14023 {
14024 tree op00type;
14028 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14031 {
14033 unsigned HOST_WIDE_INT max_offset
14038 {
14045 }
14046 }
14047 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14050 {
14054 }
14055 /* ((foo *)&fooarray)[1] => fooarray[1] */
14058 {
14068 }
14069 }
14070 }
14072 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14075 && (!in_gimple_form
14077 {
14078 tree type_domain;
14088 NULL_TREE);
14089 }
14092 }
14094 /* Builds an expression for an indirection through T, simplifying some
14095 cases. */
14097 tree
14099 {
14107 }
14109 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14111 tree
14113 {
14118 else
14120 }
14122 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14123 whose result is ignored. The type of the returned tree need not be
14124 the same as the original expression. */
14126 tree
14128 {
14134 {
14145 else
14151 {
14167 }
14172 }
14173 }
14175 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14177 tree
14179 {
14185 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14186 have to do anything. Only do this when we are not given a const,
14187 because in that case, this check is more expensive than just
14188 doing it. */
14190 {
14195 }
14197 /* If divisor is a power of two, simplify this to bit manipulation. */
14199 {
14201 {
14215 }
14216 else
14217 {
14218 tree t;
14224 }
14225 }
14226 else
14227 {
14232 }
14235 }
14237 /* Likewise, but round down. */
14239 tree
14241 {
14248 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14249 have to do anything. Only do this when we are not given a const,
14250 because in that case, this check is more expensive than just
14251 doing it. */
14253 {
14258 }
14260 /* If divisor is a power of two, simplify this to bit manipulation. */
14262 {
14263 tree t;
14267 }
14268 else
14269 {
14274 }
14277 }
14279 /* Returns the pointer to the base of the object addressed by EXP and
14280 extracts the information about the offset of the access, storing it
14281 to PBITPOS and POFFSET. */
14283 static tree
14286 {
14287 tree core;
14288 machine_mode mode;
14290 HOST_WIDE_INT bitsize;
14294 {
14299 }
14300 else
14301 {
14305 }
14308 }
14310 /* Returns true if addresses of E1 and E2 differ by a constant, false
14311 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14313 bool
14315 {
14329 {
14339 }
14341 {
14342 /* If only one of the offsets is non-constant, the difference cannot
14343 be a constant. */
14345 }
14346 else
14351 }
14353 /* Return OFF converted to a pointer offset type suitable as offset for
14354 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14355 tree
14357 {
14359 }
14361 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14362 tree
14364 {
14367 }
14369 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14370 tree
14372 {
14375 }
14377 /* Return a char pointer for a C string if it is a string constant
14378 or sum of string constant and integer constant. We only support
14379 string constants properly terminated with '\0' character.
14380 If STRLEN is a valid pointer, length (including terminating character)
14381 of returned string is stored to the argument. */
14385 {
14386 tree offset_node;
14397 {
14400 else
14402 }
14407 /* Support only properly null-terminated strings. */
14416 }
14418 #if CHECKING_P
14422 /* Helper functions for writing tests of folding trees. */
14424 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14426 static void
14428 tree constant)
14429 {
14431 }
14433 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14434 wrapping WRAPPED_EXPR. */
14436 static void
14438 tree wrapped_expr)
14439 {
14444 }
14446 /* Verify that various arithmetic binary operations are folded
14447 correctly. */
14449 static void
14451 {
14457 /* Addition. */
14458 /* 1 <-- (0 + 1) */
14460 one);
14462 one);
14464 /* (nonlvalue)x <-- (x + 0) */
14466 x);
14468 /* Subtraction. */
14469 /* 0 <-- (x - x) */
14471 zero);
14473 x);
14475 /* Multiplication. */
14476 /* 0 <-- (x * 0) */
14478 zero);
14480 /* (nonlvalue)x <-- (x * 1) */
14482 x);
14483 }
14485 /* Verify that various binary operations on vectors are folded
14486 correctly. */
14488 static void
14490 {
14496 /* Verify equality tests that return a scalar boolean result. */
14502 }
14504 /* Run all of the selftests within this file. */
14506 void
14508 {
14511 }