| blob | 2a08010d1455041e9c455efa16520b0c1fbb8f1c |
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. */
86 /* Nonzero if we are folding constants inside an initializer; zero
87 otherwise. */
90 /* The following constants represent a bit based encoding of GCC's
91 comparison operators. This encoding simplifies transformations
92 on relational comparison operators, such as AND and OR. */
110 };
143 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
144 Otherwise, return LOC. */
146 static location_t
148 {
151 }
153 /* Similar to protected_set_expr_location, but never modify x in place,
154 if location can and needs to be set, unshare it. */
158 {
164 {
167 }
169 }
170 \f
171 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
172 division and returns the quotient. Otherwise returns
173 NULL_TREE. */
175 tree
177 {
178 widest_int quo;
185 }
186 \f
187 /* This is nonzero if we should defer warnings about undefined
188 overflow. This facility exists because these warnings are a
189 special case. The code to estimate loop iterations does not want
190 to issue any warnings, since it works with expressions which do not
191 occur in user code. Various bits of cleanup code call fold(), but
192 only use the result if it has certain characteristics (e.g., is a
193 constant); that code only wants to issue a warning if the result is
194 used. */
198 /* If a warning about undefined overflow is deferred, this is the
199 warning. Note that this may cause us to turn two warnings into
200 one, but that is fine since it is sufficient to only give one
201 warning per expression. */
205 /* If a warning about undefined overflow is deferred, this is the
206 level at which the warning should be emitted. */
210 /* Start deferring overflow warnings. We could use a stack here to
211 permit nested calls, but at present it is not necessary. */
213 void
215 {
217 }
219 /* Stop deferring overflow warnings. If there is a pending warning,
220 and ISSUE is true, then issue the warning if appropriate. STMT is
221 the statement with which the warning should be associated (used for
222 location information); STMT may be NULL. CODE is the level of the
223 warning--a warn_strict_overflow_code value. This function will use
224 the smaller of CODE and the deferred code when deciding whether to
225 issue the warning. CODE may be zero to mean to always use the
226 deferred code. */
228 void
230 {
232 location_t locus;
237 {
243 }
254 /* Use the smallest code level when deciding to issue the
255 warning. */
264 else
267 }
269 /* Stop deferring overflow warnings, ignoring any deferred
270 warnings. */
272 void
274 {
276 }
278 /* Whether we are deferring overflow warnings. */
280 bool
282 {
284 }
286 /* This is called when we fold something based on the fact that signed
287 overflow is undefined. */
289 void
291 {
293 {
296 {
299 }
300 }
303 }
304 \f
305 /* Return true if the built-in mathematical function specified by CODE
306 is odd, i.e. -f(x) == f(-x). */
308 bool
310 {
312 {
313 CASE_CFN_ASIN:
314 CASE_CFN_ASINH:
315 CASE_CFN_ATAN:
316 CASE_CFN_ATANH:
317 CASE_CFN_CASIN:
318 CASE_CFN_CASINH:
319 CASE_CFN_CATAN:
320 CASE_CFN_CATANH:
321 CASE_CFN_CBRT:
322 CASE_CFN_CPROJ:
323 CASE_CFN_CSIN:
324 CASE_CFN_CSINH:
325 CASE_CFN_CTAN:
326 CASE_CFN_CTANH:
327 CASE_CFN_ERF:
328 CASE_CFN_LLROUND:
329 CASE_CFN_LROUND:
330 CASE_CFN_ROUND:
331 CASE_CFN_SIN:
332 CASE_CFN_SINH:
333 CASE_CFN_TAN:
334 CASE_CFN_TANH:
335 CASE_CFN_TRUNC:
338 CASE_CFN_LLRINT:
339 CASE_CFN_LRINT:
340 CASE_CFN_NEARBYINT:
341 CASE_CFN_RINT:
346 }
348 }
350 /* Check whether we may negate an integer constant T without causing
351 overflow. */
353 bool
355 {
356 tree type;
365 }
367 /* Determine whether an expression T can be cheaply negated using
368 the function negate_expr without introducing undefined overflow. */
370 static bool
372 {
373 tree type;
382 {
387 /* Check that -CST will not overflow type. */
400 /* We want to canonicalize to positive real constants. Pretend
401 that only negative ones can be easily negated. */
409 {
413 /* Steps don't prevent negation. */
420 }
435 /* -(A + B) -> (-B) - A. */
438 /* -(A + B) -> (-A) - B. */
442 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
451 /* INT_MIN/n * n doesn't overflow while negating one operand it does
452 if n is a (negative) power of two. */
463 /* Fall through. */
478 /* In general we can't negate B in A / B, because if A is INT_MIN and
479 B is 1, we may turn this into INT_MIN / -1 which is undefined
480 and actually traps on some architectures. */
489 /* Negate -((double)float) as (double)(-float). */
491 {
495 }
499 /* Negate -f(x) as f(-x). */
505 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
507 {
511 }
516 }
518 }
520 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
521 simplification is possible.
522 If negate_expr_p would return true for T, NULL_TREE will never be
523 returned. */
525 static tree
527 {
529 tree tem;
532 {
533 /* Convert - (~A) to A + 1. */
559 {
564 }
568 {
569 tree_vector_builder elts;
573 {
578 }
581 }
604 {
605 /* -(A + B) -> (-B) - A. */
607 {
611 }
613 /* -(A + B) -> (-A) - B. */
615 {
619 }
620 }
624 /* - (A - B) -> B - A */
635 /* Fall through. */
639 {
648 }
660 /* In general we can't negate B in A / B, because if A is INT_MIN and
661 B is 1, we may turn this into INT_MIN / -1 which is undefined
662 and actually traps on some architectures. */
674 /* Convert -((double)float) into (double)(-float). */
676 {
680 }
684 /* Negate -f(x) as f(-x). */
687 {
693 }
697 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
699 {
702 {
709 }
710 }
715 }
718 }
720 /* A wrapper for fold_negate_expr_1. */
722 static tree
724 {
731 }
733 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
734 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
735 return NULL_TREE. */
737 static tree
739 {
741 location_t loc;
754 }
755 \f
756 /* Split a tree IN into a constant, literal and variable parts that could be
757 combined with CODE to make IN. "constant" means an expression with
758 TREE_CONSTANT but that isn't an actual constant. CODE must be a
759 commutative arithmetic operation. Store the constant part into *CONP,
760 the literal in *LITP and return the variable part. If a part isn't
761 present, set it to null. If the tree does not decompose in this way,
762 return the entire tree as the variable part and the other parts as null.
764 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
765 case, we negate an operand that was subtracted. Except if it is a
766 literal for which we use *MINUS_LITP instead.
768 If NEGATE_P is true, we are negating all of IN, again except a literal
769 for which we use *MINUS_LITP instead. If a variable part is of pointer
770 type, it is negated after converting to TYPE. This prevents us from
771 generating illegal MINUS pointer expression. LOC is the location of
772 the converted variable part.
774 If IN is itself a literal or constant, return it as appropriate.
776 Note that we do not guarantee that any of the three values will be the
777 same type as IN, but they will have the same signedness and mode. */
779 static tree
783 {
791 /* Strip any conversions that don't change the machine mode or signedness. */
800 /* We can associate addition and subtraction together (even
801 though the C standard doesn't say so) for integers because
802 the value is not affected. For reals, the value might be
803 affected, so we can't. */
809 {
815 /* First see if either of the operands is a literal, then a constant. */
828 /* If we haven't dealt with either operand, this is not a case we can
829 decompose. Otherwise, VAR is either of the ones remaining, if any. */
834 else
837 /* Now do any needed negations. */
844 }
849 {
850 /* -1 - X is folded to ~X, undo that here. Do _not_ do this
851 when IN is constant. */
854 }
855 else
859 {
872 }
882 }
884 /* Re-associate trees split by the above function. T1 and T2 are
885 either expressions to associate or null. Return the new
886 expression, if any. LOC is the location of the new expression. If
887 we build an operation, do it in TYPE and with CODE. */
889 static tree
891 {
893 {
896 }
900 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
901 try to fold this since we will have infinite recursion. But do
902 deal with any NEGATE_EXPRs. */
906 {
908 {
921 }
923 {
926 }
930 }
934 }
935 \f
936 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
937 for use in int_const_binop, size_binop and size_diffop. */
939 static bool
941 {
948 {
957 }
962 }
965 /* Combine two integer constants PARG1 and PARG2 under operation CODE
966 to produce a new constant. Return NULL_TREE if we don't know how
967 to evaluate CODE at compile-time. */
969 static tree
972 {
973 wide_int res;
974 tree t;
983 {
999 {
1003 else
1005 }
1008 /* It's unclear from the C standard whether shifts can overflow.
1009 The following code ignores overflow; perhaps a C standard
1010 interpretation ruling is needed. */
1012 else
1019 {
1023 else
1025 }
1029 else
1108 }
1116 }
1118 tree
1120 {
1122 }
1124 /* Return true if binary operation OP distributes over addition in operand
1125 OPNO, with the other operand being held constant. OPNO counts from 1. */
1127 static bool
1129 {
1131 {
1142 }
1143 }
1145 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1146 constant. We assume ARG1 and ARG2 have the same data type, or at least
1147 are the same kind of constant and the same machine mode. Return zero if
1148 combining the constants is not allowed in the current operating mode. */
1150 static tree
1152 {
1153 /* Sanity check for the recursive cases. */
1161 {
1167 }
1170 {
1171 machine_mode mode;
1172 REAL_VALUE_TYPE d1;
1173 REAL_VALUE_TYPE d2;
1174 REAL_VALUE_TYPE value;
1175 REAL_VALUE_TYPE result;
1179 /* The following codes are handled by real_arithmetic. */
1181 {
1192 }
1200 /* Don't perform operation if we honor signaling NaNs and
1201 either operand is a signaling NaN. */
1207 /* Don't perform operation if it would raise a division
1208 by zero exception. */
1214 /* If either operand is a NaN, just return it. Otherwise, set up
1215 for floating-point trap; we return an overflow. */
1217 {
1218 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1219 is off. */
1223 }
1225 {
1226 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1227 is off. */
1231 }
1236 /* Don't constant fold this floating point operation if
1237 the result has overflowed and flag_trapping_math. */
1245 /* Don't constant fold this floating point operation if the
1246 result may dependent upon the run-time rounding mode and
1247 flag_rounding_math is set, or if GCC's software emulation
1248 is unable to accurately represent the result. */
1258 }
1261 {
1262 FIXED_VALUE_TYPE f1;
1263 FIXED_VALUE_TYPE f2;
1264 FIXED_VALUE_TYPE result;
1269 /* The following codes are handled by fixed_arithmetic. */
1271 {
1283 {
1290 }
1295 }
1302 /* Propagate overflow flags. */
1306 }
1309 {
1318 {
1329 mpc_mul);
1343 mpc_div);
1344 /* Fallthru. */
1350 {
1351 /* Keep this algorithm in sync with
1352 tree-complex.c:expand_complex_div_straight().
1354 Expand complex division to scalars, straightforward algorithm.
1355 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1356 t = br*br + bi*bi
1357 */
1358 tree magsquared
1362 tree t1
1366 tree t2
1373 }
1374 else
1375 {
1376 /* Keep this algorithm in sync with
1377 tree-complex.c:expand_complex_div_wide().
1379 Expand complex division to scalars, modified algorithm to minimize
1380 overflow with wide input ranges. */
1386 {
1387 /* In the TRUE branch, we compute
1388 ratio = br/bi;
1389 div = (br * ratio) + bi;
1390 tr = (ar * ratio) + ai;
1391 ti = (ai * ratio) - ar;
1392 tr = tr / div;
1393 ti = ti / div; */
1404 }
1405 else
1406 {
1407 /* In the FALSE branch, we compute
1408 ratio = d/c;
1409 divisor = (d * ratio) + c;
1410 tr = (b * ratio) + a;
1411 ti = b - (a * ratio);
1412 tr = tr / div;
1413 ti = ti / div; */
1425 }
1426 }
1431 }
1435 }
1441 {
1446 /* We can operate directly on the encoding if:
1448 a3 - a2 == a2 - a1 && b3 - b2 == b2 - b1
1449 implies
1450 (a3 op b3) - (a2 op b2) == (a2 op b2) - (a1 op b1)
1452 Addition and subtraction are the supported operators
1453 for which this is true. */
1456 /* We can operate directly on stepped encodings if:
1458 a3 - a2 == a2 - a1
1459 implies:
1460 (a3 op c) - (a2 op c) == (a2 op c) - (a1 op c)
1462 which is true if (x -> x op c) distributes over addition. */
1464 else
1465 /* Similarly in reverse. */
1467 tree_vector_builder elts;
1472 {
1478 /* It is possible that const_binop cannot handle the given
1479 code and return NULL_TREE */
1483 }
1486 }
1488 /* Shifts allow a scalar offset for a vector. */
1491 {
1494 tree_vector_builder elts;
1499 {
1504 /* It is possible that const_binop cannot handle the given
1505 code and return NULL_TREE. */
1509 }
1512 }
1514 }
1516 /* Overload that adds a TYPE parameter to be able to dispatch
1517 to fold_relational_const. */
1519 tree
1521 {
1525 /* ??? Until we make the const_binop worker take the type of the
1526 result as argument put those cases that need it here. */
1528 {
1545 {
1550 }
1555 {
1569 {
1579 }
1582 }
1588 {
1610 {
1623 }
1626 }
1629 }
1634 /* Make sure type and arg0 have the same saturating flag. */
1639 }
1641 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1642 Return zero if computing the constants is not possible. */
1644 tree
1646 {
1647 /* Don't perform the operation, other than NEGATE and ABS, if
1648 flag_signaling_nans is on and the operand is a signaling NaN. */
1657 {
1658 CASE_CONVERT:
1665 /* If the source address is 0, and the source address space
1666 cannot have a valid object at 0, fold to dest type null. */
1677 {
1678 /* Can't call fold_negate_const directly here as that doesn't
1679 handle all cases and we might not be able to negate some
1680 constants. */
1685 }
1694 {
1698 }
1704 /* Perform BIT_NOT_EXPR on each element individually. */
1706 {
1707 tree elem;
1709 /* This can cope with stepped encodings because ~x == -1 - x. */
1710 tree_vector_builder elements;
1714 {
1720 }
1723 }
1745 {
1763 else
1768 {
1774 }
1777 }
1786 }
1789 }
1791 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1792 indicates which particular sizetype to create. */
1794 tree
1796 {
1798 }
1799 \f
1800 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1801 is a tree code. The type of the result is taken from the operands.
1802 Both must be equivalent integer types, ala int_binop_types_match_p.
1803 If the operands are constant, so is the result. */
1805 tree
1807 {
1816 /* Handle the special case of two integer constants faster. */
1818 {
1819 /* And some specific cases even faster than that. */
1821 {
1826 }
1828 {
1831 }
1833 {
1836 }
1838 /* Handle general case of two integer constants. For sizetype
1839 constant calculations we always want to know about overflow,
1840 even in the unsigned case. */
1842 }
1845 }
1847 /* Given two values, either both of sizetype or both of bitsizetype,
1848 compute the difference between the two values. Return the value
1849 in signed type corresponding to the type of the operands. */
1851 tree
1853 {
1855 tree ctype;
1860 /* If the type is already signed, just do the simple thing. */
1868 else
1871 /* If either operand is not a constant, do the conversions to the signed
1872 type and subtract. The hardware will do the right thing with any
1873 overflow in the subtraction. */
1879 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1880 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1881 overflow) and negate (which can't either). Special-case a result
1882 of zero while we're here. */
1888 else
1892 MINUS_EXPR,
1894 }
1895 \f
1896 /* A subroutine of fold_convert_const handling conversions of an
1897 INTEGER_CST to another integer type. */
1899 static tree
1901 {
1902 /* Given an integer constant, make new constant with new type,
1903 appropriately sign-extended or truncated. Use widest_int
1904 so that any extension is done according ARG1's type. */
1908 }
1910 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1911 to an integer type. */
1913 static tree
1915 {
1917 tree t;
1919 /* The following code implements the floating point to integer
1920 conversion rules required by the Java Language Specification,
1921 that IEEE NaNs are mapped to zero and values that overflow
1922 the target precision saturate, i.e. values greater than
1923 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1924 are mapped to INT_MIN. These semantics are allowed by the
1925 C and C++ standards that simply state that the behavior of
1926 FP-to-integer conversion is unspecified upon overflow. */
1928 wide_int val;
1929 REAL_VALUE_TYPE r;
1933 {
1940 }
1942 /* If R is NaN, return zero and show we have an overflow. */
1944 {
1947 }
1949 /* See if R is less than the lower bound or greater than the
1950 upper bound. */
1953 {
1957 {
1960 }
1961 }
1964 {
1967 {
1970 {
1973 }
1974 }
1975 }
1982 }
1984 /* A subroutine of fold_convert_const handling conversions of a
1985 FIXED_CST to an integer type. */
1987 static tree
1989 {
1990 tree t;
1992 scalar_mode mode;
1994 /* Right shift FIXED_CST to temp by fbit. */
1998 {
2000 HOST_BITS_PER_DOUBLE_INT,
2003 /* Left shift temp to temp_trunc by fbit. */
2005 HOST_BITS_PER_DOUBLE_INT,
2007 }
2008 else
2009 {
2012 }
2014 /* If FIXED_CST is negative, we need to round the value toward 0.
2015 By checking if the fractional bits are not zero to add 1 to temp. */
2021 /* Given a fixed-point constant, make new constant with new type,
2022 appropriately sign-extended or truncated. */
2030 }
2032 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2033 to another floating point type. */
2035 static tree
2037 {
2038 REAL_VALUE_TYPE value;
2039 tree t;
2041 /* Don't perform the operation if flag_signaling_nans is on
2042 and the operand is a signaling NaN. */
2050 /* If converting an infinity or NAN to a representation that doesn't
2051 have one, set the overflow bit so that we can produce some kind of
2052 error message at the appropriate point if necessary. It's not the
2053 most user-friendly message, but it's better than nothing. */
2060 /* Regular overflow, conversion produced an infinity in a mode that
2061 can't represent them. */
2066 else
2069 }
2071 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2072 to a floating point type. */
2074 static tree
2076 {
2077 REAL_VALUE_TYPE value;
2078 tree t;
2086 }
2088 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2089 to another fixed-point type. */
2091 static tree
2093 {
2094 FIXED_VALUE_TYPE value;
2095 tree t;
2102 /* Propagate overflow flags. */
2106 }
2108 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2109 to a fixed-point type. */
2111 static tree
2113 {
2114 FIXED_VALUE_TYPE value;
2115 tree t;
2117 double_int di;
2124 else
2132 /* Propagate overflow flags. */
2136 }
2138 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2139 to a fixed-point type. */
2141 static tree
2143 {
2144 FIXED_VALUE_TYPE value;
2145 tree t;
2153 /* Propagate overflow flags. */
2157 }
2159 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2160 type TYPE. If no simplification can be done return NULL_TREE. */
2162 static tree
2164 {
2170 {
2177 }
2179 {
2186 }
2188 {
2195 }
2197 {
2200 {
2203 /* We can't handle steps directly when extending, since the
2204 values need to wrap at the original precision first. */
2205 bool step_ok_p
2209 tree_vector_builder v;
2214 {
2220 }
2222 }
2223 }
2225 }
2227 /* Construct a vector of zero elements of vector type TYPE. */
2229 static tree
2231 {
2232 tree t;
2236 }
2238 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2240 bool
2242 {
2257 {
2272 }
2273 }
2275 /* Convert expression ARG to type TYPE. Used by the middle-end for
2276 simple conversions in preference to calling the front-end's convert. */
2278 tree
2280 {
2282 tree tem;
2293 {
2296 /* Handle conversions between pointers to different address spaces. */
2301 /* fall through */
2306 {
2310 }
2324 {
2328 }
2330 {
2334 }
2336 {
2340 }
2343 {
2361 }
2366 {
2370 }
2373 {
2387 }
2391 {
2400 integer_zero_node));
2402 {
2406 {
2412 }
2420 }
2424 }
2442 }
2443 fold_convert_exit:
2446 }
2447 \f
2448 /* Return false if expr can be assumed not to be an lvalue, true
2449 otherwise. */
2451 static bool
2453 {
2454 /* We only need to wrap lvalue tree codes. */
2456 {
2487 /* Assume the worst for front-end tree codes. */
2491 }
2494 }
2496 /* Return an expr equal to X but certainly not valid as an lvalue. */
2498 tree
2500 {
2501 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2502 us. */
2509 }
2511 /* When pedantic, return an expr equal to X but certainly not valid as a
2512 pedantic lvalue. Otherwise, return X. */
2514 static tree
2516 {
2518 }
2519 \f
2520 /* Given a tree comparison code, return the code that is the logical inverse.
2521 It is generally not safe to do this for floating-point comparisons, except
2522 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2523 ERROR_MARK in this case. */
2525 enum tree_code
2527 {
2533 {
2564 }
2565 }
2567 /* Similar, but return the comparison that results if the operands are
2568 swapped. This is safe for floating-point. */
2570 enum tree_code
2572 {
2574 {
2600 }
2601 }
2604 /* Convert a comparison tree code from an enum tree_code representation
2605 into a compcode bit-based encoding. This function is the inverse of
2606 compcode_to_comparison. */
2608 static enum comparison_code
2610 {
2612 {
2643 }
2644 }
2646 /* Convert a compcode bit-based encoding of a comparison operator back
2647 to GCC's enum tree_code representation. This function is the
2648 inverse of comparison_to_compcode. */
2650 static enum tree_code
2652 {
2654 {
2685 }
2686 }
2688 /* Return a tree for the comparison which is the combination of
2689 doing the AND or OR (depending on CODE) of the two operations LCODE
2690 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2691 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2692 if this makes the transformation invalid. */
2694 tree
2699 {
2706 {
2717 }
2720 {
2721 /* Eliminate unordered comparisons, as well as LTGT and ORD
2722 which are not used unless the mode has NaNs. */
2728 }
2730 {
2731 /* Check that the original operation and the optimized ones will trap
2732 under the same condition. */
2743 /* In a short-circuited boolean expression the LHS might be
2744 such that the RHS, if evaluated, will never trap. For
2745 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2746 if neither x nor y is NaN. (This is a mixed blessing: for
2747 example, the expression above will never trap, hence
2748 optimizing it to x < y would be invalid). */
2753 /* If the comparison was short-circuited, and only the RHS
2754 trapped, we may now generate a spurious trap. */
2759 /* If we changed the conditions that cause a trap, we lose. */
2762 }
2768 else
2769 {
2774 }
2775 }
2776 \f
2777 /* Return nonzero if two operands (typically of the same tree node)
2778 are necessarily equal. FLAGS modifies behavior as follows:
2780 If OEP_ONLY_CONST is set, only return nonzero for constants.
2781 This function tests whether the operands are indistinguishable;
2782 it does not test whether they are equal using C's == operation.
2783 The distinction is important for IEEE floating point, because
2784 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2785 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2787 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2788 even though it may hold multiple values during a function.
2789 This is because a GCC tree node guarantees that nothing else is
2790 executed between the evaluation of its "operands" (which may often
2791 be evaluated in arbitrary order). Hence if the operands themselves
2792 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2793 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2794 unset means assuming isochronic (or instantaneous) tree equivalence.
2795 Unless comparing arbitrary expression trees, such as from different
2796 statements, this flag can usually be left unset.
2798 If OEP_PURE_SAME is set, then pure functions with identical arguments
2799 are considered the same. It is used when the caller has other ways
2800 to ensure that global memory is unchanged in between.
2802 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2803 not values of expressions.
2805 If OEP_LEXICOGRAPHIC is set, then also handle expressions with side-effects
2806 such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
2808 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2809 any operand with side effect. This is unnecesarily conservative in the
2810 case we know that arg0 and arg1 are in disjoint code paths (such as in
2811 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2812 addresses with TREE_CONSTANT flag set so we know that &var == &var
2813 even if var is volatile. */
2815 int
2817 {
2818 /* When checking, verify at the outermost operand_equal_p call that
2819 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2820 hash value. */
2822 {
2824 {
2826 {
2833 }
2835 }
2836 else
2838 }
2840 /* If either is ERROR_MARK, they aren't equal. */
2846 /* Similar, if either does not have a type (like a released SSA name),
2847 they aren't equal. */
2851 /* We cannot consider pointers to different address space equal. */
2858 /* Check equality of integer constants before bailing out due to
2859 precision differences. */
2861 {
2862 /* Address of INTEGER_CST is not defined; check that we did not forget
2863 to drop the OEP_ADDRESS_OF flags. */
2866 }
2869 {
2870 /* If both types don't have the same signedness, then we can't consider
2871 them equal. We must check this before the STRIP_NOPS calls
2872 because they may change the signedness of the arguments. As pointers
2873 strictly don't have a signedness, require either two pointers or
2874 two non-pointers as well. */
2880 /* If both types don't have the same precision, then it is not safe
2881 to strip NOPs. */
2888 }
2889 #if 0
2890 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2891 sanity check once the issue is solved. */
2892 else
2893 /* Addresses of conversions and SSA_NAMEs (and many other things)
2894 are not defined. Check that we did not forget to drop the
2895 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2898 #endif
2900 /* In case both args are comparisons but with different comparison
2901 code, try to swap the comparison operands of one arg to produce
2902 a match and compare that variant. */
2906 {
2914 }
2917 {
2918 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2920 ;
2922 {
2923 /* If we are interested in comparing addresses ignore
2924 MEM_REF wrappings of the base that can appear just for
2925 TBAA reasons. */
2939 }
2940 else
2942 }
2944 /* When not checking adddresses, this is needed for conversions and for
2945 COMPONENT_REF. Might as well play it safe and always test this. */
2952 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2953 We don't care about side effects in that case because the SAVE_EXPR
2954 takes care of that for us. In all other cases, two expressions are
2955 equal if they have no side effects. If we have two identical
2956 expressions with side effects that should be treated the same due
2957 to the only side effects being identical SAVE_EXPR's, that will
2958 be detected in the recursive calls below.
2959 If we are taking an invariant address of two identical objects
2960 they are necessarily equal as well. */
2967 /* Next handle constant cases, those for which we can return 1 even
2968 if ONLY_CONST is set. */
2971 {
2985 {
2986 /* If we do not distinguish between signed and unsigned zero,
2987 consider them equal. */
2990 }
2994 {
3009 }
3013 flags)
3015 flags));
3026 flags | OEP_ADDRESS_OF
3029 /* In GIMPLE empty constructors are allowed in initializers of
3030 aggregates. */
3034 }
3039 /* Define macros to test an operand from arg0 and arg1 for equality and a
3040 variant that allows null and views null as being different from any
3041 non-null value. In the latter case, if either is null, the both
3042 must be; otherwise, do the normal comparison. */
3043 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3044 TREE_OPERAND (arg1, N), flags)
3046 #define OP_SAME_WITH_NULL(N) \
3047 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3048 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3051 {
3053 /* Two conversions are equal only if signedness and modes match. */
3055 {
3056 CASE_CONVERT:
3064 }
3074 /* For commutative ops, allow the other order. */
3082 /* If either of the pointer (or reference) expressions we are
3083 dereferencing contain a side effect, these cannot be equal,
3084 but their addresses can be. */
3091 {
3101 /* Require the same offset. */
3107 /* Fallthru. */
3115 {
3116 /* Require equal access sizes */
3122 flags)))
3124 /* Verify that access happens in similar types. */
3127 /* Verify that accesses are TBAA compatible. */
3136 /* Verify that alignment is compatible. */
3140 }
3143 /* TARGET_MEM_REF require equal extra operands. */
3154 /* Compare the array index by value if it is constant first as we
3155 may have different types but same value here. */
3161 /* Compare low bound and element size as with OEP_ADDRESS_OF
3162 we have to account for the offset of the ref. */
3167 array_ref_low_bound
3171 array_ref_element_size
3173 flags))));
3176 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3177 may be NULL when we're called to compare MEM_EXPRs. */
3192 }
3196 {
3198 /* Be sure we pass right ADDRESS_OF flag. */
3216 /* The multiplcation operands are commutative. */
3217 /* FALLTHRU */
3225 /* Otherwise take into account this is a commutative operation. */
3238 /* BIT_INSERT_EXPR has an implict operand as the type precision
3239 of op1. Need to check to make sure they are the same. */
3245 /* FALLTHRU */
3270 }
3274 {
3278 /* If not both CALL_EXPRs are either internal or normal function
3279 functions, then they are not equal. */
3282 {
3283 /* If the CALL_EXPRs call different internal functions, then they
3284 are not equal. */
3287 }
3288 else
3289 {
3290 /* If the CALL_EXPRs call different functions, then they are not
3291 equal. */
3293 flags))
3295 }
3297 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3298 {
3302 else
3306 }
3308 /* Now see if all the arguments are the same. */
3309 {
3320 /* If we get here and both argument lists are exhausted
3321 then the CALL_EXPRs are equal. */
3323 }
3326 }
3329 /* Consider __builtin_sqrt equal to sqrt. */
3337 {
3338 /* In GIMPLE constructors are used only to build vectors from
3339 elements. Individual elements in the constructor must be
3340 indexed in increasing order and form an initial sequence.
3342 We make no effort to compare constructors in generic.
3343 (see sem_variable::equals in ipa-icf which can do so for
3344 constants). */
3349 /* Be sure that vectors constructed have the same representation.
3350 We only tested element precision and modes to match.
3351 Vectors may be BLKmode and thus also check that the number of
3352 parts match. */
3365 {
3370 /* In GIMPLE the indexes can be either NULL or matching i.
3371 Double check this so we won't get false
3372 positives for GENERIC. */
3380 }
3382 }
3385 {
3386 /* Compare the STATEMENT_LISTs. */
3392 {
3393 /* The lists don't have the same number of statements. */
3399 OEP_LEXICOGRAPHIC))
3401 }
3402 }
3407 {
3414 }
3418 }
3420 #undef OP_SAME
3421 #undef OP_SAME_WITH_NULL
3422 }
3423 \f
3424 /* Similar to operand_equal_p, but see if ARG0 might be a variant of ARG1
3425 with a different signedness or a narrower precision. */
3427 static bool
3429 {
3437 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3438 and see if the inner values are the same. This removes any
3439 signedness comparison, which doesn't matter here. */
3447 /* Discard a single widening conversion from ARG1 and see if the inner
3448 value is the same as ARG0. */
3457 }
3458 \f
3459 /* See if ARG is an expression that is either a comparison or is performing
3460 arithmetic on comparisons. The comparisons must only be comparing
3461 two different values, which will be stored in *CVAL1 and *CVAL2; if
3462 they are nonzero it means that some operands have already been found.
3463 No variables may be used anywhere else in the expression except in the
3464 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3465 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3467 If this is true, return 1. Otherwise, return zero. */
3469 static int
3471 {
3475 /* We can handle some of the tcc_expression cases here. */
3485 {
3486 /* If we've already found a CVAL1 or CVAL2, this expression is
3487 two complex to handle. */
3493 }
3496 {
3519 /* First see if we can handle the first operand, then the second. For
3520 the second operand, we know *CVAL1 can't be zero. It must be that
3521 one side of the comparison is each of the values; test for the
3522 case where this isn't true by failing if the two operands
3523 are the same. */
3532 ;
3536 ;
3537 else
3541 ;
3545 ;
3546 else
3553 }
3554 }
3555 \f
3556 /* ARG is a tree that is known to contain just arithmetic operations and
3557 comparisons. Evaluate the operations in the tree substituting NEW0 for
3558 any occurrence of OLD0 as an operand of a comparison and likewise for
3559 NEW1 and OLD1. */
3561 static tree
3564 {
3569 /* We can handle some of the tcc_expression cases here. */
3577 {
3592 {
3611 }
3612 /* Fall through - ??? */
3615 {
3619 /* We need to check both for exact equality and tree equality. The
3620 former will be true if the operand has a side-effect. In that
3621 case, we know the operand occurred exactly once. */
3634 }
3638 }
3639 }
3640 \f
3641 /* Return a tree for the case when the result of an expression is RESULT
3642 converted to TYPE and OMITTED was previously an operand of the expression
3643 but is now not needed (e.g., we folded OMITTED * 0).
3645 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3646 the conversion of RESULT to TYPE. */
3648 tree
3650 {
3653 /* If the resulting operand is an empty statement, just return the omitted
3654 statement casted to void. */
3664 }
3666 /* Return a tree for the case when the result of an expression is RESULT
3667 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3668 of the expression but are now not needed.
3670 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3671 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3672 evaluated before OMITTED2. Otherwise, if neither has side effects,
3673 just do the conversion of RESULT to TYPE. */
3675 tree
3678 {
3687 }
3689 \f
3690 /* Return a simplified tree node for the truth-negation of ARG. This
3691 never alters ARG itself. We assume that ARG is an operation that
3692 returns a truth value (0 or 1).
3694 FIXME: one would think we would fold the result, but it causes
3695 problems with the dominator optimizer. */
3697 static tree
3699 {
3704 /* If this is a comparison, we can simply invert it, except for
3705 floating-point non-equality comparisons, in which case we just
3706 enclose a TRUTH_NOT_EXPR around what we have. */
3709 {
3712 && flag_trapping_math
3726 }
3729 {
3748 /* Here we can invert either operand. We invert the first operand
3749 unless the second operand is a TRUTH_NOT_EXPR in which case our
3750 result is the XOR of the first operand with the inside of the
3751 negation of the second operand. */
3756 else
3779 {
3786 /* A COND_EXPR may have a throw as one operand, which
3787 then has void type. Just leave void operands
3788 as they are. */
3794 }
3806 CASE_CONVERT:
3810 /* fall through */
3832 }
3833 }
3835 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3836 assume that ARG is an operation that returns a truth value (0 or 1
3837 for scalars, 0 or -1 for vectors). Return the folded expression if
3838 folding is successful. Otherwise, return NULL_TREE. */
3840 static tree
3842 {
3845 ? BIT_NOT_EXPR
3848 }
3850 /* Return a simplified tree node for the truth-negation of ARG. This
3851 never alters ARG itself. We assume that ARG is an operation that
3852 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3854 tree
3856 {
3862 ? BIT_NOT_EXPR
3865 }
3866 \f
3867 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3868 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3869 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3870 is the original memory reference used to preserve the alias set of
3871 the access. */
3873 static tree
3877 {
3880 /* Attempt not to lose the access path if possible. */
3882 {
3884 machine_mode nmode;
3886 tree noffset;
3896 && !reversep
3897 && !nreversep
3899 {
3902 }
3903 }
3912 {
3919 }
3934 }
3936 /* Optimize a bit-field compare.
3938 There are two cases: First is a compare against a constant and the
3939 second is a comparison of two items where the fields are at the same
3940 bit position relative to the start of a chunk (byte, halfword, word)
3941 large enough to contain it. In these cases we can avoid the shift
3942 implicit in bitfield extractions.
3944 For constants, we emit a compare of the shifted constant with the
3945 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3946 compared. For two fields at the same position, we do the ANDs with the
3947 similar mask and compare the result of the ANDs.
3949 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3950 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3951 are the left and right operands of the comparison, respectively.
3953 If the optimization described above can be done, we return the resulting
3954 tree. Otherwise we return zero. */
3956 static tree
3959 {
3962 tree unsigned_type;
3965 scalar_int_mode nmode;
3970 tree mask;
3971 tree offset;
3973 /* Get all the information about the extractions being done. If the bit size
3974 if the same as the size of the underlying object, we aren't doing an
3975 extraction at all and so can do nothing. We also don't want to
3976 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3977 then will no longer be able to replace it. */
3986 else
3987 {
3988 /* If this is not a constant, we can only do something if bit positions,
3989 sizes, signedness and storage order are the same. */
3990 rinner
3998 }
4000 /* Honor the C++ memory model and mimic what RTL expansion does. */
4004 {
4008 }
4010 /* See if we can find a mode to refer to this field. We should be able to,
4011 but fail if we can't. */
4019 /* Set signed and unsigned types of the precision of this mode for the
4020 shifts below. */
4023 /* Compute the bit position and size for the new reference and our offset
4024 within it. If the new reference is the same size as the original, we
4025 won't optimize anything, so return zero. */
4035 /* Make the mask to be used against the extracted field. */
4042 {
4046 /* If not comparing with constant, just rework the comparison
4047 and return. */
4055 }
4057 /* Otherwise, we are handling the constant case. See if the constant is too
4058 big for the field. Warn and return a tree for 0 (false) if so. We do
4059 this not only for its own sake, but to avoid having to test for this
4060 error case below. If we didn't, we might generate wrong code.
4062 For unsigned fields, the constant shifted right by the field length should
4063 be all zero. For signed fields, the high-order bits should agree with
4064 the sign bit. */
4067 {
4069 {
4073 }
4074 }
4075 else
4076 {
4079 {
4083 }
4084 }
4089 /* Single-bit compares should always be against zero. */
4091 {
4094 }
4096 /* Make a new bitfield reference, shift the constant over the
4097 appropriate number of bits and mask it with the computed mask
4098 (in case this was a signed field). If we changed it, make a new one. */
4106 mask);
4111 }
4112 \f
4113 /* Subroutine for fold_truth_andor_1: decode a field reference.
4115 If EXP is a comparison reference, we return the innermost reference.
4117 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4118 set to the starting bit number.
4120 If the innermost field can be completely contained in a mode-sized
4121 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4123 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4124 otherwise it is not changed.
4126 *PUNSIGNEDP is set to the signedness of the field.
4128 *PREVERSEP is set to the storage order of the field.
4130 *PMASK is set to the mask used. This is either contained in a
4131 BIT_AND_EXPR or derived from the width of the field.
4133 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4135 Return 0 if this is not a component reference or is one that we can't
4136 do anything with. */
4138 static tree
4143 {
4148 tree unsigned_type;
4151 /* All the optimizations using this function assume integer fields.
4152 There are problems with FP fields since the type_for_size call
4153 below can fail for, e.g., XFmode. */
4157 /* We are interested in the bare arrangement of bits, so strip everything
4158 that doesn't affect the machine mode. However, record the type of the
4159 outermost expression if it may matter below. */
4166 {
4172 }
4179 /* Reject out-of-bound accesses (PR79731). */
4187 /* If the number of bits in the reference is the same as the bitsize of
4188 the outer type, then the outer type gives the signedness. Otherwise
4189 (in case of a small bitfield) the signedness is unchanged. */
4193 /* Compute the mask to access the bitfield. */
4202 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4210 }
4212 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4213 bit positions and MASK is SIGNED. */
4215 static int
4217 {
4221 /* If this function returns true when the type of the mask is
4222 UNSIGNED, then there will be errors. In particular see
4223 gcc.c-torture/execute/990326-1.c. There does not appear to be
4224 any documentation paper trail as to why this is so. But the pre
4225 wide-int worked with that restriction and it has been preserved
4226 here. */
4231 }
4233 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4234 represents the sign bit of EXP's type. If EXP represents a sign
4235 or zero extension, also test VAL against the unextended type.
4236 The return value is the (sub)expression whose sign bit is VAL,
4237 or NULL_TREE otherwise. */
4239 tree
4241 {
4243 tree t;
4245 /* Tree EXP must have an integral type. */
4250 /* Tree VAL must be an integer constant. */
4259 /* Handle extension from a narrower type. */
4265 }
4267 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4268 to be evaluated unconditionally. */
4270 static int
4272 {
4273 /* Strip any conversions that don't change the machine mode. */
4282 /* Don't regard global variables as simple. They may be
4283 allocated in ways unknown to the compiler (shared memory,
4284 #pragma weak, etc). */
4287 /* Weakrefs are not safe to be read, since they can be NULL.
4288 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4289 have DECL_WEAK flag set. */
4291 /* Loading a static variable is unduly expensive, but global
4292 registers aren't expensive. */
4294 }
4296 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4297 to be evaluated unconditionally.
4298 I addition to simple_operand_p, we assume that comparisons, conversions,
4299 and logic-not operations are simple, if their operands are simple, too. */
4301 static bool
4303 {
4323 }
4325 \f
4326 /* The following functions are subroutines to fold_range_test and allow it to
4327 try to change a logical combination of comparisons into a range test.
4329 For example, both
4330 X == 2 || X == 3 || X == 4 || X == 5
4331 and
4332 X >= 2 && X <= 5
4333 are converted to
4334 (unsigned) (X - 2) <= 3
4336 We describe each set of comparisons as being either inside or outside
4337 a range, using a variable named like IN_P, and then describe the
4338 range with a lower and upper bound. If one of the bounds is omitted,
4339 it represents either the highest or lowest value of the type.
4341 In the comments below, we represent a range by two numbers in brackets
4342 preceded by a "+" to designate being inside that range, or a "-" to
4343 designate being outside that range, so the condition can be inverted by
4344 flipping the prefix. An omitted bound is represented by a "-". For
4345 example, "- [-, 10]" means being outside the range starting at the lowest
4346 possible value and ending at 10, in other words, being greater than 10.
4347 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4348 always false.
4350 We set up things so that the missing bounds are handled in a consistent
4351 manner so neither a missing bound nor "true" and "false" need to be
4352 handled using a special case. */
4354 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4355 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4356 and UPPER1_P are nonzero if the respective argument is an upper bound
4357 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4358 must be specified for a comparison. ARG1 will be converted to ARG0's
4359 type if both are specified. */
4361 static tree
4364 {
4365 tree tem;
4369 /* If neither arg represents infinity, do the normal operation.
4370 Else, if not a comparison, return infinity. Else handle the special
4371 comparison rules. Note that most of the cases below won't occur, but
4372 are handled for consistency. */
4375 {
4380 }
4385 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4386 for neither. In real maths, we cannot assume open ended ranges are
4387 the same. But, this is computer arithmetic, where numbers are finite.
4388 We can therefore make the transformation of any unbounded range with
4389 the value Z, Z being greater than any representable number. This permits
4390 us to treat unbounded ranges as equal. */
4394 {
4415 }
4418 }
4419 \f
4420 /* Helper routine for make_range. Perform one step for it, return
4421 new expression if the loop should continue or NULL_TREE if it should
4422 stop. */
4424 tree
4428 {
4434 {
4436 /* We can only do something if the range is testing for zero. */
4445 /* We can only do something if the range is testing for zero
4446 and if the second operand is an integer constant. Note that
4447 saying something is "in" the range we make is done by
4448 complementing IN_P since it will set in the initial case of
4449 being not equal to zero; "out" is leaving it alone. */
4456 {
4477 }
4479 /* If this is an unsigned comparison, we also know that EXP is
4480 greater than or equal to zero. We base the range tests we make
4481 on that fact, so we record it here so we can parse existing
4482 range tests. We test arg0_type since often the return type
4483 of, e.g. EQ_EXPR, is boolean. */
4485 {
4489 NULL_TREE))
4494 /* If the high bound is missing, but we have a nonzero low
4495 bound, reverse the range so it goes from zero to the low bound
4496 minus 1. */
4498 {
4503 }
4504 }
4512 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4513 low and high are non-NULL, then normalize will DTRT. */
4516 {
4521 }
4523 /* (-x) IN [a,b] -> x in [-b, -a] */
4535 /* ~ X -> -X - 1 */
4544 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4545 move a constant to the other side. */
4550 /* If EXP is signed, any overflow in the computation is undefined,
4551 so we don't worry about it so long as our computations on
4552 the bounds don't overflow. For unsigned, overflow is defined
4553 and this is exactly the right thing. */
4565 normalize:
4566 /* Check for an unsigned range which has wrapped around the maximum
4567 value thus making n_high < n_low, and normalize it. */
4569 {
4575 /* If the range is of the form +/- [ x+1, x ], we won't
4576 be able to normalize it. But then, it represents the
4577 whole range or the empty set, so make it
4578 +/- [ -, - ]. */
4582 else
4584 }
4585 else
4593 CASE_CONVERT:
4611 /* If we're converting arg0 from an unsigned type, to exp,
4612 a signed type, we will be doing the comparison as unsigned.
4613 The tests above have already verified that LOW and HIGH
4614 are both positive.
4616 So we have to ensure that we will handle large unsigned
4617 values the same way that the current signed bounds treat
4618 negative values. */
4621 {
4622 tree high_positive;
4623 tree equiv_type;
4624 /* For fixed-point modes, we need to pass the saturating flag
4625 as the 2nd parameter. */
4627 equiv_type
4630 else
4631 equiv_type
4634 /* A range without an upper bound is, naturally, unbounded.
4635 Since convert would have cropped a very large value, use
4636 the max value for the destination type. */
4637 high_positive
4644 high_positive),
4647 /* If the low bound is specified, "and" the range with the
4648 range for which the original unsigned value will be
4649 positive. */
4651 {
4654 integer_zero_node),
4655 high_positive))
4659 }
4660 else
4661 {
4662 /* Otherwise, "or" the range with the range of the input
4663 that will be interpreted as negative. */
4666 integer_zero_node),
4667 high_positive))
4671 }
4672 }
4681 }
4682 }
4684 /* Given EXP, a logical expression, set the range it is testing into
4685 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4686 actually being tested. *PLOW and *PHIGH will be made of the same
4687 type as the returned expression. If EXP is not a comparison, we
4688 will most likely not be returning a useful value and range. Set
4689 *STRICT_OVERFLOW_P to true if the return value is only valid
4690 because signed overflow is undefined; otherwise, do not change
4691 *STRICT_OVERFLOW_P. */
4693 tree
4696 {
4704 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4705 and see if we can refine the range. Some of the cases below may not
4706 happen, but it doesn't seem worth worrying about this. We "continue"
4707 the outer loop when we've changed something; otherwise we "break"
4708 the switch, which will "break" the while. */
4714 {
4720 {
4728 }
4737 }
4739 /* If EXP is a constant, we can evaluate whether this is true or false. */
4741 {
4748 }
4752 }
4754 /* Returns TRUE if [LOW, HIGH] range check can be optimized to
4755 a bitwise check i.e. when
4756 LOW == 0xXX...X00...0
4757 HIGH == 0xXX...X11...1
4758 Return corresponding mask in MASK and stem in VALUE. */
4760 static bool
4763 {
4786 }
4787 \f
4788 /* Helper routine for build_range_check and match.pd. Return the type to
4789 perform the check or NULL if it shouldn't be optimized. */
4791 tree
4793 {
4794 /* First make sure that arithmetics in this type is valid, then make sure
4795 that it wraps around. */
4801 {
4804 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4805 for the type in question, as we rely on this here. */
4815 else
4817 }
4819 }
4821 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4822 type, TYPE, return an expression to test if EXP is in (or out of, depending
4823 on IN_P) the range. Return 0 if the test couldn't be created. */
4825 tree
4828 {
4831 /* Disable this optimization for function pointer expressions
4832 on targets that require function pointer canonicalization. */
4839 {
4845 }
4867 value);
4870 {
4872 {
4876 }
4878 }
4880 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4882 {
4886 {
4888 {
4891 etype
4893 else
4896 }
4899 }
4900 }
4902 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4903 This requires wrap-around arithmetics for the type of the expression. */
4923 }
4924 \f
4925 /* Return the predecessor of VAL in its type, handling the infinite case. */
4927 static tree
4929 {
4935 else
4938 }
4940 /* Return the successor of VAL in its type, handling the infinite case. */
4942 static tree
4944 {
4950 else
4953 }
4955 /* Given two ranges, see if we can merge them into one. Return 1 if we
4956 can, 0 if we can't. Set the output range into the specified parameters. */
4958 bool
4961 {
4965 tree tem;
4975 /* Make range 0 be the range that starts first, or ends last if they
4976 start at the same value. Swap them if it isn't. */
4979 || (lowequal
4982 {
4986 }
4988 /* Now flag two cases, whether the ranges are disjoint or whether the
4989 second range is totally subsumed in the first. Note that the tests
4990 below are simplified by the ones above. */
4996 /* We now have four cases, depending on whether we are including or
4997 excluding the two ranges. */
4999 {
5000 /* If they don't overlap, the result is false. If the second range
5001 is a subset it is the result. Otherwise, the range is from the start
5002 of the second to the end of the first. */
5007 else
5009 }
5012 {
5013 /* If they don't overlap, the result is the first range. If they are
5014 equal, the result is false. If the second range is a subset of the
5015 first, and the ranges begin at the same place, we go from just after
5016 the end of the second range to the end of the first. If the second
5017 range is not a subset of the first, or if it is a subset and both
5018 ranges end at the same place, the range starts at the start of the
5019 first range and ends just before the second range.
5020 Otherwise, we can't describe this as a single range. */
5026 {
5031 {
5032 /* We are in the weird situation where high0 > high1 but
5033 high1 has no successor. Punt. */
5035 }
5036 }
5038 {
5043 {
5044 /* low0 < low1 but low1 has no predecessor. Punt. */
5046 }
5047 }
5048 else
5050 }
5053 {
5054 /* If they don't overlap, the result is the second range. If the second
5055 is a subset of the first, the result is false. Otherwise,
5056 the range starts just after the first range and ends at the
5057 end of the second. */
5062 else
5063 {
5068 {
5069 /* high1 > high0 but high0 has no successor. Punt. */
5071 }
5072 }
5073 }
5075 else
5076 {
5077 /* The case where we are excluding both ranges. Here the complex case
5078 is if they don't overlap. In that case, the only time we have a
5079 range is if they are adjacent. If the second is a subset of the
5080 first, the result is the first. Otherwise, the range to exclude
5081 starts at the beginning of the first range and ends at the end of the
5082 second. */
5084 {
5089 else
5090 {
5091 /* Canonicalize - [min, x] into - [-, x]. */
5094 {
5099 /* FALLTHROUGH */
5112 }
5114 /* Canonicalize - [x, max] into - [x, -]. */
5117 {
5122 /* FALLTHROUGH */
5138 }
5140 /* The ranges might be also adjacent between the maximum and
5141 minimum values of the given type. For
5142 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5143 return + [x + 1, y - 1]. */
5145 {
5152 }
5153 else
5155 }
5156 }
5159 else
5161 }
5165 }
5166 \f
5168 /* Subroutine of fold, looking inside expressions of the form
5169 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5170 of the COND_EXPR. This function is being used also to optimize
5171 A op B ? C : A, by reversing the comparison first.
5173 Return a folded expression whose code is not a COND_EXPR
5174 anymore, or NULL_TREE if no folding opportunity is found. */
5176 static tree
5179 {
5184 tree tem;
5189 /* If we have A op 0 ? A : -A, consider applying the following
5190 transformations:
5192 A == 0? A : -A same as -A
5193 A != 0? A : -A same as A
5194 A >= 0? A : -A same as abs (A)
5195 A > 0? A : -A same as abs (A)
5196 A <= 0? A : -A same as -abs (A)
5197 A < 0? A : -A same as -abs (A)
5199 None of these transformations work for modes with signed
5200 zeros. If A is +/-0, the first two transformations will
5201 change the sign of the result (from +0 to -0, or vice
5202 versa). The last four will fix the sign of the result,
5203 even though the original expressions could be positive or
5204 negative, depending on the sign of A.
5206 Note that all these transformations are correct if A is
5207 NaN, since the two alternatives (A and -A) are also NaNs. */
5214 /* In the case that A is of the form X-Y, '-A' (arg2) may
5215 have already been folded to Y-X, check for that. */
5223 {
5235 /* Fall through. */
5246 /* FALLTHRU */
5256 }
5258 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5259 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5260 both transformations are correct when A is NaN: A != 0
5261 is then true, and A == 0 is false. */
5265 {
5270 }
5272 /* Try some transformations of A op B ? A : B.
5274 A == B? A : B same as B
5275 A != B? A : B same as A
5276 A >= B? A : B same as max (A, B)
5277 A > B? A : B same as max (B, A)
5278 A <= B? A : B same as min (A, B)
5279 A < B? A : B same as min (B, A)
5281 As above, these transformations don't work in the presence
5282 of signed zeros. For example, if A and B are zeros of
5283 opposite sign, the first two transformations will change
5284 the sign of the result. In the last four, the original
5285 expressions give different results for (A=+0, B=-0) and
5286 (A=-0, B=+0), but the transformed expressions do not.
5288 The first two transformations are correct if either A or B
5289 is a NaN. In the first transformation, the condition will
5290 be false, and B will indeed be chosen. In the case of the
5291 second transformation, the condition A != B will be true,
5292 and A will be chosen.
5294 The conversions to max() and min() are not correct if B is
5295 a number and A is not. The conditions in the original
5296 expressions will be false, so all four give B. The min()
5297 and max() versions would give a NaN instead. */
5300 /* Avoid these transformations if the COND_EXPR may be used
5301 as an lvalue in the C++ front-end. PR c++/19199. */
5302 && (in_gimple_form
5308 {
5314 {
5323 /* In C++ a ?: expression can be an lvalue, so put the
5324 operand which will be used if they are equal first
5325 so that we can convert this back to the
5326 corresponding COND_EXPR. */
5328 {
5336 }
5343 {
5351 }
5364 }
5365 }
5368 }
5371 \f
5372 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5373 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5374 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5375 false) >= 2)
5376 #endif
5378 /* EXP is some logical combination of boolean tests. See if we can
5379 merge it into some range test. Return the new tree if so. */
5381 static tree
5384 {
5400 /* If this is an OR operation, invert both sides; we will invert
5401 again at the end. */
5405 /* If both expressions are the same, if we can merge the ranges, and we
5406 can build the range test, return it or it inverted. If one of the
5407 ranges is always true or always false, consider it to be the same
5408 expression as the other. */
5416 {
5420 }
5422 /* On machines where the branch cost is expensive, if this is a
5423 short-circuited branch and the underlying object on both sides
5424 is the same, make a non-short-circuit operation. */
5426 && !flag_sanitize_coverage
5431 {
5432 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5433 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5434 which cases we can't do this. */
5442 {
5451 {
5454 WARN_STRICT_OVERFLOW_COMPARISON);
5458 }
5459 }
5460 }
5463 }
5464 \f
5465 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5466 bit value. Arrange things so the extra bits will be set to zero if and
5467 only if C is signed-extended to its full width. If MASK is nonzero,
5468 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5470 static tree
5472 {
5475 tree temp;
5480 /* We work by getting just the sign bit into the low-order bit, then
5481 into the high-order bit, then sign-extend. We then XOR that value
5482 with C. */
5486 /* We must use a signed type in order to get an arithmetic right shift.
5487 However, we must also avoid introducing accidental overflows, so that
5488 a subsequent call to integer_zerop will work. Hence we must
5489 do the type conversion here. At this point, the constant is either
5490 zero or one, and the conversion to a signed type can never overflow.
5491 We could get an overflow if this conversion is done anywhere else. */
5500 /* If necessary, convert the type back to match the type of C. */
5505 }
5506 \f
5507 /* For an expression that has the form
5508 (A && B) || ~B
5509 or
5510 (A || B) && ~B,
5511 we can drop one of the inner expressions and simplify to
5512 A || ~B
5513 or
5514 A && ~B
5515 LOC is the location of the resulting expression. OP is the inner
5516 logical operation; the left-hand side in the examples above, while CMPOP
5517 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5518 removing a condition that guards another, as in
5519 (A != NULL && A->...) || A == NULL
5520 which we must not transform. If RHS_ONLY is true, only eliminate the
5521 right-most operand of the inner logical operation. */
5523 static tree
5526 {
5544 {
5547 {
5550 }
5551 }
5553 {
5556 {
5559 }
5560 }
5575 }
5577 /* Find ways of folding logical expressions of LHS and RHS:
5578 Try to merge two comparisons to the same innermost item.
5579 Look for range tests like "ch >= '0' && ch <= '9'".
5580 Look for combinations of simple terms on machines with expensive branches
5581 and evaluate the RHS unconditionally.
5583 For example, if we have p->a == 2 && p->b == 4 and we can make an
5584 object large enough to span both A and B, we can do this with a comparison
5585 against the object ANDed with the a mask.
5587 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5588 operations to do this with one comparison.
5590 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5591 function and the one above.
5593 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5594 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5596 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5597 two operands.
5599 We return the simplified tree or 0 if no optimization is possible. */
5601 static tree
5604 {
5605 /* If this is the "or" of two comparisons, we can do something if
5606 the comparisons are NE_EXPR. If this is the "and", we can do something
5607 if the comparisons are EQ_EXPR. I.e.,
5608 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5610 WANTED_CODE is this operation code. For single bit fields, we can
5611 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5612 comparison for one-bit fields. */
5633 /* Start by getting the comparison codes. Fail if anything is volatile.
5634 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5635 it were surrounded with a NE_EXPR. */
5644 {
5648 }
5651 {
5655 }
5666 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5669 {
5672 {
5677 }
5680 {
5686 }
5687 }
5692 /* If the RHS can be evaluated unconditionally and its operands are
5693 simple, it wins to evaluate the RHS unconditionally on machines
5694 with expensive branches. In this case, this isn't a comparison
5695 that can be merged. */
5702 {
5703 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5714 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5724 }
5726 /* See if the comparisons can be merged. Then get all the parameters for
5727 each side. */
5752 /* It must be true that the inner operation on the lhs of each
5753 comparison must be the same if we are to be able to do anything.
5754 Then see if we have constants. If not, the same must be true for
5755 the rhs's. */
5764 {
5767 }
5772 else
5775 /* If either comparison code is not correct for our logical operation,
5776 fail. However, we can convert a one-bit comparison against zero into
5777 the opposite comparison against that bit being set in the field. */
5781 {
5783 {
5784 /* Make the left operand unsigned, since we are only interested
5785 in the value of one bit. Otherwise we are doing the wrong
5786 thing below. */
5789 }
5790 else
5792 }
5794 /* This is analogous to the code for l_const above. */
5796 {
5798 {
5801 }
5802 else
5804 }
5806 /* See if we can find a mode that contains both fields being compared on
5807 the left. If we can't, fail. Otherwise, update all constants and masks
5808 to be relative to a field of that size. */
5822 {
5825 }
5833 {
5840 {
5844 }
5845 }
5847 {
5854 {
5858 }
5859 }
5861 /* If the right sides are not constant, do the same for it. Also,
5862 disallow this optimization if a size or signedness mismatch occurs
5863 between the left and right sides. */
5865 {
5868 /* Make sure the two fields on the right
5869 correspond to the left without being swapped. */
5886 {
5889 }
5898 /* Make a mask that corresponds to both fields being compared.
5899 Do this for both items being compared. If the operands are the
5900 same size and the bits being compared are in the same position
5901 then we can do this by masking both and comparing the masked
5902 results. */
5909 {
5923 }
5925 /* There is still another way we can do something: If both pairs of
5926 fields being compared are adjacent, we may be able to make a wider
5927 field containing them both.
5929 Note that we still must mask the lhs/rhs expressions. Furthermore,
5930 the mask must be shifted to account for the shift done by
5931 make_bit_field_ref. */
5940 {
5941 tree type;
5957 /* Convert to the smaller type before masking out unwanted bits. */
5960 {
5962 {
5966 }
5968 {
5972 }
5973 }
5982 }
5985 }
5987 /* Handle the case of comparisons with constants. If there is something in
5988 common between the masks, those bits of the constants must be the same.
5989 If not, the condition is always false. Test for this to avoid generating
5990 incorrect code below. */
5995 {
5997 {
6000 }
6001 else
6002 {
6005 }
6006 }
6011 /* Construct the expression we will return. First get the component
6012 reference we will make. Unless the mask is all ones the width of
6013 that field, perform the mask operation. Then compare with the
6014 merged constant. */
6025 }
6026 \f
6027 /* T is an integer expression that is being multiplied, divided, or taken a
6028 modulus (CODE says which and what kind of divide or modulus) by a
6029 constant C. See if we can eliminate that operation by folding it with
6030 other operations already in T. WIDE_TYPE, if non-null, is a type that
6031 should be used for the computation if wider than our type.
6033 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6034 (X * 2) + (Y * 4). We must, however, be assured that either the original
6035 expression would not overflow or that overflow is undefined for the type
6036 in the language in question.
6038 If we return a non-null expression, it is an equivalent form of the
6039 original computation, but need not be in the original type.
6041 We set *STRICT_OVERFLOW_P to true if the return values depends on
6042 signed overflow being undefined. Otherwise we do not change
6043 *STRICT_OVERFLOW_P. */
6045 static tree
6048 {
6049 /* To avoid exponential search depth, refuse to allow recursion past
6050 three levels. Beyond that (1) it's highly unlikely that we'll find
6051 something interesting and (2) we've probably processed it before
6052 when we built the inner expression. */
6055 tree ret;
6060 depth++;
6062 depth--;
6065 }
6067 static tree
6070 {
6082 /* Don't deal with constants of zero here; they confuse the code below. */
6092 /* Note that we need not handle conditional operations here since fold
6093 already handles those cases. So just do arithmetic here. */
6095 {
6097 /* For a constant, we can always simplify if we are a multiply
6098 or (for divide and modulus) if it is a multiple of our constant. */
6102 {
6105 /* If the multiplication overflowed, we lost information on it.
6106 See PR68142 and PR69845. */
6110 }
6114 /* If op0 is an expression ... */
6120 /* ... and has wrapping overflow, and its type is smaller
6121 than ctype, then we cannot pass through as widening. */
6126 /* ... or this is a truncation (t is narrower than op0),
6127 then we cannot pass through this narrowing. */
6130 /* ... or signedness changes for division or modulus,
6131 then we cannot pass through this conversion. */
6135 /* ... or has undefined overflow while the converted to
6136 type has not, we cannot do the operation in the inner type
6137 as that would introduce undefined overflow. */
6143 /* Pass the constant down and see if we can make a simplification. If
6144 we can, replace this expression with the inner simplification for
6145 possible later conversion to our or some other type. */
6150 code == MULT_EXPR
6152 strict_overflow_p))))
6157 /* If widening the type changes it from signed to unsigned, then we
6158 must avoid building ABS_EXPR itself as unsigned. */
6160 {
6164 {
6167 }
6169 }
6170 /* If the constant is negative, we cannot simplify this. */
6173 /* FALLTHROUGH */
6175 /* For division and modulus, type can't be unsigned, as e.g.
6176 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6177 For signed types, even with wrapping overflow, this is fine. */
6186 /* If widening the type changes the signedness, then we can't perform
6187 this optimization as that changes the result. */
6191 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6197 {
6204 }
6208 /* If the second operand is constant, this is a multiplication
6209 or floor division, by a power of two, so we can treat it that
6210 way unless the multiplier or divisor overflows. Signed
6211 left-shift overflow is implementation-defined rather than
6212 undefined in C90, so do not convert signed left shift into
6213 multiplication. */
6216 /* const_binop may not detect overflow correctly,
6217 so check for it explicitly here. */
6222 size_one_node,
6223 op1)))
6227 ctype,
6229 t1),
6234 /* See if we can eliminate the operation on both sides. If we can, we
6235 can return a new PLUS or MINUS. If we can't, the only remaining
6236 cases where we can do anything are if the second operand is a
6237 constant. */
6244 /* If not multiplication, we can only do this if both operands
6245 are divisible by c. */
6248 {
6253 }
6255 /* If this was a subtraction, negate OP1 and set it to be an addition.
6256 This simplifies the logic below. */
6258 {
6260 /* If OP1 was not easily negatable, the constant may be OP0. */
6262 {
6265 }
6266 }
6271 /* If either OP1 or C are negative, this optimization is not safe for
6272 some of the division and remainder types while for others we need
6273 to change the code. */
6275 {
6283 }
6285 /* If it's a multiply or a division/modulus operation of a multiple
6286 of our constant, do the operation and verify it doesn't overflow. */
6290 {
6293 /* We allow the constant to overflow with wrapping semantics. */
6297 }
6298 else
6301 /* If we have an unsigned type, we cannot widen the operation since it
6302 will change the result if the original computation overflowed. */
6306 /* The last case is if we are a multiply. In that case, we can
6307 apply the distributive law to commute the multiply and addition
6308 if the multiplication of the constants doesn't overflow
6309 and overflow is defined. With undefined overflow
6310 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6316 op1);
6321 /* We have a special case here if we are doing something like
6322 (C * 8) % 4 since we know that's zero. */
6325 /* If the multiplication can overflow we cannot optimize this. */
6330 {
6333 }
6335 /* ... fall through ... */
6339 /* If we can extract our operation from the LHS, do so and return a
6340 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6341 do something only if the second operand is a constant. */
6357 /* If these are the same operation types, we can associate them
6358 assuming no overflow. */
6360 {
6375 }
6377 /* If these operations "cancel" each other, we have the main
6378 optimizations of this pass, which occur when either constant is a
6379 multiple of the other, in which case we replace this with either an
6380 operation or CODE or TCODE.
6382 If we have an unsigned type, we cannot do this since it will change
6383 the result if the original computation overflowed. */
6390 {
6393 {
6400 }
6403 {
6410 }
6411 }
6416 }
6419 }
6420 \f
6421 /* Return a node which has the indicated constant VALUE (either 0 or
6422 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6423 and is of the indicated TYPE. */
6425 tree
6427 {
6436 else
6438 }
6441 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6442 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6443 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6444 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6445 COND is the first argument to CODE; otherwise (as in the example
6446 given here), it is the second argument. TYPE is the type of the
6447 original expression. Return NULL_TREE if no simplification is
6448 possible. */
6450 static tree
6455 {
6465 {
6469 /* If this operand throws an expression, then it does not make
6470 sense to try to perform a logical or arithmetic operation
6471 involving it. */
6476 }
6479 {
6484 }
6485 else
6486 /* Detect the case of mixing vector and scalar types - bail out. */
6492 /* This transformation is only worthwhile if we don't have to wrap ARG
6493 in a SAVE_EXPR and the operation can be simplified without recursing
6494 on at least one of the branches once its pushed inside the COND_EXPR. */
6503 {
6507 else
6509 }
6511 {
6515 else
6517 }
6519 /* Check that we have simplified at least one of the branches. */
6524 }
6526 \f
6527 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6529 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6530 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6531 ADDEND is the same as X.
6533 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6534 and finite. The problematic cases are when X is zero, and its mode
6535 has signed zeros. In the case of rounding towards -infinity,
6536 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6537 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6539 bool
6541 {
6545 /* Don't allow the fold with -fsignaling-nans. */
6549 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6553 /* In a vector or complex, we would need to check the sign of all zeros. */
6557 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6561 /* The mode has signed zeros, and we have to honor their sign.
6562 In this situation, there is only one case we can return true for.
6563 X - 0 is the same as X unless rounding towards -infinity is
6564 supported. */
6566 }
6568 /* Subroutine of match.pd that optimizes comparisons of a division by
6569 a nonzero integer constant against an integer constant, i.e.
6570 X/C1 op C2.
6572 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6573 GE_EXPR or LE_EXPR. ARG01 and ARG1 must be a INTEGER_CST. */
6575 enum tree_code
6578 {
6583 /* We have to do this the hard way to detect unsigned overflow.
6584 prod = int_const_binop (MULT_EXPR, c1, c2); */
6590 {
6594 /* Likewise *hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6597 }
6599 {
6602 {
6621 }
6622 }
6623 else
6624 {
6625 /* A negative divisor reverses the relational operators. */
6630 {
6649 }
6650 }
6663 }
6666 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6667 equality/inequality test, then return a simplified form of the test
6668 using a sign testing. Otherwise return NULL. TYPE is the desired
6669 result type. */
6671 static tree
6674 tree result_type)
6675 {
6676 /* If this is testing a single bit, we can optimize the test. */
6680 {
6681 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6682 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6686 /* This is only a win if casting to a signed type is cheap,
6687 i.e. when arg00's type is not a partial mode. */
6689 {
6692 result_type,
6695 }
6696 }
6699 }
6701 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6702 equality/inequality test, then return a simplified form of
6703 the test using shifts and logical operations. Otherwise return
6704 NULL. TYPE is the desired result type. */
6706 tree
6709 {
6710 /* If this is testing a single bit, we can optimize the test. */
6714 {
6723 /* First, see if we can fold the single bit test into a sign-bit
6724 test. */
6726 result_type);
6730 /* Otherwise we have (A & C) != 0 where C is a single bit,
6731 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6732 Similarly for (A & C) == 0. */
6734 /* If INNER is a right shift of a constant and it plus BITNUM does
6735 not overflow, adjust BITNUM and INNER. */
6741 {
6744 }
6746 /* If we are going to be able to omit the AND below, we must do our
6747 operations as unsigned. If we must use the AND, we have a choice.
6748 Normally unsigned is faster, but for some machines signed is. */
6766 /* Put the AND last so it can combine with more things. */
6769 /* Make sure to return the proper type. */
6773 }
6775 }
6777 /* Test whether it is preferable two swap two operands, ARG0 and
6778 ARG1, for example because ARG0 is an integer constant and ARG1
6779 isn't. */
6781 bool
6783 {
6797 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6798 for commutative and comparison operators. Ensuring a canonical
6799 form allows the optimizers to find additional redundancies without
6800 having to explicitly check for both orderings. */
6806 /* Put SSA_NAMEs last. */
6812 /* Put variables last. */
6819 }
6822 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6823 means A >= Y && A != MAX, but in this case we know that
6824 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6826 static tree
6828 {
6835 else
6844 {
6847 }
6849 {
6852 }
6853 else
6860 {
6861 /* Convert the pointer types into integer before taking the difference. */
6865 }
6866 else
6873 }
6875 /* Fold a sum or difference of at least one multiplication.
6876 Returns the folded tree or NULL if no simplification could be made. */
6878 static tree
6881 {
6885 /* (A * C) +- (B * C) -> (A+-B) * C.
6886 (A * C) +- A -> A * (C+-1).
6887 We are most concerned about the case where C is a constant,
6888 but other combinations show up during loop reduction. Since
6889 it is not difficult, try all four possibilities. */
6892 {
6895 }
6897 {
6900 }
6901 else
6902 {
6903 /* We cannot generate constant 1 for fract. */
6908 }
6910 {
6913 }
6915 {
6917 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6918 the purpose of this canonicalization. */
6922 {
6925 }
6926 else
6928 }
6929 else
6930 {
6931 /* We cannot generate constant 1 for fract. */
6936 }
6939 /* Prefer factoring a common non-constant. */
6949 /* No identical multiplicands; see if we can find a common
6950 power-of-two factor in non-power-of-two multiplies. This
6951 can help in multi-dimensional array access. */
6954 {
6957 tree maybe_same;
6961 /* Move min of absolute values to int11. */
6963 {
6968 }
6969 else
6973 /* The remainder should not be a constant, otherwise we
6974 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6975 increased the number of multiplications necessary. */
6977 {
6985 }
6986 }
6993 /* We are neither factoring zero nor minus one. */
7001 /* Same may be zero and thus the operation 'code' may overflow. Likewise
7002 same may be minus one and thus the multiplication may overflow. Perform
7003 the operations in an unsigned type. */
7008 /* If the sum evaluated to a constant that is not -INF the multiplication
7009 cannot overflow. */
7019 }
7021 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7022 specified by EXPR into the buffer PTR of length LEN bytes.
7023 Return the number of bytes placed in the buffer, or zero
7024 upon failure. */
7026 static int
7028 {
7040 /* Dry run. */
7046 {
7048 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7049 number of bytes. */
7053 {
7060 else
7062 }
7063 else
7067 }
7069 }
7072 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7073 specified by EXPR into the buffer PTR of length LEN bytes.
7074 Return the number of bytes placed in the buffer, or zero
7075 upon failure. */
7077 static int
7079 {
7083 FIXED_VALUE_TYPE value;
7098 }
7101 /* Subroutine of native_encode_expr. Encode the REAL_CST
7102 specified by EXPR into the buffer PTR of length LEN bytes.
7103 Return the number of bytes placed in the buffer, or zero
7104 upon failure. */
7106 static int
7108 {
7114 /* There are always 32 bits in each long, no matter the size of
7115 the hosts long. We handle floating point representations with
7116 up to 192 bits. */
7125 /* Dry run. */
7134 {
7139 {
7146 else
7148 }
7149 else
7150 {
7153 {
7154 /* Reverse bytes within each long, or within the entire float
7155 if it's smaller than a long (for HFmode). */
7158 }
7159 }
7164 }
7166 }
7168 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7169 specified by EXPR into the buffer PTR of length LEN bytes.
7170 Return the number of bytes placed in the buffer, or zero
7171 upon failure. */
7173 static int
7175 {
7177 tree part;
7191 }
7194 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7195 specified by EXPR into the buffer PTR of length LEN bytes.
7196 Return the number of bytes placed in the buffer, or zero
7197 upon failure. */
7199 static int
7201 {
7211 {
7213 {
7216 }
7227 }
7229 }
7232 /* Subroutine of native_encode_expr. Encode the STRING_CST
7233 specified by EXPR into the buffer PTR of length LEN bytes.
7234 Return the number of bytes placed in the buffer, or zero
7235 upon failure. */
7237 static int
7239 {
7242 /* Wide-char strings are encoded in target byte-order so native
7243 encoding them is trivial. */
7258 {
7261 {
7264 }
7267 }
7268 else
7271 }
7274 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7275 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7276 buffer PTR of length LEN bytes. If PTR is NULL, don't actually store
7277 anything, just do a dry run. If OFF is not -1 then start
7278 the encoding at byte offset OFF and encode at most LEN bytes.
7279 Return the number of bytes placed in the buffer, or zero upon failure. */
7281 int
7283 {
7284 /* We don't support starting at negative offset and -1 is special. */
7289 {
7310 }
7311 }
7314 /* Subroutine of native_interpret_expr. Interpret the contents of
7315 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7316 If the buffer cannot be interpreted, return NULL_TREE. */
7318 static tree
7320 {
7330 }
7333 /* Subroutine of native_interpret_expr. Interpret the contents of
7334 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7335 If the buffer cannot be interpreted, return NULL_TREE. */
7337 static tree
7339 {
7342 double_int result;
7343 FIXED_VALUE_TYPE fixed_value;
7353 }
7356 /* Subroutine of native_interpret_expr. Interpret the contents of
7357 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7358 If the buffer cannot be interpreted, return NULL_TREE. */
7360 static tree
7362 {
7366 /* There are always 32 bits in each long, no matter the size of
7367 the hosts long. We handle floating point representations with
7368 up to 192 bits. */
7369 REAL_VALUE_TYPE r;
7379 {
7380 /* Both OFFSET and BYTE index within a long;
7381 bitpos indexes the whole float. */
7384 {
7391 else
7393 }
7394 else
7395 {
7398 {
7399 /* Reverse bytes within each long, or within the entire float
7400 if it's smaller than a long (for HFmode). */
7403 }
7404 }
7408 }
7412 }
7415 /* Subroutine of native_interpret_expr. Interpret the contents of
7416 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7417 If the buffer cannot be interpreted, return NULL_TREE. */
7419 static tree
7421 {
7436 }
7439 /* Subroutine of native_interpret_expr. Interpret the contents of
7440 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7441 If the buffer cannot be interpreted, return NULL_TREE. */
7443 static tree
7445 {
7457 {
7462 }
7464 }
7467 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7468 the buffer PTR of length LEN as a constant of type TYPE. For
7469 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7470 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7471 return NULL_TREE. */
7473 tree
7475 {
7477 {
7499 }
7500 }
7502 /* Returns true if we can interpret the contents of a native encoding
7503 as TYPE. */
7505 static bool
7507 {
7509 {
7522 }
7523 }
7526 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7527 TYPE at compile-time. If we're unable to perform the conversion
7528 return NULL_TREE. */
7530 static tree
7532 {
7533 /* We support up to 512-bit values (for V8DFmode). */
7537 /* Check that the host and target are sane. */
7546 }
7548 /* Build an expression for the address of T. Folds away INDIRECT_REF
7549 to avoid confusing the gimplify process. */
7551 tree
7553 {
7554 /* The size of the object is not relevant when talking about its address. */
7559 {
7564 }
7574 {
7579 }
7580 else
7584 }
7586 /* Build an expression for the address of T. */
7588 tree
7590 {
7594 }
7596 /* Fold a unary expression of code CODE and type TYPE with operand
7597 OP0. Return the folded expression if folding is successful.
7598 Otherwise, return NULL_TREE. */
7600 tree
7602 {
7603 tree tem;
7604 tree arg0;
7612 {
7615 {
7616 /* Don't use STRIP_NOPS, because signedness of argument type
7617 matters. */
7619 }
7620 else
7621 {
7622 /* Strip any conversions that don't change the mode. This
7623 is safe for every expression, except for a comparison
7624 expression because its signedness is derived from its
7625 operands.
7627 Note that this is done as an internal manipulation within
7628 the constant folder, in order to find the simplest
7629 representation of the arguments so that their form can be
7630 studied. In any cases, the appropriate type conversions
7631 should be put back in the tree that will get out of the
7632 constant folder. */
7634 }
7637 {
7640 {
7644 }
7645 }
7646 }
7653 {
7660 {
7674 /* If this was a conversion, and all we did was to move into
7675 inside the COND_EXPR, bring it back out. But leave it if
7676 it is a conversion from integer to integer and the
7677 result precision is no wider than a word since such a
7678 conversion is cheap and may be optimized away by combine,
7679 while it couldn't if it were outside the COND_EXPR. Then return
7680 so we don't get into an infinite recursion loop taking the
7681 conversion out and then back in. */
7693 && (INTEGRAL_TYPE_P
7706 }
7707 }
7710 {
7716 CASE_CONVERT:
7720 {
7721 /* If we have (type) (a CMP b) and type is an integral type, return
7722 new expression involving the new type. Canonicalize
7723 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7724 non-integral type.
7725 Do not fold the result as that would not simplify further, also
7726 folding again results in recursions. */
7736 }
7738 /* Handle (T *)&A.B.C for A being of type T and B and C
7739 living at offset zero. This occurs frequently in
7740 C++ upcasting and then accessing the base. */
7744 {
7746 tree offset;
7747 machine_mode mode;
7749 tree base
7753 /* If the reference was to a (constant) zero offset, we can use
7754 the address of the base if it has the same base type
7755 as the result type and the pointer type is unqualified. */
7762 }
7766 /* Detect assigning a bitfield. */
7768 && DECL_BIT_FIELD
7770 {
7771 /* Don't leave an assignment inside a conversion
7772 unless assigning a bitfield. */
7774 /* First do the assignment, then return converted constant. */
7779 }
7781 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7782 constants (if x has signed type, the sign bit cannot be set
7783 in c). This folds extension into the BIT_AND_EXPR.
7784 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7785 very likely don't have maximal range for their precision and this
7786 transformation effectively doesn't preserve non-maximal ranges. */
7790 {
7801 <= HOST_BITS_PER_WIDE_INT
7803 {
7807 cst &= HOST_WIDE_INT_M1U
7811 && !flag_syntax_only
7814 {
7818 }
7819 }
7821 {
7826 }
7827 }
7829 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7830 cast (T1)X will fold away. We assume that this happens when X itself
7831 is a cast. */
7835 {
7839 return fold_build_pointer_plus_loc
7841 }
7843 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7844 of the same precision, and X is an integer type not narrower than
7845 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7851 {
7857 }
7859 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7860 type of X and Y (integer types only). */
7865 {
7866 /* Be careful not to introduce new overflows. */
7867 tree mult_type;
7870 else
7874 {
7881 }
7882 }
7888 {
7895 }
7906 /* Convert fabs((double)float) into (double)fabsf(float). */
7909 {
7915 targ0));
7916 }
7920 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7939 /* Note that the operand of this must be an int
7940 and its values must be 0 or 1.
7941 ("true" is a fixed value perhaps depending on the language,
7942 but we don't handle values other than 1 correctly yet.) */
7949 /* Fold *&X to X if X is an lvalue. */
7951 {
7958 }
7964 }
7967 /* If the operation was a conversion do _not_ mark a resulting constant
7968 with TREE_OVERFLOW if the original constant was not. These conversions
7969 have implementation defined behavior and retaining the TREE_OVERFLOW
7970 flag here would confuse later passes such as VRP. */
7971 tree
7974 {
7983 }
7985 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7986 operands OP0 and OP1. LOC is the location of the resulting expression.
7987 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7988 Return the folded expression if folding is successful. Otherwise,
7989 return NULL_TREE. */
7990 static tree
7993 {
7994 tree tem;
7996 /* We only do these simplifications if we are optimizing. */
8000 /* Check for things like (A || B) && (A || C). We can convert this
8001 to A || (B && C). Note that either operator can be any of the four
8002 truth and/or operations and the transformation will still be
8003 valid. Also note that we only care about order for the
8004 ANDIF and ORIF operators. If B contains side effects, this
8005 might change the truth-value of A. */
8012 {
8032 /* This case if tricky because we must either have commutative
8033 operators or else A10 must not have side-effects. */
8039 a01);
8040 }
8042 /* See if we can build a range comparison. */
8048 {
8052 }
8056 {
8060 }
8062 /* Check for the possibility of merging component references. If our
8063 lhs is another similar operation, try to merge its rhs with our
8064 rhs. Then try to merge our lhs and rhs. */
8074 && !flag_sanitize_coverage
8079 {
8086 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8087 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8088 We don't want to pack more than two leafs to a non-IF AND/OR
8089 expression.
8090 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8091 equal to IF-CODE, then we don't want to add right-hand operand.
8092 If the inner right-hand side of left-hand operand has
8093 side-effects, or isn't simple, then we can't add to it,
8094 as otherwise we might destroy if-sequence. */
8097 /* Needed for sequence points to handle trappings, and
8098 side-effects. */
8100 {
8102 arg1);
8104 tem);
8105 }
8106 /* Same as above but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8107 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8110 /* Needed for sequence points to handle trappings, and
8111 side-effects. */
8113 {
8118 }
8119 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8120 into (A OR B).
8121 For sequence point consistancy, we need to check for trapping,
8122 and side-effects. */
8126 }
8129 }
8131 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8132 by changing CODE to reduce the magnitude of constants involved in
8133 ARG0 of the comparison.
8134 Returns a canonicalized comparison tree if a simplification was
8135 possible, otherwise returns NULL_TREE.
8136 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8137 valid if signed overflow is undefined. */
8139 static tree
8143 {
8148 /* Match A +- CST code arg1. We can change this only if overflow
8149 is undefined. */
8152 /* In principle pointers also have undefined overflow behavior,
8153 but that causes problems elsewhere. */
8160 /* Identify the constant in arg0 and its sign. */
8164 /* Overflowed constants and zero will cause problems. */
8169 /* See if we can reduce the magnitude of the constant in
8170 arg0 by changing the comparison code. */
8171 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8175 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8179 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8183 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8187 else
8191 /* Now build the constant reduced in magnitude. But not if that
8192 would produce one outside of its types range. */
8208 }
8210 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8211 overflow further. Try to decrease the magnitude of constants involved
8212 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8213 and put sole constants at the second argument position.
8214 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8216 static tree
8219 {
8220 tree t;
8225 /* Try canonicalization by simplifying arg0. */
8230 {
8234 }
8236 /* Try canonicalization by simplifying arg1 using the swapped
8237 comparison. */
8245 }
8247 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8248 space. This is used to avoid issuing overflow warnings for
8249 expressions like &p->x which can not wrap. */
8251 static bool
8253 {
8260 wide_int wi_offset;
8266 else
8282 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8283 array. */
8285 {
8286 HOST_WIDE_INT base_size;
8291 }
8294 }
8296 /* Return a positive integer when the symbol DECL is known to have
8297 a nonzero address, zero when it's known not to (e.g., it's a weak
8298 symbol), and a negative integer when the symbol is not yet in the
8299 symbol table and so whether or not its address is zero is unknown.
8300 For function local objects always return positive integer. */
8301 static int
8303 {
8308 /* Function local objects are never NULL. */
8316 }
8318 /* Subroutine of fold_binary. This routine performs all of the
8319 transformations that are common to the equality/inequality
8320 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8321 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8322 fold_binary should call fold_binary. Fold a comparison with
8323 tree code CODE and type TYPE with operands OP0 and OP1. Return
8324 the folded comparison or NULL_TREE. */
8326 static tree
8329 {
8339 /* For comparisons of pointers we can decompose it to a compile time
8340 comparison of the base objects and the offsets into the object.
8341 This requires at least one operand being an ADDR_EXPR or a
8342 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8348 {
8351 machine_mode mode;
8355 /* Get base and offset for the access. Strip ADDR_EXPR for
8356 get_inner_reference, but put it back by stripping INDIRECT_REF
8357 off the base object if possible. indirect_baseN will be true
8358 if baseN is not an address but refers to the object itself. */
8361 {
8362 base0
8368 else
8370 }
8372 {
8376 {
8377 base0
8383 else
8385 }
8388 else
8392 {
8398 {
8401 }
8402 }
8403 }
8407 {
8408 base1
8414 else
8416 }
8418 {
8422 {
8423 base1
8429 else
8431 }
8434 else
8438 {
8444 {
8447 }
8448 }
8449 }
8451 /* If we have equivalent bases we might be able to simplify. */
8455 {
8456 /* We can fold this expression to a constant if the non-constant
8457 offset parts are equal. */
8461 {
8467 "occur when comparing P +- C1 with "
8469 WARN_STRICT_OVERFLOW_CONDITIONAL);
8472 {
8486 }
8487 }
8488 /* We can simplify the comparison to a comparison of the variable
8489 offset parts if the constant offset parts are equal.
8490 Be careful to use signed sizetype here because otherwise we
8491 mess with array offsets in the wrong way. This is possible
8492 because pointer arithmetic is restricted to retain within an
8493 object and overflow on pointer differences is undefined as of
8494 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8496 {
8497 /* By converting to signed sizetype we cover middle-end pointer
8498 arithmetic which operates on unsigned pointer types of size
8499 type size and ARRAY_REF offsets which are properly sign or
8500 zero extended from their type in case it is narrower than
8501 sizetype. */
8504 else
8508 else
8515 "occur when comparing P +- C1 with "
8517 WARN_STRICT_OVERFLOW_COMPARISON);
8520 }
8521 }
8522 /* For equal offsets we can simplify to a comparison of the
8523 base addresses. */
8525 && (indirect_base0
8527 && (indirect_base1
8532 {
8538 }
8539 /* Comparison between an ordinary (non-weak) symbol and a null
8540 pointer can be eliminated since such symbols must have a non
8541 null address. In C, relational expressions between pointers
8542 to objects and null pointers are undefined. The results
8543 below follow the C++ rules with the additional property that
8544 every object pointer compares greater than a null pointer.
8545 */
8548 /* Avoid folding references to struct members at offset 0 to
8549 prevent tests like '&ptr->firstmember == 0' from getting
8550 eliminated. When ptr is null, although the -> expression
8551 is strictly speaking invalid, GCC retains it as a matter
8552 of QoI. See PR c/44555. */
8555 && indirect_base0
8556 /* The caller guarantees that when one of the arguments is
8557 constant (i.e., null in this case) it is second. */
8559 {
8561 {
8572 }
8573 }
8574 }
8576 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8577 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8578 the resulting offset is smaller in absolute value than the
8579 original one and has the same sign. */
8588 {
8593 tree cst;
8595 "occur when combining constants around "
8598 /* Put the constant on the side where it doesn't overflow and is
8599 of lower absolute value and of same sign than before. */
8606 {
8609 variable1,
8613 }
8621 {
8627 variable2);
8628 }
8629 }
8635 /* If we are comparing an expression that just has comparisons
8636 of two integer values, arithmetic expressions of those comparisons,
8637 and constants, we can simplify it. There are only three cases
8638 to check: the two values can either be equal, the first can be
8639 greater, or the second can be greater. Fold the expression for
8640 those three values. Since each value must be 0 or 1, we have
8641 eight possibilities, each of which corresponds to the constant 0
8642 or 1 or one of the six possible comparisons.
8644 This handles common cases like (a > b) == 0 but also handles
8645 expressions like ((x > y) - (y > x)) > 0, which supposedly
8646 occur in macroized code. */
8649 {
8654 /* Don't handle degenerate cases here; they should already
8655 have been handled anyway. */
8664 {
8668 /* We can't just pass T to eval_subst in case cval1 or cval2
8669 was the same as ARG1. */
8671 tree high_result
8675 arg1);
8676 tree equal_result
8680 arg1);
8681 tree low_result
8685 arg1);
8687 /* All three of these results should be 0 or 1. Confirm they are.
8688 Then use those values to select the proper code to use. */
8693 {
8694 /* Make a 3-bit mask with the high-order bit being the
8695 value for `>', the next for '=', and the low for '<'. */
8699 {
8701 /* Always false. */
8722 /* Always true. */
8724 }
8727 {
8731 }
8733 }
8734 }
8735 }
8738 }
8741 /* Subroutine of fold_binary. Optimize complex multiplications of the
8742 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8743 argument EXPR represents the expression "z" of type TYPE. */
8745 static tree
8747 {
8752 {
8755 }
8757 {
8760 }
8761 else
8762 {
8766 }
8775 }
8778 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8779 CONSTRUCTOR ARG into array ELTS, which has NELTS elements, and return
8780 true if successful. */
8782 static bool
8784 {
8788 {
8791 }
8793 {
8799 else
8801 }
8802 else
8808 }
8810 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8811 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8812 NULL_TREE otherwise. */
8814 static tree
8816 {
8835 {
8839 }
8842 {
8848 }
8849 else
8851 }
8853 /* Try to fold a pointer difference of type TYPE two address expressions of
8854 array references AREF0 and AREF1 using location LOC. Return a
8855 simplified expression for the difference or NULL_TREE. */
8857 static tree
8861 {
8866 /* If the bases are array references as well, recurse. If the bases
8867 are pointer indirections compute the difference of the pointers.
8868 If the bases are equal, we are set. */
8871 && (base_offset
8873 use_pointer_diff)))
8876 && (base_offset
8877 = use_pointer_diff
8887 {
8893 base_offset,
8896 }
8898 }
8900 /* If the real or vector real constant CST of type TYPE has an exact
8901 inverse, return it, else return NULL. */
8903 tree
8905 {
8906 REAL_VALUE_TYPE r;
8907 tree unit_type;
8908 machine_mode mode;
8911 {
8921 {
8925 tree_vector_builder elts;
8930 {
8935 }
8938 }
8942 }
8943 }
8945 /* Mask out the tz least significant bits of X of type TYPE where
8946 tz is the number of trailing zeroes in Y. */
8947 static wide_int
8949 {
8954 }
8956 /* Return true when T is an address and is known to be nonzero.
8957 For floating point we further ensure that T is not denormal.
8958 Similar logic is present in nonzero_address in rtlanal.h.
8960 If the return value is based on the assumption that signed overflow
8961 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8962 change *STRICT_OVERFLOW_P. */
8964 static bool
8966 {
8970 /* Doing something useful for floating point would need more work. */
8976 {
8979 strict_overflow_p);
8985 strict_overflow_p);
8993 }
8996 {
8999 strict_overflow_p);
9007 strict_overflow_p);
9022 strict_overflow_p);
9026 strict_overflow_p);
9029 {
9041 }
9045 }
9047 }
9049 /* Return true when T is an address and is known to be nonzero.
9050 Handle warnings about undefined signed overflow. */
9052 bool
9054 {
9061 "determining that expression is always "
9063 WARN_STRICT_OVERFLOW_MISC);
9065 }
9067 /* Return true if T is known not to be equal to an integer W. */
9069 bool
9071 {
9073 value_range_type rtype;
9075 {
9084 {
9089 }
9094 /* If T has some known zero bits and W has any of those bits set,
9095 then T is known not to be equal to W. */
9103 }
9104 }
9106 /* Fold a binary expression of code CODE and type TYPE with operands
9107 OP0 and OP1. LOC is the location of the resulting expression.
9108 Return the folded expression if folding is successful. Otherwise,
9109 return NULL_TREE. */
9111 tree
9114 {
9129 /* Strip any conversions that don't change the mode. This is
9130 safe for every expression, except for a comparison expression
9131 because its signedness is derived from its operands. So, in
9132 the latter case, only strip conversions that don't change the
9133 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9134 preserved.
9136 Note that this is done as an internal manipulation within the
9137 constant folder, in order to find the simplest representation
9138 of the arguments so that their form can be studied. In any
9139 cases, the appropriate type conversions should be put back in
9140 the tree that will get out of the constant folder. */
9143 {
9146 }
9147 else
9148 {
9151 }
9153 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9154 constant but we can't do arithmetic on them. */
9156 {
9159 {
9163 }
9164 }
9166 /* If this is a commutative operation, and ARG0 is a constant, move it
9167 to ARG1 to reduce the number of tests below. */
9172 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9173 to ARG1 to reduce the number of tests below. */
9182 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9184 First check for cases where an arithmetic operation is applied to a
9185 compound, conditional, or comparison operation. Push the arithmetic
9186 operation inside the compound or conditional to see if any folding
9187 can then be done. Convert comparison to conditional for this purpose.
9188 The also optimizes non-constant cases that used to be done in
9189 expand_expr.
9191 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9192 one of the operands is a comparison and the other is a comparison, a
9193 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9194 code below would make the expression more complex. Change it to a
9195 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9196 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9209 {
9213 boolean_type_node,
9221 }
9225 {
9227 {
9232 tem);
9233 }
9235 {
9240 tem);
9241 }
9246 {
9252 }
9257 {
9263 }
9264 }
9267 {
9269 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9272 {
9278 }
9280 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9283 {
9284 tree base;
9285 HOST_WIDE_INT coffset;
9294 }
9299 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9305 arg1),
9307 arg0)));
9313 {
9314 /* X + (X / CST) * -CST is X % CST. */
9319 {
9328 cst0));
9329 }
9330 }
9332 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9333 one. Make sure the type is not saturating and has the signedness of
9334 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9335 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9342 {
9346 }
9349 {
9350 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9351 (plus (plus (mult) (mult)) (foo)) so that we can
9352 take advantage of the factoring cases below. */
9361 {
9367 else
9380 parg0),
9382 marg)),
9386 return
9392 parg1)));
9393 }
9394 }
9395 else
9396 {
9397 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9398 to __complex__ ( x, y ). This is not the same for SNaNs or
9399 if signed zeros are involved. */
9403 {
9410 {
9414 {
9420 }
9422 {
9428 }
9429 }
9430 }
9432 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9433 We associate floats only if the user has specified
9434 -fassociative-math. */
9438 {
9443 {
9444 tree tree0;
9447 }
9448 }
9449 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9450 We associate floats only if the user has specified
9451 -fassociative-math. */
9455 {
9460 {
9461 tree tree0;
9464 }
9465 }
9466 }
9468 bit_rotate:
9469 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9470 is a rotate of A by C1 bits. */
9471 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9472 is a rotate of A by B bits.
9473 Similarly for (A << B) | (A >> (-B & C3)) where C3 is Z-1,
9474 though in this case CODE must be | and not + or ^, otherwise
9475 it doesn't return A when B is 0. */
9476 {
9478 tree rtype;
9487 /* Only create rotates in complete modes. Other cases are not
9488 expanded properly. */
9491 {
9504 {
9509 }
9514 {
9517 code0 == LSHIFT_EXPR
9520 }
9522 {
9532 {
9536 orig_tree01);
9538 }
9539 }
9543 {
9554 {
9558 orig_tree01);
9560 }
9561 }
9562 }
9563 }
9565 associate:
9566 /* In most languages, can't associate operations on floats through
9567 parentheses. Rather than remember where the parentheses were, we
9568 don't associate floats at all, unless the user has specified
9569 -fassociative-math.
9570 And, we need to make sure type is not saturating. */
9574 {
9580 /* Split both trees into variables, constants, and literals. Then
9581 associate each group together, the constants with literals,
9582 then the result with variables. This increases the chances of
9583 literals being recombined later and of generating relocatable
9584 expressions for the sum of a constant and literal. */
9592 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9596 /* With undefined overflow prefer doing association in a type
9597 which wraps on overflow, if that is one of the operand types. */
9600 {
9608 }
9610 /* With undefined overflow we can only associate constants with one
9611 variable, and constants whose association doesn't overflow. */
9614 {
9616 {
9617 /* ??? If split_tree would handle NEGATE_EXPR we could
9618 simply reject these cases and the allowed cases would
9619 be the var0/minus_var1 ones. */
9625 {
9628 }
9635 {
9638 }
9644 /* The only case we can still associate with two variables
9645 is if they cancel out. */
9649 }
9655 }
9657 /* Only do something if we found more than two objects. Otherwise,
9658 nothing has changed and we risk infinite recursion. */
9666 {
9678 {
9682 }
9684 {
9688 }
9690 /* Preserve the MINUS_EXPR if the negative part of the literal is
9691 greater than the positive part. Otherwise, the multiplicative
9692 folding code (i.e extract_muldiv) may be fooled in case
9693 unsigned constants are subtracted, like in the following
9694 example: ((X*2 + 4) - 8U)/2. */
9696 {
9700 /* But avoid ending up with only negated parts. */
9702 {
9706 }
9707 else
9708 {
9712 }
9713 }
9715 /* Don't introduce overflows through reassociation. */
9720 /* Eliminate lit0 and minus_lit0 to con0 and minus_con0. */
9727 /* Eliminate minus_con0. */
9729 {
9736 else
9739 }
9741 /* Eliminate minus_var0. */
9743 {
9747 else
9750 }
9752 return
9755 }
9756 }
9762 /* Fold &a[i] - &a[j] to i-j. */
9767 {
9771 code
9775 }
9777 /* Further transformations are not for pointers. */
9781 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9784 /* If arg0 is e.g. unsigned int and type is int, then this could
9785 introduce UB, because if A is INT_MIN at runtime, the original
9786 expression can be well defined while the latter is not.
9787 See PR83269. */
9796 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9797 __complex__ ( x, -y ). This is not the same for SNaNs or if
9798 signed zeros are involved. */
9802 {
9809 {
9813 {
9815 arg1r ? arg1r
9820 }
9822 {
9826 arg1i ? arg1i
9829 }
9830 }
9831 }
9833 /* A - B -> A + (-B) if B is easily negatable. */
9837 /* Avoid this transformation if B is a positive REAL_CST. */
9845 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9846 one. Make sure the type is not saturating and has the signedness of
9847 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9848 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9855 {
9859 }
9865 {
9866 /* Transform x * -C into -x * C if x is easily negatable. */
9881 {
9884 "occur when simplifying "
9886 WARN_STRICT_OVERFLOW_MISC);
9888 }
9890 /* Optimize z * conj(z) for integer complex numbers. */
9897 }
9898 else
9899 {
9900 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9901 This is not the same for NaNs or if signed zeros are
9902 involved. */
9908 {
9911 return
9917 return
9922 }
9924 /* Optimize z * conj(z) for floating point complex numbers.
9925 Guarded by flag_unsafe_math_optimizations as non-finite
9926 imaginary components don't produce scalar results. */
9935 }
9939 /* Canonicalize (X & C1) | C2. */
9943 {
9948 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9956 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9958 {
9961 }
9963 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9964 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9965 mode which allows further optimizations. */
9970 {
9975 {
9978 }
9979 }
9982 {
9987 }
9988 }
9990 /* See if this can be simplified into a rotate first. If that
9991 is unsuccessful continue in the association code. */
9995 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10003 /* See if this can be simplified into a rotate first. If that
10004 is unsuccessful continue in the association code. */
10008 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10013 {
10014 tree tem2;
10021 }
10022 /* Fold ~X & 1 as (X & 1) == 0. */
10026 {
10027 tree tem2;
10034 }
10035 /* Fold !X & 1 as X == 0. */
10038 {
10042 }
10044 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10045 multiple of 1 << CST. */
10047 {
10054 }
10056 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10057 bits from CST2. */
10061 {
10063 wide_int masked
10070 {
10071 /* Avoid the transform if arg1 is a mask of some
10072 mode which allows further optimizations. */
10079 }
10080 }
10082 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10083 ((A & N) + B) & M -> (A + B) & M
10084 Similarly if (N & M) == 0,
10085 ((A | N) + B) & M -> (A + B) & M
10086 and for - instead of + (or unary - instead of +)
10087 and/or ^ instead of |.
10088 If B is constant and (B & M) == 0, fold into A & M. */
10090 {
10099 {
10102 wide_int cst0;
10104 /* Now we know that arg0 is (C + D) or (C - D) or
10105 -C and arg1 (M) is == (1LL << cst) - 1.
10106 Store C into PMOP[0] and D into PMOP[1]. */
10110 {
10113 }
10120 {
10129 {
10132 }
10135 /* If C or D is of the form (A & N) where
10136 (N & M) == M, or of the form (A | N) or
10137 (A ^ N) where (N & M) == 0, replace it with A. */
10141 /* If C or D is a N where (N & M) == 0, it can be
10142 omitted (assumed 0). */
10150 }
10152 /* Only build anything new if we optimized one or both arguments
10153 above. */
10157 {
10160 {
10161 /* Perform the operations in a type that has defined
10162 overflow behavior. */
10168 }
10173 {
10181 else
10183 }
10186 else
10189 /* TEM is now the new binary +, - or unary - replacement. */
10193 }
10194 }
10195 }
10197 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10200 {
10205 return
10207 }
10212 /* Don't touch a floating-point divide by zero unless the mode
10213 of the constant can represent infinity. */
10219 /* (-A) / (-B) -> A / B */
10231 /* Fall through */
10234 /* Simplify A / (B << N) where A and B are positive and B is
10235 a power of 2, to A >> (N + log2(B)). */
10240 {
10243 {
10251 WARN_STRICT_OVERFLOW_MISC);
10257 }
10258 }
10260 /* Fall through */
10268 /* Convert -A / -B to A / B when the type is signed and overflow is
10269 undefined. */
10273 {
10276 "when distributing negation across "
10278 WARN_STRICT_OVERFLOW_MISC);
10283 }
10287 {
10290 "when distributing negation across "
10292 WARN_STRICT_OVERFLOW_MISC);
10297 }
10299 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10300 operation, EXACT_DIV_EXPR.
10302 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10303 At one time others generated faster code, it's not clear if they do
10304 after the last round to changes to the DIV code in expmed.c. */
10315 {
10319 WARN_STRICT_OVERFLOW_MISC);
10321 }
10333 {
10337 WARN_STRICT_OVERFLOW_MISC);
10339 }
10347 /* Since negative shift count is not well-defined,
10348 don't try to compute it in the compiler. */
10354 /* If we have a rotate of a bit operation with the rotate count and
10355 the second operand of the bit operation both constant,
10356 permute the two operations. */
10362 {
10370 }
10372 /* Two consecutive rotates adding up to the some integer
10373 multiple of the precision of the type can be ignored. */
10389 /* Note that the operands of this must be ints
10390 and their values must be 0 or 1.
10391 ("true" is a fixed value perhaps depending on the language.) */
10392 /* If first arg is constant zero, return it. */
10395 /* FALLTHRU */
10397 /* If either arg is constant true, drop it. */
10401 /* Preserve sequence points. */
10404 /* If second arg is constant zero, result is zero, but first arg
10405 must be evaluated. */
10408 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10409 case will be handled here. */
10413 /* !X && X is always false. */
10417 /* X && !X is always false. */
10422 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10423 means A >= Y && A != MAX, but in this case we know that
10424 A < X <= MAX. */
10428 {
10436 }
10445 /* Note that the operands of this must be ints
10446 and their values must be 0 or true.
10447 ("true" is a fixed value perhaps depending on the language.) */
10448 /* If first arg is constant true, return it. */
10451 /* FALLTHRU */
10453 /* If either arg is constant zero, drop it. */
10457 /* Preserve sequence points. */
10460 /* If second arg is constant true, result is true, but we must
10461 evaluate first arg. */
10464 /* Likewise for first arg, but note this only occurs here for
10465 TRUTH_OR_EXPR. */
10469 /* !X || X is always true. */
10473 /* X || !X is always true. */
10478 /* (X && !Y) || (!X && Y) is X ^ Y */
10481 {
10498 }
10507 /* If the second arg is constant zero, drop it. */
10510 /* If the second arg is constant true, this is a logical inversion. */
10512 {
10515 }
10516 /* Identical arguments cancel to zero. */
10520 /* !X ^ X is always true. */
10525 /* X ^ !X is always true. */
10541 /* bool_var != 1 becomes !bool_var. */
10548 /* bool_var == 0 becomes !bool_var. */
10555 /* !exp != 0 becomes !exp */
10560 /* If this is an EQ or NE comparison with zero and ARG0 is
10561 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10562 two operations, but the latter can be done in one less insn
10563 on machines that have only two-operand insns or on which a
10564 constant cannot be the first operand. */
10567 {
10572 {
10579 arg1);
10580 }
10583 {
10590 arg1);
10591 }
10592 }
10594 /* If this is an NE or EQ comparison of zero against the result of a
10595 signed MOD operation whose second operand is a power of 2, make
10596 the MOD operation unsigned since it is simpler and equivalent. */
10604 {
10614 }
10616 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10617 C1 is a valid shift constant, and C2 is a power of two, i.e.
10618 a single bit. */
10622 == INTEGER_CST
10625 {
10630 /* Check for a valid shift count. */
10632 {
10636 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10637 can be rewritten as (X & (C2 << C1)) != 0. */
10639 {
10644 }
10645 /* Otherwise, for signed (arithmetic) shifts,
10646 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10647 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10651 /* Otherwise, of unsigned (logical) shifts,
10652 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10653 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10654 else
10658 arg000);
10659 }
10660 }
10662 /* If this is a comparison of a field, we may be able to simplify it. */
10665 /* Handle the constant case even without -O
10666 to make sure the warnings are given. */
10668 {
10672 }
10674 /* Optimize comparisons of strlen vs zero to a compare of the
10675 first character of the string vs zero. To wit,
10676 strlen(ptr) == 0 => *ptr == 0
10677 strlen(ptr) != 0 => *ptr != 0
10678 Other cases should reduce to one of these two (or a constant)
10679 due to the return value of strlen being unsigned. */
10682 {
10690 {
10695 }
10696 }
10698 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10699 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10703 {
10708 {
10710 {
10713 }
10716 }
10717 }
10719 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10720 (X & C) == 0 when C is a single bit. */
10725 {
10732 arg1));
10733 }
10735 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10736 constant C is a power of two, i.e. a single bit. */
10743 {
10747 }
10749 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10750 when is C is a power of two, i.e. a single bit. */
10757 {
10763 }
10767 {
10770 }
10772 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10775 {
10783 {
10789 }
10791 {
10797 }
10799 {
10805 }
10807 {
10813 }
10814 }
10818 {
10825 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10826 operand_equal_p guarantees no side-effects so we don't need
10827 to use omit_one_operand on Z. */
10831 arg10));
10835 arg11));
10839 arg10));
10843 arg11));
10845 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10848 {
10854 }
10855 }
10857 /* Attempt to simplify equality/inequality comparisons of complex
10858 values. Only lower the comparison if the result is known or
10859 can be simplified to a single scalar comparison. */
10864 {
10869 {
10872 }
10873 else
10874 {
10877 }
10880 {
10883 }
10884 else
10885 {
10888 }
10892 {
10894 {
10899 }
10900 else
10901 {
10906 }
10907 }
10911 {
10913 {
10918 }
10919 else
10920 {
10925 }
10926 }
10927 }
10939 /* Transform comparisons of the form X +- C CMP X. */
10944 {
10949 /* (X - c) > X becomes false. */
10955 /* Likewise (X + c) < X becomes false. */
10961 /* Convert (X - c) <= X to true. */
10968 /* Convert (X + c) >= X to true. */
10974 }
10976 /* If we are comparing an ABS_EXPR with a constant, we can
10977 convert all the cases into explicit comparisons, but they may
10978 well not be faster than doing the ABS and one comparison.
10979 But ABS (X) <= C is a range comparison, which becomes a subtraction
10980 and a comparison, and is probably faster. */
10994 /* Convert ABS_EXPR<x> >= 0 to true. */
11001 {
11004 "when simplifying comparison of "
11006 WARN_STRICT_OVERFLOW_CONDITIONAL);
11009 arg0);
11010 }
11012 /* Convert ABS_EXPR<x> < 0 to false. */
11017 {
11020 "when simplifying comparison of "
11022 WARN_STRICT_OVERFLOW_CONDITIONAL);
11025 arg0);
11026 }
11028 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11029 and similarly for >= into !=. */
11039 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11040 otherwise Y might be >= # of bits in X's type and thus e.g.
11041 (unsigned char) (1 << Y) for Y 15 might be 0.
11042 If the cast is widening, then 1 << Y should have unsigned type,
11043 otherwise if Y is number of bits in the signed shift type minus 1,
11044 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11045 31 might be 0xffffffff80000000. */
11056 {
11062 }
11074 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11075 {
11087 }
11092 /* When pedantic, a compound expression can be neither an lvalue
11093 nor an integer constant expression. */
11096 /* Don't let (0, 0) be null pointer constant. */
11102 /* An ASSERT_EXPR should never be passed to fold_binary. */
11108 }
11110 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11111 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11112 of GOTO_EXPR. */
11114 static tree
11116 {
11118 {
11125 /* fall through */
11129 }
11130 }
11132 /* Return whether the sub-tree ST contains a label which is accessible from
11133 outside the sub-tree. */
11135 static bool
11137 {
11138 return
11140 }
11142 /* Fold a ternary expression of code CODE and type TYPE with operands
11143 OP0, OP1, and OP2. Return the folded expression if folding is
11144 successful. Otherwise, return NULL_TREE. */
11146 tree
11149 {
11150 tree tem;
11157 /* If this is a commutative operation, and OP0 is a constant, move it
11158 to OP1 to reduce the number of tests below. */
11167 /* Strip any conversions that don't change the mode. This is safe
11168 for every expression, except for a comparison expression because
11169 its signedness is derived from its operands. So, in the latter
11170 case, only strip conversions that don't change the signedness.
11172 Note that this is done as an internal manipulation within the
11173 constant folder, in order to find the simplest representation of
11174 the arguments so that their form can be studied. In any cases,
11175 the appropriate type conversions should be put back in the tree
11176 that will get out of the constant folder. */
11178 {
11181 }
11184 {
11187 }
11190 {
11193 }
11196 {
11200 {
11206 }
11211 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11212 so all simple results must be passed through pedantic_non_lvalue. */
11214 {
11217 /* Only optimize constant conditions when the selected branch
11218 has the same type as the COND_EXPR. This avoids optimizing
11219 away "c ? x : throw", where the throw has a void type.
11220 Avoid throwing away that operand which contains label. */
11227 }
11229 {
11234 {
11239 {
11247 }
11251 }
11252 }
11254 /* If we have A op B ? A : C, we may be able to convert this to a
11255 simpler expression, depending on the operation and the values
11256 of B and C. Signed zeros prevent all of these transformations,
11257 for reasons given above each one.
11259 Also try swapping the arguments and inverting the conditional. */
11263 {
11267 }
11272 {
11276 {
11280 }
11281 }
11283 /* If the second operand is simpler than the third, swap them
11284 since that produces better jump optimization results. */
11287 {
11289 /* See if this can be inverted. If it can't, possibly because
11290 it was a floating-point inequality comparison, don't do
11291 anything. */
11295 }
11297 /* Convert A ? 1 : 0 to simply A. */
11302 /* If we try to convert OP0 to our type, the
11303 call to fold will try to move the conversion inside
11304 a COND, which will recurse. In that case, the COND_EXPR
11305 is probably the best choice, so leave it alone. */
11309 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11310 over COND_EXPR in cases such as floating point comparisons. */
11319 arg0)));
11321 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11326 {
11327 /* sign_bit_p looks through both zero and sign extensions,
11328 but for this optimization only sign extensions are
11329 usable. */
11332 {
11335 {
11338 }
11340 }
11341 /* sign_bit_p only checks ARG1 bits within A's precision.
11342 If <sign bit of A> has wider type than A, bits outside
11343 of A's precision in <sign bit of A> need to be checked.
11344 If they are all 0, this optimization needs to be done
11345 in unsigned A's type, if they are all 1 in signed A's type,
11346 otherwise this can't be done. */
11352 {
11354 tree tem_type;
11367 {
11370 }
11372 {
11375 }
11376 else
11378 }
11381 return
11387 arg1)));
11388 }
11390 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11391 already handled above. */
11396 {
11406 op1);
11407 }
11409 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11410 is probably obsolete because the first operand should be a
11411 truth value (that's why we have the two cases above), but let's
11412 leave it in until we can confirm this for all front-ends. */
11424 /* Disable the transformations below for vectors, since
11425 fold_binary_op_with_conditional_arg may undo them immediately,
11426 yielding an infinite loop. */
11430 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11439 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11444 {
11446 /* Only perform transformation if ARG0 is easily inverted. */
11450 ? BIT_IOR_EXPR
11453 op1);
11454 }
11456 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11461 {
11463 /* Only perform transformation if ARG0 is easily inverted. */
11469 op2);
11470 }
11472 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11484 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11485 of fold_ternary on them. */
11493 {
11503 {
11508 {
11516 }
11517 }
11518 }
11520 /* On constants we can use native encode/interpret to constant
11521 fold (nearly) all BIT_FIELD_REFs. */
11525 {
11528 /* Limit us to a reasonable amount of work. To relax the
11529 other limitations we need bit-shifting of the buffer
11530 and rounding up the size. */
11534 {
11536 unsigned HOST_WIDE_INT len
11541 {
11546 }
11547 }
11548 }
11553 /* For integers we can decompose the FMA if possible. */
11565 {
11581 {
11586 /* Make sure that the perm value is in an acceptable
11587 range. */
11596 else
11604 }
11607 {
11612 }
11617 {
11622 }
11628 {
11632 }
11637 /* Some targets are deficient and fail to expand a single
11638 argument permutation while still allowing an equivalent
11639 2-argument version. */
11643 {
11646 }
11649 {
11656 }
11660 }
11664 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11667 {
11673 wide_int tem2
11677 }
11682 {
11684 unsigned HOST_WIDE_INT elsize
11687 {
11691 else
11692 {
11699 }
11700 }
11701 }
11707 }
11709 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11710 of an array (or vector). */
11712 tree
11714 {
11719 {
11722 {
11723 /* Static constructors for variably sized objects makes no sense. */
11727 }
11728 }
11739 offset_int max_index;
11744 {
11745 /* Array constructor might explicitly set index, or specify a range,
11746 or leave index NULL meaning that it is next index after previous
11747 one. */
11749 {
11752 else
11753 {
11757 }
11758 }
11759 else
11760 {
11766 }
11768 /* Do we have match? */
11772 }
11774 }
11776 /* Perform constant folding and related simplification of EXPR.
11777 The related simplifications include x*1 => x, x*0 => 0, etc.,
11778 and application of the associative law.
11779 NOP_EXPR conversions may be removed freely (as long as we
11780 are careful not to change the type of the overall expression).
11781 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11782 but we can constant-fold them if they have constant operands. */
11784 #ifdef ENABLE_FOLD_CHECKING
11785 # define fold(x) fold_1 (x)
11787 static
11788 #endif
11789 tree
11791 {
11795 tree tem;
11798 /* Return right away if a constant. */
11802 /* CALL_EXPR-like objects with variable numbers of operands are
11803 treated specially. */
11805 {
11807 {
11810 }
11812 }
11815 {
11820 {
11838 }
11839 }
11842 {
11844 {
11851 {
11856 }
11859 }
11861 /* Return a VECTOR_CST if possible. */
11863 {
11869 tree val;
11875 }
11883 }
11885 #ifdef ENABLE_FOLD_CHECKING
11886 #undef fold
11893 /* When --enable-checking=fold, compute a digest of expr before
11894 and after actual fold call to see if fold did not accidentally
11895 change original expr. */
11897 tree
11899 {
11900 tree ret;
11920 }
11922 void
11924 {
11935 }
11937 static void
11939 {
11941 }
11943 static void
11946 {
11952 recursive_label:
11962 {
11963 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
11968 }
11976 {
11977 /* Allow these fields to be modified. */
11978 tree tmp;
11987 {
11990 }
11991 }
12002 {
12005 {
12021 }
12025 {
12038 }
12055 {
12061 }
12064 {
12066 {
12069 }
12071 }
12082 {
12085 }
12095 }
12096 }
12098 /* Helper function for outputting the checksum of a tree T. When
12099 debugging with gdb, you can "define mynext" to be "next" followed
12100 by "call debug_fold_checksum (op0)", then just trace down till the
12101 outputs differ. */
12103 DEBUG_FUNCTION void
12105 {
12120 }
12122 #endif
12124 /* Fold a unary tree expression with code CODE of type TYPE with an
12125 operand OP0. LOC is the location of the resulting expression.
12126 Return a folded expression if successful. Otherwise, return a tree
12127 expression with code CODE of type TYPE with an operand OP0. */
12129 tree
12132 {
12133 tree tem;
12134 #ifdef ENABLE_FOLD_CHECKING
12143 #endif
12149 #ifdef ENABLE_FOLD_CHECKING
12156 #endif
12158 }
12160 /* Fold a binary tree expression with code CODE of type TYPE with
12161 operands OP0 and OP1. LOC is the location of the resulting
12162 expression. Return a folded expression if successful. Otherwise,
12163 return a tree expression with code CODE of type TYPE with operands
12164 OP0 and OP1. */
12166 tree
12169 MEM_STAT_DECL)
12170 {
12171 tree tem;
12172 #ifdef ENABLE_FOLD_CHECKING
12189 #endif
12195 #ifdef ENABLE_FOLD_CHECKING
12210 #endif
12212 }
12214 /* Fold a ternary tree expression with code CODE of type TYPE with
12215 operands OP0, OP1, and OP2. Return a folded expression if
12216 successful. Otherwise, return a tree expression with code CODE of
12217 type TYPE with operands OP0, OP1, and OP2. */
12219 tree
12222 {
12223 tree tem;
12224 #ifdef ENABLE_FOLD_CHECKING
12248 #endif
12255 #ifdef ENABLE_FOLD_CHECKING
12278 #endif
12280 }
12282 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12283 arguments in ARGARRAY, and a null static chain.
12284 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12285 of type TYPE from the given operands as constructed by build_call_array. */
12287 tree
12290 {
12291 tree tem;
12292 #ifdef ENABLE_FOLD_CHECKING
12311 #endif
12317 #ifdef ENABLE_FOLD_CHECKING
12333 #endif
12335 }
12337 /* Perform constant folding and related simplification of initializer
12338 expression EXPR. These behave identically to "fold_buildN" but ignore
12339 potential run-time traps and exceptions that fold must preserve. */
12341 #define START_FOLD_INIT \
12342 int saved_signaling_nans = flag_signaling_nans;\
12343 int saved_trapping_math = flag_trapping_math;\
12344 int saved_rounding_math = flag_rounding_math;\
12345 int saved_trapv = flag_trapv;\
12346 int saved_folding_initializer = folding_initializer;\
12347 flag_signaling_nans = 0;\
12348 flag_trapping_math = 0;\
12349 flag_rounding_math = 0;\
12350 flag_trapv = 0;\
12351 folding_initializer = 1;
12353 #define END_FOLD_INIT \
12354 flag_signaling_nans = saved_signaling_nans;\
12355 flag_trapping_math = saved_trapping_math;\
12356 flag_rounding_math = saved_rounding_math;\
12357 flag_trapv = saved_trapv;\
12358 folding_initializer = saved_folding_initializer;
12360 tree
12363 {
12364 tree result;
12365 START_FOLD_INIT;
12369 END_FOLD_INIT;
12371 }
12373 tree
12376 {
12377 tree result;
12378 START_FOLD_INIT;
12382 END_FOLD_INIT;
12384 }
12386 tree
12389 {
12390 tree result;
12391 START_FOLD_INIT;
12395 END_FOLD_INIT;
12397 }
12399 #undef START_FOLD_INIT
12400 #undef END_FOLD_INIT
12402 /* Determine if first argument is a multiple of second argument. Return 0 if
12403 it is not, or we cannot easily determined it to be.
12405 An example of the sort of thing we care about (at this point; this routine
12406 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12407 fold cases do now) is discovering that
12409 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12411 is a multiple of
12413 SAVE_EXPR (J * 8)
12415 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12417 This code also handles discovering that
12419 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12421 is a multiple of 8 so we don't have to worry about dealing with a
12422 possible remainder.
12424 Note that we *look* inside a SAVE_EXPR only to determine how it was
12425 calculated; it is not safe for fold to do much of anything else with the
12426 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12427 at run time. For example, the latter example above *cannot* be implemented
12428 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12429 evaluation time of the original SAVE_EXPR is not necessarily the same at
12430 the time the new expression is evaluated. The only optimization of this
12431 sort that would be valid is changing
12433 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12435 divided by 8 to
12437 SAVE_EXPR (I) * SAVE_EXPR (J)
12439 (where the same SAVE_EXPR (J) is used in the original and the
12440 transformed version). */
12442 int
12444 {
12455 {
12457 /* Bitwise and provides a power of two multiple. If the mask is
12458 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12461 /* FALLTHRU */
12468 /* It is impossible to prove if op0 - op1 is multiple of bottom
12469 precisely, so be conservative here checking if both op0 and op1
12470 are multiple of bottom. Note we check the second operand first
12471 since it's usually simpler. */
12476 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12477 as op0 - 3 if the expression has unsigned type. For example,
12478 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12488 {
12490 /* const_binop may not detect overflow correctly,
12491 so check for it explicitly here. */
12496 size_one_node,
12497 op1)))
12500 }
12504 /* Can't handle conversions from non-integral or wider integral type. */
12510 /* fall through */
12527 SIGNED);
12533 {
12536 /* Check for special cases to see if top is defined as multiple
12537 of bottom:
12539 top = (X & ~(bottom - 1) ; bottom is power of 2
12541 or
12543 Y = X % bottom
12544 top = X - Y. */
12563 }
12565 /* fall through */
12569 }
12570 }
12572 #define tree_expr_nonnegative_warnv_p(X, Y) \
12575 #define RECURSE(X) \
12576 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12578 /* Return true if CODE or TYPE is known to be non-negative. */
12580 static bool
12582 {
12585 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12586 have a signed:1 type (where the value is -1 and 0). */
12589 }
12591 /* Return true if (CODE OP0) is known to be non-negative. If the return
12592 value is based on the assumption that signed overflow is undefined,
12593 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12594 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12596 bool
12599 {
12604 {
12606 /* We can't return 1 if flag_wrapv is set because
12607 ABS_EXPR<INT_MIN> = INT_MIN. */
12611 {
12614 }
12622 CASE_CONVERT:
12623 {
12628 {
12632 {
12636 }
12637 }
12639 {
12645 }
12646 }
12651 }
12653 /* We don't know sign of `t', so be conservative and return false. */
12655 }
12657 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12658 value is based on the assumption that signed overflow is undefined,
12659 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12660 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12662 bool
12666 {
12671 {
12677 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12678 both unsigned and at least 2 bits shorter than the result. */
12682 {
12687 {
12691 }
12692 }
12697 {
12698 /* x * x is always non-negative for floating point x
12699 or without overflow. */
12702 {
12707 }
12708 }
12710 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12711 both unsigned and their total bits is shorter than the result. */
12715 {
12734 {
12744 }
12745 }
12772 }
12774 /* We don't know sign of `t', so be conservative and return false. */
12776 }
12778 /* Return true if T is known to be non-negative. If the return
12779 value is based on the assumption that signed overflow is undefined,
12780 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12781 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12783 bool
12785 {
12790 {
12804 /* Limit the depth of recursion to avoid quadratic behavior.
12805 This is expected to catch almost all occurrences in practice.
12806 If this code misses important cases that unbounded recursion
12807 would not, passes that need this information could be revised
12808 to provide it through dataflow propagation. */
12816 }
12817 }
12819 /* Return true if T is known to be non-negative. If the return
12820 value is based on the assumption that signed overflow is undefined,
12821 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12822 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12824 bool
12827 {
12829 {
12830 CASE_CFN_ACOS:
12831 CASE_CFN_ACOSH:
12832 CASE_CFN_CABS:
12833 CASE_CFN_COSH:
12834 CASE_CFN_ERFC:
12835 CASE_CFN_EXP:
12836 CASE_CFN_EXP10:
12837 CASE_CFN_EXP2:
12838 CASE_CFN_FABS:
12839 CASE_CFN_FDIM:
12840 CASE_CFN_HYPOT:
12841 CASE_CFN_POW10:
12842 CASE_CFN_FFS:
12843 CASE_CFN_PARITY:
12844 CASE_CFN_POPCOUNT:
12845 CASE_CFN_CLZ:
12846 CASE_CFN_CLRSB:
12849 /* Always true. */
12852 CASE_CFN_SQRT:
12853 CASE_CFN_SQRT_FN:
12854 /* sqrt(-0.0) is -0.0. */
12859 CASE_CFN_ASINH:
12860 CASE_CFN_ATAN:
12861 CASE_CFN_ATANH:
12862 CASE_CFN_CBRT:
12863 CASE_CFN_CEIL:
12864 CASE_CFN_ERF:
12865 CASE_CFN_EXPM1:
12866 CASE_CFN_FLOOR:
12867 CASE_CFN_FMOD:
12868 CASE_CFN_FREXP:
12869 CASE_CFN_ICEIL:
12870 CASE_CFN_IFLOOR:
12871 CASE_CFN_IRINT:
12872 CASE_CFN_IROUND:
12873 CASE_CFN_LCEIL:
12874 CASE_CFN_LDEXP:
12875 CASE_CFN_LFLOOR:
12876 CASE_CFN_LLCEIL:
12877 CASE_CFN_LLFLOOR:
12878 CASE_CFN_LLRINT:
12879 CASE_CFN_LLROUND:
12880 CASE_CFN_LRINT:
12881 CASE_CFN_LROUND:
12882 CASE_CFN_MODF:
12883 CASE_CFN_NEARBYINT:
12884 CASE_CFN_RINT:
12885 CASE_CFN_ROUND:
12886 CASE_CFN_SCALB:
12887 CASE_CFN_SCALBLN:
12888 CASE_CFN_SCALBN:
12889 CASE_CFN_SIGNBIT:
12890 CASE_CFN_SIGNIFICAND:
12891 CASE_CFN_SINH:
12892 CASE_CFN_TANH:
12893 CASE_CFN_TRUNC:
12894 /* True if the 1st argument is nonnegative. */
12897 CASE_CFN_FMAX:
12898 CASE_CFN_FMAX_FN:
12899 /* True if the 1st OR 2nd arguments are nonnegative. */
12902 CASE_CFN_FMIN:
12903 CASE_CFN_FMIN_FN:
12904 /* True if the 1st AND 2nd arguments are nonnegative. */
12907 CASE_CFN_COPYSIGN:
12908 CASE_CFN_COPYSIGN_FN:
12909 /* True if the 2nd argument is nonnegative. */
12912 CASE_CFN_POWI:
12913 /* True if the 1st argument is nonnegative or the second
12914 argument is an even integer. */
12920 CASE_CFN_POW:
12921 /* True if the 1st argument is nonnegative or the second
12922 argument is an even integer valued real. */
12924 {
12925 REAL_VALUE_TYPE c;
12926 HOST_WIDE_INT n;
12931 {
12932 REAL_VALUE_TYPE cint;
12936 }
12937 }
12942 }
12944 }
12946 /* Return true if T is known to be non-negative. If the return
12947 value is based on the assumption that signed overflow is undefined,
12948 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12949 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12951 static bool
12953 {
12959 {
12961 {
12965 /* If the initializer is non-void, then it's a normal expression
12966 that will be assigned to the slot. */
12970 /* Otherwise, the initializer sets the slot in some way. One common
12971 way is an assignment statement at the end of the initializer. */
12973 {
12981 else
12983 }
12989 }
12992 {
12998 arg0,
12999 arg1,
13001 }
13014 }
13015 }
13017 #undef RECURSE
13018 #undef tree_expr_nonnegative_warnv_p
13020 /* Return true if T is known to be non-negative. If the return
13021 value is based on the assumption that signed overflow is undefined,
13022 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13023 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13025 bool
13027 {
13034 {
13056 }
13059 {
13085 }
13086 }
13088 /* Return true if `t' is known to be non-negative. Handle warnings
13089 about undefined signed overflow. */
13091 bool
13093 {
13100 "determining that expression is always "
13102 WARN_STRICT_OVERFLOW_MISC);
13104 }
13107 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13108 For floating point we further ensure that T is not denormal.
13109 Similar logic is present in nonzero_address in rtlanal.h.
13111 If the return value is based on the assumption that signed overflow
13112 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13113 change *STRICT_OVERFLOW_P. */
13115 bool
13118 {
13120 {
13123 strict_overflow_p);
13126 {
13132 strict_overflow_p));
13133 }
13138 strict_overflow_p);
13142 }
13145 }
13147 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13148 For floating point we further ensure that T is not denormal.
13149 Similar logic is present in nonzero_address in rtlanal.h.
13151 If the return value is based on the assumption that signed overflow
13152 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13153 change *STRICT_OVERFLOW_P. */
13155 bool
13157 tree type,
13158 tree op0,
13160 {
13163 {
13167 {
13168 /* With the presence of negative values it is hard
13169 to say something. */
13176 /* One of operands must be positive and the other non-negative. */
13177 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13178 overflows, on a twos-complement machine the sum of two
13179 nonnegative numbers can never be zero. */
13181 strict_overflow_p)
13183 strict_overflow_p));
13184 }
13189 {
13191 strict_overflow_p)
13193 strict_overflow_p))
13194 {
13197 }
13198 }
13207 {
13210 }
13217 {
13221 /* When both operands are nonzero, then MAX must be too. */
13223 strict_overflow_p))
13226 /* MAX where operand 0 is positive is positive. */
13228 strict_overflow_p);
13229 }
13230 /* MAX where operand 1 is positive is positive. */
13235 {
13239 }
13244 strict_overflow_p)
13246 strict_overflow_p));
13250 }
13253 }
13255 /* Return true when T is an address and is known to be nonzero.
13256 For floating point we further ensure that T is not denormal.
13257 Similar logic is present in nonzero_address in rtlanal.h.
13259 If the return value is based on the assumption that signed overflow
13260 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13261 change *STRICT_OVERFLOW_P. */
13263 bool
13265 {
13268 {
13273 {
13285 /* For objects in symbol table check if we know they are non-zero.
13286 Don't do anything for variables and functions before symtab is built;
13287 it is quite possible that they will be declared weak later. */
13292 /* Constants are never weak. */
13297 }
13305 {
13309 }
13319 }
13321 }
13323 #define integer_valued_real_p(X) \
13326 #define RECURSE(X) \
13327 ((integer_valued_real_p) (X, depth + 1))
13329 /* Return true if the floating point result of (CODE OP0) has an
13330 integer value. We also allow +Inf, -Inf and NaN to be considered
13331 integer values. Return false for signaling NaN.
13333 DEPTH is the current nesting depth of the query. */
13335 bool
13337 {
13339 {
13346 CASE_CONVERT:
13347 {
13354 }
13358 }
13360 }
13362 /* Return true if the floating point result of (CODE OP0 OP1) has an
13363 integer value. We also allow +Inf, -Inf and NaN to be considered
13364 integer values. Return false for signaling NaN.
13366 DEPTH is the current nesting depth of the query. */
13368 bool
13370 {
13372 {
13382 }
13384 }
13386 /* Return true if the floating point result of calling FNDECL with arguments
13387 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13388 considered integer values. Return false for signaling NaN. If FNDECL
13389 takes fewer than 2 arguments, the remaining ARGn are null.
13391 DEPTH is the current nesting depth of the query. */
13393 bool
13395 {
13397 {
13398 CASE_CFN_CEIL:
13399 CASE_CFN_FLOOR:
13400 CASE_CFN_NEARBYINT:
13401 CASE_CFN_RINT:
13402 CASE_CFN_ROUND:
13403 CASE_CFN_TRUNC:
13406 CASE_CFN_FMIN:
13407 CASE_CFN_FMIN_FN:
13408 CASE_CFN_FMAX:
13409 CASE_CFN_FMAX_FN:
13414 }
13416 }
13418 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13419 has an integer value. We also allow +Inf, -Inf and NaN to be
13420 considered integer values. Return false for signaling NaN.
13422 DEPTH is the current nesting depth of the query. */
13424 bool
13426 {
13428 {
13436 /* Limit the depth of recursion to avoid quadratic behavior.
13437 This is expected to catch almost all occurrences in practice.
13438 If this code misses important cases that unbounded recursion
13439 would not, passes that need this information could be revised
13440 to provide it through dataflow propagation. */
13444 depth));
13448 }
13450 }
13452 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13453 has an integer value. We also allow +Inf, -Inf and NaN to be
13454 considered integer values. Return false for signaling NaN.
13456 DEPTH is the current nesting depth of the query. */
13458 static bool
13460 {
13462 {
13473 }
13475 }
13477 #undef RECURSE
13478 #undef integer_valued_real_p
13480 /* Return true if the floating point expression T has an integer value.
13481 We also allow +Inf, -Inf and NaN to be considered integer values.
13482 Return false for signaling NaN.
13484 DEPTH is the current nesting depth of the query. */
13486 bool
13488 {
13494 {
13510 }
13513 {
13519 {
13528 }
13532 }
13533 }
13535 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13536 attempt to fold the expression to a constant without modifying TYPE,
13537 OP0 or OP1.
13539 If the expression could be simplified to a constant, then return
13540 the constant. If the expression would not be simplified to a
13541 constant, then return NULL_TREE. */
13543 tree
13545 {
13548 }
13550 /* Given the components of a unary expression CODE, TYPE and OP0,
13551 attempt to fold the expression to a constant without modifying
13552 TYPE or OP0.
13554 If the expression could be simplified to a constant, then return
13555 the constant. If the expression would not be simplified to a
13556 constant, then return NULL_TREE. */
13558 tree
13560 {
13563 }
13565 /* If EXP represents referencing an element in a constant string
13566 (either via pointer arithmetic or array indexing), return the
13567 tree representing the value accessed, otherwise return NULL. */
13569 tree
13571 {
13575 {
13577 tree index;
13578 tree string;
13583 else
13584 {
13588 /* Optimize the special-case of a zero lower bound.
13590 We convert the low_bound to sizetype to avoid some problems
13591 with constant folding. (E.g. suppose the lower bound is 1,
13592 and its mode is QI. Without the conversion,l (ARRAY
13593 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13594 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13600 }
13602 scalar_int_mode char_mode;
13614 }
13616 }
13618 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13619 an integer constant, real, or fixed-point constant.
13621 TYPE is the type of the result. */
13623 static tree
13625 {
13629 {
13631 {
13638 }
13645 {
13646 FIXED_VALUE_TYPE f;
13651 /* Propagate overflow flags. */
13655 }
13659 }
13662 }
13664 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13665 an integer constant or real constant.
13667 TYPE is the type of the result. */
13669 tree
13671 {
13675 {
13677 {
13678 /* If the value is unsigned or non-negative, then the absolute value
13679 is the same as the ordinary value. */
13683 /* If the value is negative, then the absolute value is
13684 its negation. */
13685 else
13686 {
13691 }
13692 }
13698 else
13704 }
13707 }
13709 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13710 constant. TYPE is the type of the result. */
13712 static tree
13714 {
13718 }
13720 /* Given CODE, a relational operator, the target type, TYPE and two
13721 constant operands OP0 and OP1, return the result of the
13722 relational operation. If the result is not a compile time
13723 constant, then return NULL_TREE. */
13725 static tree
13727 {
13730 /* From here on, the only cases we handle are when the result is
13731 known to be a constant. */
13734 {
13738 /* Handle the cases where either operand is a NaN. */
13740 {
13742 {
13770 }
13773 }
13776 }
13779 {
13783 }
13785 /* Handle equality/inequality of complex constants. */
13787 {
13798 else
13800 }
13803 {
13805 {
13806 /* Have vector comparison with scalar boolean result. */
13810 {
13818 }
13820 }
13821 tree_vector_builder elts;
13826 {
13839 }
13842 }
13844 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13846 To compute GT, swap the arguments and do LT.
13847 To compute GE, do LT and invert the result.
13848 To compute LE, swap the arguments, do LT and invert the result.
13849 To compute NE, do EQ and invert the result.
13851 Therefore, the code below must handle only EQ and LT. */
13854 {
13857 }
13859 /* Note that it is safe to invert for real values here because we
13860 have already handled the one case that it matters. */
13864 {
13867 }
13869 /* Compute a result for LT or EQ if args permit;
13870 Otherwise return T. */
13872 {
13875 else
13877 }
13878 else
13884 }
13886 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13887 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13888 itself. */
13890 tree
13892 {
13893 /* If the expression does not have side effects then we don't have to wrap
13894 it with a cleanup point expression. */
13898 /* If the expression is a return, check to see if the expression inside the
13899 return has no side effects or the right hand side of the modify expression
13900 inside the return. If either don't have side effects set we don't need to
13901 wrap the expression in a cleanup point expression. Note we don't check the
13902 left hand side of the modify because it should always be a return decl. */
13904 {
13911 }
13914 }
13916 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13917 of an indirection through OP0, or NULL_TREE if no simplification is
13918 possible. */
13920 tree
13922 {
13924 tree subtype;
13933 {
13936 /* *&CONST_DECL -> to the value of the const decl. */
13939 /* *&p => p; make sure to handle *&"str"[cst] here. */
13941 {
13945 else
13947 }
13948 /* *(foo *)&fooarray => fooarray[0] */
13951 && (!in_gimple_form
13953 {
13963 }
13964 /* *(foo *)&complexfoo => __real__ complexfoo */
13968 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
13971 {
13975 }
13976 }
13980 {
13986 {
13987 tree op00type;
13991 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
13994 {
13996 unsigned HOST_WIDE_INT max_offset
14001 {
14008 }
14009 }
14010 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14013 {
14017 }
14018 /* ((foo *)&fooarray)[1] => fooarray[1] */
14021 {
14028 offset_int remainder;
14031 {
14036 }
14037 }
14038 }
14039 }
14041 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14044 && (!in_gimple_form
14046 {
14047 tree type_domain;
14057 NULL_TREE);
14058 }
14061 }
14063 /* Builds an expression for an indirection through T, simplifying some
14064 cases. */
14066 tree
14068 {
14076 }
14078 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14080 tree
14082 {
14087 else
14089 }
14091 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14092 whose result is ignored. The type of the returned tree need not be
14093 the same as the original expression. */
14095 tree
14097 {
14103 {
14114 else
14120 {
14136 }
14141 }
14142 }
14144 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14146 tree
14148 {
14154 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14155 have to do anything. Only do this when we are not given a const,
14156 because in that case, this check is more expensive than just
14157 doing it. */
14159 {
14164 }
14166 /* If divisor is a power of two, simplify this to bit manipulation. */
14168 {
14170 {
14184 }
14185 else
14186 {
14187 tree t;
14193 }
14194 }
14195 else
14196 {
14201 }
14204 }
14206 /* Likewise, but round down. */
14208 tree
14210 {
14217 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14218 have to do anything. Only do this when we are not given a const,
14219 because in that case, this check is more expensive than just
14220 doing it. */
14222 {
14227 }
14229 /* If divisor is a power of two, simplify this to bit manipulation. */
14231 {
14232 tree t;
14236 }
14237 else
14238 {
14243 }
14246 }
14248 /* Returns the pointer to the base of the object addressed by EXP and
14249 extracts the information about the offset of the access, storing it
14250 to PBITPOS and POFFSET. */
14252 static tree
14255 {
14256 tree core;
14257 machine_mode mode;
14259 HOST_WIDE_INT bitsize;
14263 {
14268 }
14270 {
14276 {
14281 {
14284 }
14285 }
14286 }
14287 else
14288 {
14292 }
14295 }
14297 /* Returns true if addresses of E1 and E2 differ by a constant, false
14298 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14300 bool
14302 {
14316 {
14326 }
14328 {
14329 /* If only one of the offsets is non-constant, the difference cannot
14330 be a constant. */
14332 }
14333 else
14338 }
14340 /* Return OFF converted to a pointer offset type suitable as offset for
14341 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14342 tree
14344 {
14346 }
14348 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14349 tree
14351 {
14354 }
14356 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14357 tree
14359 {
14362 }
14364 /* Return a char pointer for a C string if it is a string constant
14365 or sum of string constant and integer constant. We only support
14366 string constants properly terminated with '\0' character.
14367 If STRLEN is a valid pointer, length (including terminating character)
14368 of returned string is stored to the argument. */
14372 {
14373 tree offset_node;
14384 {
14387 else
14389 }
14394 /* Support only properly null-terminated strings. */
14403 }
14405 #if CHECKING_P
14409 /* Helper functions for writing tests of folding trees. */
14411 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14413 static void
14415 tree constant)
14416 {
14418 }
14420 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14421 wrapping WRAPPED_EXPR. */
14423 static void
14425 tree wrapped_expr)
14426 {
14431 }
14433 /* Verify that various arithmetic binary operations are folded
14434 correctly. */
14436 static void
14438 {
14444 /* Addition. */
14445 /* 1 <-- (0 + 1) */
14447 one);
14449 one);
14451 /* (nonlvalue)x <-- (x + 0) */
14453 x);
14455 /* Subtraction. */
14456 /* 0 <-- (x - x) */
14458 zero);
14460 x);
14462 /* Multiplication. */
14463 /* 0 <-- (x * 0) */
14465 zero);
14467 /* (nonlvalue)x <-- (x * 1) */
14469 x);
14470 }
14472 /* Verify that various binary operations on vectors are folded
14473 correctly. */
14475 static void
14477 {
14483 /* Verify equality tests that return a scalar boolean result. */
14489 }
14491 /* Verify folding of VEC_DUPLICATE_EXPRs. */
14493 static void
14495 {
14498 /* This will be 1 if VEC_MODE isn't a vector mode. */
14505 }
14507 /* Run all of the selftests within this file. */
14509 void
14511 {
14515 }