| blob | 5b481a247f2f23861f518c1ef11d8e3f62105f2b |
1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2023 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. */
43 #define INCLUDE_ALGORITHM
90 /* Nonzero if we are folding constants inside an initializer or a C++
91 manifestly-constant-evaluated context; zero otherwise.
92 Should be used when folding in initializer enables additional
93 optimizations. */
96 /* Nonzero if we are folding C++ manifestly-constant-evaluated context; zero
97 otherwise.
98 Should be used when certain constructs shouldn't be optimized
99 during folding in that context. */
102 /* The following constants represent a bit based encoding of GCC's
103 comparison operators. This encoding simplifies transformations
104 on relational comparison operators, such as AND and OR. */
122 };
154 /* This is a helper function to detect min/max for some operands of COND_EXPR.
155 The form is "(EXP0 CMP EXP1) ? EXP2 : EXP3". */
156 tree_code
158 {
168 {
170 {
171 /* X <= Y - 1 equals to X < Y. */
174 /* X > Y - 1 equals to X >= Y. */
177 /* a != MIN_RANGE<a> ? a : MIN_RANGE<a>+1 -> MAX_EXPR<MIN_RANGE<a>+1, a> */
179 {
180 value_range r;
189 }
190 }
192 {
193 /* X < Y + 1 equals to X <= Y. */
196 /* X >= Y + 1 equals to X > Y. */
199 /* a != MAX_RANGE<a> ? a : MAX_RANGE<a>-1 -> MIN_EXPR<MIN_RANGE<a>-1, a> */
201 {
202 value_range r;
211 }
212 }
213 }
216 {
221 }
223 }
225 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
226 Otherwise, return LOC. */
228 static location_t
230 {
233 }
235 /* Similar to protected_set_expr_location, but never modify x in place,
236 if location can and needs to be set, unshare it. */
238 tree
240 {
246 {
249 }
251 }
252 \f
253 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
254 division and returns the quotient. Otherwise returns
255 NULL_TREE. */
257 tree
259 {
260 widest_int quo;
267 }
268 \f
269 /* This is nonzero if we should defer warnings about undefined
270 overflow. This facility exists because these warnings are a
271 special case. The code to estimate loop iterations does not want
272 to issue any warnings, since it works with expressions which do not
273 occur in user code. Various bits of cleanup code call fold(), but
274 only use the result if it has certain characteristics (e.g., is a
275 constant); that code only wants to issue a warning if the result is
276 used. */
280 /* If a warning about undefined overflow is deferred, this is the
281 warning. Note that this may cause us to turn two warnings into
282 one, but that is fine since it is sufficient to only give one
283 warning per expression. */
287 /* If a warning about undefined overflow is deferred, this is the
288 level at which the warning should be emitted. */
292 /* Start deferring overflow warnings. We could use a stack here to
293 permit nested calls, but at present it is not necessary. */
295 void
297 {
299 }
301 /* Stop deferring overflow warnings. If there is a pending warning,
302 and ISSUE is true, then issue the warning if appropriate. STMT is
303 the statement with which the warning should be associated (used for
304 location information); STMT may be NULL. CODE is the level of the
305 warning--a warn_strict_overflow_code value. This function will use
306 the smaller of CODE and the deferred code when deciding whether to
307 issue the warning. CODE may be zero to mean to always use the
308 deferred code. */
310 void
312 {
314 location_t locus;
319 {
325 }
336 /* Use the smallest code level when deciding to issue the
337 warning. */
346 else
349 }
351 /* Stop deferring overflow warnings, ignoring any deferred
352 warnings. */
354 void
356 {
358 }
360 /* Whether we are deferring overflow warnings. */
362 bool
364 {
366 }
368 /* This is called when we fold something based on the fact that signed
369 overflow is undefined. */
371 void
373 {
375 {
378 {
381 }
382 }
385 }
386 \f
387 /* Return true if the built-in mathematical function specified by CODE
388 is odd, i.e. -f(x) == f(-x). */
390 bool
392 {
394 {
395 CASE_CFN_ASIN:
396 CASE_CFN_ASIN_FN:
397 CASE_CFN_ASINH:
398 CASE_CFN_ASINH_FN:
399 CASE_CFN_ATAN:
400 CASE_CFN_ATAN_FN:
401 CASE_CFN_ATANH:
402 CASE_CFN_ATANH_FN:
403 CASE_CFN_CASIN:
404 CASE_CFN_CASIN_FN:
405 CASE_CFN_CASINH:
406 CASE_CFN_CASINH_FN:
407 CASE_CFN_CATAN:
408 CASE_CFN_CATAN_FN:
409 CASE_CFN_CATANH:
410 CASE_CFN_CATANH_FN:
411 CASE_CFN_CBRT:
412 CASE_CFN_CBRT_FN:
413 CASE_CFN_CPROJ:
414 CASE_CFN_CPROJ_FN:
415 CASE_CFN_CSIN:
416 CASE_CFN_CSIN_FN:
417 CASE_CFN_CSINH:
418 CASE_CFN_CSINH_FN:
419 CASE_CFN_CTAN:
420 CASE_CFN_CTAN_FN:
421 CASE_CFN_CTANH:
422 CASE_CFN_CTANH_FN:
423 CASE_CFN_ERF:
424 CASE_CFN_ERF_FN:
425 CASE_CFN_LLROUND:
426 CASE_CFN_LLROUND_FN:
427 CASE_CFN_LROUND:
428 CASE_CFN_LROUND_FN:
429 CASE_CFN_ROUND:
430 CASE_CFN_ROUNDEVEN:
431 CASE_CFN_ROUNDEVEN_FN:
432 CASE_CFN_SIN:
433 CASE_CFN_SIN_FN:
434 CASE_CFN_SINH:
435 CASE_CFN_SINH_FN:
436 CASE_CFN_TAN:
437 CASE_CFN_TAN_FN:
438 CASE_CFN_TANH:
439 CASE_CFN_TANH_FN:
440 CASE_CFN_TRUNC:
441 CASE_CFN_TRUNC_FN:
444 CASE_CFN_LLRINT:
445 CASE_CFN_LLRINT_FN:
446 CASE_CFN_LRINT:
447 CASE_CFN_LRINT_FN:
448 CASE_CFN_NEARBYINT:
449 CASE_CFN_NEARBYINT_FN:
450 CASE_CFN_RINT:
451 CASE_CFN_RINT_FN:
456 }
458 }
460 /* Check whether we may negate an integer constant T without causing
461 overflow. */
463 bool
465 {
466 tree type;
475 }
477 /* Determine whether an expression T can be cheaply negated using
478 the function negate_expr without introducing undefined overflow. */
480 static bool
482 {
483 tree type;
492 {
497 /* Check that -CST will not overflow type. */
510 /* We want to canonicalize to positive real constants. Pretend
511 that only negative ones can be easily negated. */
519 {
523 /* Steps don't prevent negation. */
530 }
545 /* -(A + B) -> (-B) - A. */
548 /* -(A + B) -> (-A) - B. */
552 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
561 /* INT_MIN/n * n doesn't overflow while negating one operand it does
562 if n is a (negative) power of two. */
573 /* Fall through. */
586 /* In general we can't negate A in A / B, because if A is INT_MIN and
587 B is not 1 we change the sign of the result. */
591 /* In general we can't negate B in A / B, because if A is INT_MIN and
592 B is 1, we may turn this into INT_MIN / -1 which is undefined
593 and actually traps on some architectures. */
602 /* Negate -((double)float) as (double)(-float). */
604 {
608 }
612 /* Negate -f(x) as f(-x). */
618 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
620 {
624 }
629 }
631 }
633 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
634 simplification is possible.
635 If negate_expr_p would return true for T, NULL_TREE will never be
636 returned. */
638 static tree
640 {
642 tree tem;
645 {
646 /* Convert - (~A) to A + 1. */
670 {
675 }
679 {
680 tree_vector_builder elts;
684 {
689 }
692 }
715 {
716 /* -(A + B) -> (-B) - A. */
718 {
722 }
724 /* -(A + B) -> (-A) - B. */
726 {
730 }
731 }
735 /* - (A - B) -> B - A */
746 /* Fall through. */
750 {
759 }
767 /* In general we can't negate A in A / B, because if A is INT_MIN and
768 B is not 1 we change the sign of the result. */
774 /* In general we can't negate B in A / B, because if A is INT_MIN and
775 B is 1, we may turn this into INT_MIN / -1 which is undefined
776 and actually traps on some architectures. */
788 /* Convert -((double)float) into (double)(-float). */
790 {
794 }
798 /* Negate -f(x) as f(-x). */
801 {
807 }
811 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
813 {
816 {
823 }
824 }
829 }
832 }
834 /* A wrapper for fold_negate_expr_1. */
836 static tree
838 {
845 }
847 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T cannot be
848 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
849 return NULL_TREE. */
851 static tree
853 {
855 location_t loc;
868 }
869 \f
870 /* Split a tree IN into a constant, literal and variable parts that could be
871 combined with CODE to make IN. "constant" means an expression with
872 TREE_CONSTANT but that isn't an actual constant. CODE must be a
873 commutative arithmetic operation. Store the constant part into *CONP,
874 the literal in *LITP and return the variable part. If a part isn't
875 present, set it to null. If the tree does not decompose in this way,
876 return the entire tree as the variable part and the other parts as null.
878 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
879 case, we negate an operand that was subtracted. Except if it is a
880 literal for which we use *MINUS_LITP instead.
882 If NEGATE_P is true, we are negating all of IN, again except a literal
883 for which we use *MINUS_LITP instead. If a variable part is of pointer
884 type, it is negated after converting to TYPE. This prevents us from
885 generating illegal MINUS pointer expression. LOC is the location of
886 the converted variable part.
888 If IN is itself a literal or constant, return it as appropriate.
890 Note that we do not guarantee that any of the three values will be the
891 same type as IN, but they will have the same signedness and mode. */
893 static tree
897 {
905 /* Strip any conversions that don't change the machine mode or signedness. */
914 /* We can associate addition and subtraction together (even
915 though the C standard doesn't say so) for integers because
916 the value is not affected. For reals, the value might be
917 affected, so we can't. */
923 {
929 /* First see if either of the operands is a literal, then a constant. */
942 /* If we haven't dealt with either operand, this is not a case we can
943 decompose. Otherwise, VAR is either of the ones remaining, if any. */
948 else
951 /* Now do any needed negations. */
958 }
963 {
964 /* -1 - X is folded to ~X, undo that here. Do _not_ do this
965 when IN is constant. */
968 }
969 else
973 {
986 }
996 }
998 /* Re-associate trees split by the above function. T1 and T2 are
999 either expressions to associate or null. Return the new
1000 expression, if any. LOC is the location of the new expression. If
1001 we build an operation, do it in TYPE and with CODE. */
1003 static tree
1005 {
1007 {
1010 }
1014 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1015 try to fold this since we will have infinite recursion. But do
1016 deal with any NEGATE_EXPRs. */
1020 {
1022 {
1035 }
1037 {
1040 }
1044 }
1048 }
1049 \f
1050 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
1051 for use in int_const_binop, size_binop and size_diffop. */
1053 static bool
1055 {
1062 {
1071 }
1076 }
1078 /* Combine two wide ints ARG1 and ARG2 under operation CODE to produce
1079 a new constant in RES. Return FALSE if we don't know how to
1080 evaluate CODE at compile-time. */
1082 bool
1086 {
1087 wide_int tmp;
1090 {
1112 /* It's unclear from the C standard whether shifts can overflow.
1113 The following code ignores overflow; perhaps a C standard
1114 interpretation ruling is needed. */
1121 {
1125 else
1127 }
1128 else
1133 else
1212 }
1214 }
1216 /* Combine two poly int's ARG1 and ARG2 under operation CODE to
1217 produce a new constant in RES. Return FALSE if we don't know how
1218 to evaluate CODE at compile-time. */
1220 static bool
1224 {
1228 {
1246 else
1253 else
1266 }
1268 }
1270 /* Combine two integer constants ARG1 and ARG2 under operation CODE to
1271 produce a new constant. Return NULL_TREE if we don't know how to
1272 evaluate CODE at compile-time. */
1274 tree
1277 {
1278 poly_wide_int poly_res;
1284 {
1290 }
1299 }
1301 /* Return true if binary operation OP distributes over addition in operand
1302 OPNO, with the other operand being held constant. OPNO counts from 1. */
1304 static bool
1306 {
1308 {
1319 }
1320 }
1322 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1323 constant. We assume ARG1 and ARG2 have the same data type, or at least
1324 are the same kind of constant and the same machine mode. Return zero if
1325 combining the constants is not allowed in the current operating mode. */
1327 static tree
1329 {
1330 /* Sanity check for the recursive cases. */
1338 {
1344 }
1347 {
1348 machine_mode mode;
1349 REAL_VALUE_TYPE d1;
1350 REAL_VALUE_TYPE d2;
1351 REAL_VALUE_TYPE value;
1352 REAL_VALUE_TYPE result;
1356 /* The following codes are handled by real_arithmetic. */
1358 {
1369 }
1377 /* Don't perform operation if we honor signaling NaNs and
1378 either operand is a signaling NaN. */
1384 /* Don't perform operation if it would raise a division
1385 by zero exception. */
1391 /* If either operand is a NaN, just return it. Otherwise, set up
1392 for floating-point trap; we return an overflow. */
1394 {
1395 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1396 is off. */
1400 }
1402 {
1403 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1404 is off. */
1408 }
1413 /* Don't constant fold this floating point operation if
1414 both operands are not NaN but the result is NaN, and
1415 flag_trapping_math. Such operations should raise an
1416 invalid operation exception. */
1424 /* Don't constant fold this floating point operation if
1425 the result has overflowed and flag_trapping_math. */
1433 /* Don't constant fold this floating point operation if the
1434 result may dependent upon the run-time rounding mode and
1435 flag_rounding_math is set, or if GCC's software emulation
1436 is unable to accurately represent the result. */
1446 }
1449 {
1450 FIXED_VALUE_TYPE f1;
1451 FIXED_VALUE_TYPE f2;
1452 FIXED_VALUE_TYPE result;
1457 /* The following codes are handled by fixed_arithmetic. */
1459 {
1471 {
1478 }
1483 }
1490 /* Propagate overflow flags. */
1494 }
1497 {
1506 {
1517 mpc_mul);
1531 mpc_div);
1532 /* Fallthru. */
1538 {
1539 /* Keep this algorithm in sync with
1540 tree-complex.cc:expand_complex_div_straight().
1542 Expand complex division to scalars, straightforward algorithm.
1543 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1544 t = br*br + bi*bi
1545 */
1546 tree magsquared
1550 tree t1
1554 tree t2
1561 }
1562 else
1563 {
1564 /* Keep this algorithm in sync with
1565 tree-complex.cc:expand_complex_div_wide().
1567 Expand complex division to scalars, modified algorithm to minimize
1568 overflow with wide input ranges. */
1574 {
1575 /* In the TRUE branch, we compute
1576 ratio = br/bi;
1577 div = (br * ratio) + bi;
1578 tr = (ar * ratio) + ai;
1579 ti = (ai * ratio) - ar;
1580 tr = tr / div;
1581 ti = ti / div; */
1592 }
1593 else
1594 {
1595 /* In the FALSE branch, we compute
1596 ratio = d/c;
1597 divisor = (d * ratio) + c;
1598 tr = (b * ratio) + a;
1599 ti = b - (a * ratio);
1600 tr = tr / div;
1601 ti = ti / div; */
1613 }
1614 }
1619 }
1623 }
1629 {
1634 /* We can operate directly on the encoding if:
1636 a3 - a2 == a2 - a1 && b3 - b2 == b2 - b1
1637 implies
1638 (a3 op b3) - (a2 op b2) == (a2 op b2) - (a1 op b1)
1640 Addition and subtraction are the supported operators
1641 for which this is true. */
1644 /* We can operate directly on stepped encodings if:
1646 a3 - a2 == a2 - a1
1647 implies:
1648 (a3 op c) - (a2 op c) == (a2 op c) - (a1 op c)
1650 which is true if (x -> x op c) distributes over addition. */
1652 else
1653 /* Similarly in reverse. */
1655 tree_vector_builder elts;
1660 {
1666 /* It is possible that const_binop cannot handle the given
1667 code and return NULL_TREE */
1671 }
1674 }
1676 /* Shifts allow a scalar offset for a vector. */
1679 {
1682 tree_vector_builder elts;
1687 {
1692 /* It is possible that const_binop cannot handle the given
1693 code and return NULL_TREE. */
1697 }
1700 }
1702 }
1704 /* Overload that adds a TYPE parameter to be able to dispatch
1705 to fold_relational_const. */
1707 tree
1709 {
1713 /* ??? Until we make the const_binop worker take the type of the
1714 result as argument put those cases that need it here. */
1716 {
1733 {
1738 }
1744 {
1760 {
1765 ? NOP_EXPR
1772 }
1775 }
1781 {
1804 {
1817 }
1820 }
1823 }
1828 /* Make sure type and arg0 have the same saturating flag. */
1833 }
1835 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1836 Return zero if computing the constants is not possible. */
1838 tree
1840 {
1841 /* Don't perform the operation, other than NEGATE and ABS, if
1842 flag_signaling_nans is on and the operand is a signaling NaN. */
1852 {
1853 CASE_CONVERT:
1860 /* If the source address is 0, and the source address space
1861 cannot have a valid object at 0, fold to dest type null. */
1872 {
1873 /* Can't call fold_negate_const directly here as that doesn't
1874 handle all cases and we might not be able to negate some
1875 constants. */
1880 }
1890 {
1894 }
1902 /* Perform BIT_NOT_EXPR on each element individually. */
1904 {
1905 tree elem;
1907 /* This can cope with stepped encodings because ~x == -1 - x. */
1908 tree_vector_builder elements;
1912 {
1918 }
1921 }
1945 {
1968 else
1973 {
1979 }
1982 }
1991 }
1994 }
1996 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1997 indicates which particular sizetype to create. */
1999 tree
2001 {
2003 }
2004 \f
2005 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
2006 is a tree code. The type of the result is taken from the operands.
2007 Both must be equivalent integer types, ala int_binop_types_match_p.
2008 If the operands are constant, so is the result. */
2010 tree
2012 {
2021 /* Handle the special case of two poly_int constants faster. */
2023 {
2024 /* And some specific cases even faster than that. */
2026 {
2033 }
2035 {
2039 }
2041 {
2045 }
2047 /* Handle general case of two integer constants. For sizetype
2048 constant calculations we always want to know about overflow,
2049 even in the unsigned case. */
2053 }
2056 }
2058 /* Given two values, either both of sizetype or both of bitsizetype,
2059 compute the difference between the two values. Return the value
2060 in signed type corresponding to the type of the operands. */
2062 tree
2064 {
2066 tree ctype;
2071 /* If the type is already signed, just do the simple thing. */
2079 else
2082 /* If either operand is not a constant, do the conversions to the signed
2083 type and subtract. The hardware will do the right thing with any
2084 overflow in the subtraction. */
2090 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
2091 Otherwise, subtract the other way, convert to CTYPE (we know that can't
2092 overflow) and negate (which can't either). Special-case a result
2093 of zero while we're here. */
2099 else
2103 MINUS_EXPR,
2105 }
2106 \f
2107 /* A subroutine of fold_convert_const handling conversions of an
2108 INTEGER_CST to another integer type. */
2110 static tree
2112 {
2113 /* Given an integer constant, make new constant with new type,
2114 appropriately sign-extended or truncated. Use widest_int
2115 so that any extension is done according ARG1's type. */
2119 }
2121 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2122 to an integer type. */
2124 static tree
2126 {
2128 tree t;
2130 /* The following code implements the floating point to integer
2131 conversion rules required by the Java Language Specification,
2132 that IEEE NaNs are mapped to zero and values that overflow
2133 the target precision saturate, i.e. values greater than
2134 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2135 are mapped to INT_MIN. These semantics are allowed by the
2136 C and C++ standards that simply state that the behavior of
2137 FP-to-integer conversion is unspecified upon overflow. */
2139 wide_int val;
2140 REAL_VALUE_TYPE r;
2144 {
2151 }
2153 /* If R is NaN, return zero and show we have an overflow. */
2155 {
2158 }
2160 /* See if R is less than the lower bound or greater than the
2161 upper bound. */
2164 {
2168 {
2171 }
2172 }
2175 {
2178 {
2181 {
2184 }
2185 }
2186 }
2193 }
2195 /* A subroutine of fold_convert_const handling conversions of a
2196 FIXED_CST to an integer type. */
2198 static tree
2200 {
2201 tree t;
2203 scalar_mode mode;
2205 /* Right shift FIXED_CST to temp by fbit. */
2209 {
2211 HOST_BITS_PER_DOUBLE_INT,
2214 /* Left shift temp to temp_trunc by fbit. */
2216 HOST_BITS_PER_DOUBLE_INT,
2218 }
2219 else
2220 {
2223 }
2225 /* If FIXED_CST is negative, we need to round the value toward 0.
2226 By checking if the fractional bits are not zero to add 1 to temp. */
2232 /* Given a fixed-point constant, make new constant with new type,
2233 appropriately sign-extended or truncated. */
2241 }
2243 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2244 to another floating point type. */
2246 static tree
2248 {
2249 REAL_VALUE_TYPE value;
2250 tree t;
2252 /* If the underlying modes are the same, simply treat it as
2253 copy and rebuild with TREE_REAL_CST information and the
2254 given type. */
2256 {
2259 }
2261 /* Don't perform the operation if flag_signaling_nans is on
2262 and the operand is a signaling NaN. */
2267 /* With flag_rounding_math we should respect the current rounding mode
2268 unless the conversion is exact. */
2276 /* If converting an infinity or NAN to a representation that doesn't
2277 have one, set the overflow bit so that we can produce some kind of
2278 error message at the appropriate point if necessary. It's not the
2279 most user-friendly message, but it's better than nothing. */
2286 /* Regular overflow, conversion produced an infinity in a mode that
2287 can't represent them. */
2292 else
2295 }
2297 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2298 to a floating point type. */
2300 static tree
2302 {
2303 REAL_VALUE_TYPE value;
2304 tree t;
2312 }
2314 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2315 to another fixed-point type. */
2317 static tree
2319 {
2320 FIXED_VALUE_TYPE value;
2321 tree t;
2328 /* Propagate overflow flags. */
2332 }
2334 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2335 to a fixed-point type. */
2337 static tree
2339 {
2340 FIXED_VALUE_TYPE value;
2341 tree t;
2343 double_int di;
2350 else
2358 /* Propagate overflow flags. */
2362 }
2364 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2365 to a fixed-point type. */
2367 static tree
2369 {
2370 FIXED_VALUE_TYPE value;
2371 tree t;
2379 /* Propagate overflow flags. */
2383 }
2385 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2386 type TYPE. If no simplification can be done return NULL_TREE. */
2388 static tree
2390 {
2395 /* We can't widen types, since the runtime value could overflow the
2396 original type before being extended to the new type. */
2407 {
2414 }
2416 {
2418 {
2420 /* Avoid the folding if flag_rounding_math is on and the
2421 conversion is not exact. */
2423 {
2429 }
2431 }
2436 }
2438 {
2445 }
2447 {
2450 {
2453 /* We can't handle steps directly when extending, since the
2454 values need to wrap at the original precision first. */
2455 bool step_ok_p
2459 tree_vector_builder v;
2464 {
2470 }
2472 }
2473 }
2475 }
2477 /* Construct a vector of zero elements of vector type TYPE. */
2479 static tree
2481 {
2482 tree t;
2486 }
2488 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2490 bool
2492 {
2507 {
2529 }
2530 }
2532 /* Convert expression ARG to type TYPE. Used by the middle-end for
2533 simple conversions in preference to calling the front-end's convert. */
2535 tree
2537 {
2539 tree tem;
2550 {
2553 /* Handle conversions between pointers to different address spaces. */
2558 /* fall through */
2563 {
2567 }
2581 {
2585 }
2587 {
2591 }
2593 {
2597 }
2600 {
2618 }
2623 {
2627 }
2630 {
2645 }
2649 {
2658 integer_zero_node));
2660 {
2664 {
2670 }
2678 }
2682 }
2700 }
2701 fold_convert_exit:
2704 }
2705 \f
2706 /* Return false if expr can be assumed not to be an lvalue, true
2707 otherwise. */
2709 static bool
2711 {
2712 /* We only need to wrap lvalue tree codes. */
2714 {
2747 /* Assume the worst for front-end tree codes. */
2751 }
2754 }
2756 /* Return an expr equal to X but certainly not valid as an lvalue. */
2758 tree
2760 {
2761 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2762 us. */
2769 }
2770 \f
2771 /* Given a tree comparison code, return the code that is the logical inverse.
2772 It is generally not safe to do this for floating-point comparisons, except
2773 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2774 ERROR_MARK in this case. */
2776 enum tree_code
2778 {
2784 {
2815 }
2816 }
2818 /* Similar, but return the comparison that results if the operands are
2819 swapped. This is safe for floating-point. */
2821 enum tree_code
2823 {
2825 {
2851 }
2852 }
2855 /* Convert a comparison tree code from an enum tree_code representation
2856 into a compcode bit-based encoding. This function is the inverse of
2857 compcode_to_comparison. */
2859 static enum comparison_code
2861 {
2863 {
2894 }
2895 }
2897 /* Convert a compcode bit-based encoding of a comparison operator back
2898 to GCC's enum tree_code representation. This function is the
2899 inverse of comparison_to_compcode. */
2901 static enum tree_code
2903 {
2905 {
2936 }
2937 }
2939 /* Return true if COND1 tests the opposite condition of COND2. */
2941 bool
2943 {
2946 && (invert_tree_comparison
2953 }
2955 /* Return a tree for the comparison which is the combination of
2956 doing the AND or OR (depending on CODE) of the two operations LCODE
2957 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2958 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2959 if this makes the transformation invalid. */
2961 tree
2966 {
2973 {
2984 }
2987 {
2988 /* Eliminate unordered comparisons, as well as LTGT and ORD
2989 which are not used unless the mode has NaNs. */
2995 }
2997 {
2998 /* Check that the original operation and the optimized ones will trap
2999 under the same condition. */
3010 /* In a short-circuited boolean expression the LHS might be
3011 such that the RHS, if evaluated, will never trap. For
3012 example, in ORD (x, y) && (x < y), we evaluate the RHS only
3013 if neither x nor y is NaN. (This is a mixed blessing: for
3014 example, the expression above will never trap, hence
3015 optimizing it to x < y would be invalid). */
3020 /* If the comparison was short-circuited, and only the RHS
3021 trapped, we may now generate a spurious trap. */
3026 /* If we changed the conditions that cause a trap, we lose. */
3029 }
3035 else
3036 {
3041 }
3042 }
3043 \f
3044 /* Return nonzero if two operands (typically of the same tree node)
3045 are necessarily equal. FLAGS modifies behavior as follows:
3047 If OEP_ONLY_CONST is set, only return nonzero for constants.
3048 This function tests whether the operands are indistinguishable;
3049 it does not test whether they are equal using C's == operation.
3050 The distinction is important for IEEE floating point, because
3051 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
3052 (2) two NaNs may be indistinguishable, but NaN!=NaN.
3054 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
3055 even though it may hold multiple values during a function.
3056 This is because a GCC tree node guarantees that nothing else is
3057 executed between the evaluation of its "operands" (which may often
3058 be evaluated in arbitrary order). Hence if the operands themselves
3059 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
3060 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
3061 unset means assuming isochronic (or instantaneous) tree equivalence.
3062 Unless comparing arbitrary expression trees, such as from different
3063 statements, this flag can usually be left unset.
3065 If OEP_PURE_SAME is set, then pure functions with identical arguments
3066 are considered the same. It is used when the caller has other ways
3067 to ensure that global memory is unchanged in between.
3069 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
3070 not values of expressions.
3072 If OEP_LEXICOGRAPHIC is set, then also handle expressions with side-effects
3073 such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
3075 If OEP_BITWISE is set, then require the values to be bitwise identical
3076 rather than simply numerically equal. Do not take advantage of things
3077 like math-related flags or undefined behavior; only return true for
3078 values that are provably bitwise identical in all circumstances.
3080 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
3081 any operand with side effect. This is unnecesarily conservative in the
3082 case we know that arg0 and arg1 are in disjoint code paths (such as in
3083 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
3084 addresses with TREE_CONSTANT flag set so we know that &var == &var
3085 even if var is volatile. */
3087 bool
3090 {
3098 /* If either is ERROR_MARK, they aren't equal. */
3104 /* Similar, if either does not have a type (like a template id),
3105 they aren't equal. */
3109 /* Bitwise identity makes no sense if the values have different layouts. */
3114 /* We cannot consider pointers to different address space equal. */
3121 /* Check equality of integer constants before bailing out due to
3122 precision differences. */
3124 {
3125 /* Address of INTEGER_CST is not defined; check that we did not forget
3126 to drop the OEP_ADDRESS_OF flags. */
3129 }
3132 {
3133 /* If both types don't have the same signedness, then we can't consider
3134 them equal. We must check this before the STRIP_NOPS calls
3135 because they may change the signedness of the arguments. As pointers
3136 strictly don't have a signedness, require either two pointers or
3137 two non-pointers as well. */
3143 /* If both types don't have the same precision, then it is not safe
3144 to strip NOPs. */
3151 }
3152 #if 0
3153 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
3154 sanity check once the issue is solved. */
3155 else
3156 /* Addresses of conversions and SSA_NAMEs (and many other things)
3157 are not defined. Check that we did not forget to drop the
3158 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
3161 #endif
3163 /* In case both args are comparisons but with different comparison
3164 code, try to swap the comparison operands of one arg to produce
3165 a match and compare that variant. */
3169 {
3177 }
3180 {
3181 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
3183 ;
3185 {
3186 /* If we are interested in comparing addresses ignore
3187 MEM_REF wrappings of the base that can appear just for
3188 TBAA reasons. */
3202 }
3203 else
3205 }
3207 /* When not checking adddresses, this is needed for conversions and for
3208 COMPONENT_REF. Might as well play it safe and always test this. */
3215 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3216 We don't care about side effects in that case because the SAVE_EXPR
3217 takes care of that for us. In all other cases, two expressions are
3218 equal if they have no side effects. If we have two identical
3219 expressions with side effects that should be treated the same due
3220 to the only side effects being identical SAVE_EXPR's, that will
3221 be detected in the recursive calls below.
3222 If we are taking an invariant address of two identical objects
3223 they are necessarily equal as well. */
3230 /* Next handle constant cases, those for which we can return 1 even
3231 if ONLY_CONST is set. */
3234 {
3247 {
3248 /* If we do not distinguish between signed and unsigned zero,
3249 consider them equal. */
3252 }
3256 {
3271 }
3275 flags)
3277 flags));
3288 flags | OEP_ADDRESS_OF
3291 /* In GIMPLE empty constructors are allowed in initializers of
3292 aggregates. */
3296 }
3298 /* Don't handle more cases for OEP_BITWISE, since we can't guarantee that
3299 two instances of undefined behavior will give identical results. */
3303 /* Define macros to test an operand from arg0 and arg1 for equality and a
3304 variant that allows null and views null as being different from any
3305 non-null value. In the latter case, if either is null, the both
3306 must be; otherwise, do the normal comparison. */
3307 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3308 TREE_OPERAND (arg1, N), flags)
3310 #define OP_SAME_WITH_NULL(N) \
3311 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3312 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3315 {
3317 /* Two conversions are equal only if signedness and modes match. */
3319 {
3320 CASE_CONVERT:
3328 }
3338 /* For commutative ops, allow the other order. */
3346 /* If either of the pointer (or reference) expressions we are
3347 dereferencing contain a side effect, these cannot be equal,
3348 but their addresses can be. */
3355 {
3358 {
3362 /* Verify that the access types are compatible. */
3366 }
3371 /* Require the same offset. */
3377 /* Fallthru. */
3385 {
3386 /* Require equal access sizes */
3392 flags)))
3394 /* Verify that access happens in similar types. */
3397 /* Verify that accesses are TBAA compatible. */
3406 /* Verify that alignment is compatible. */
3410 }
3413 /* TARGET_MEM_REF require equal extra operands. */
3424 /* Compare the array index by value if it is constant first as we
3425 may have different types but same value here. */
3431 /* Compare low bound and element size as with OEP_ADDRESS_OF
3432 we have to account for the offset of the ref. */
3437 array_ref_low_bound
3441 array_ref_element_size
3443 flags))));
3446 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3447 may be NULL when we're called to compare MEM_EXPRs. */
3450 {
3453 /* Most of time we only need to compare FIELD_DECLs for equality.
3454 However when determining address look into actual offsets.
3455 These may match for unions and unshared record types. */
3458 {
3461 {
3465 /* Non-FIELD_DECL operands can appear in C++ templates. */
3472 flags))
3474 }
3475 else
3477 }
3478 }
3489 }
3493 {
3495 /* Be sure we pass right ADDRESS_OF flag. */
3512 /* The multiplcation operands are commutative. */
3513 /* FALLTHRU */
3521 /* Otherwise take into account this is a commutative operation. */
3534 /* BIT_INSERT_EXPR has an implict operand as the type precision
3535 of op1. Need to check to make sure they are the same. */
3541 /* FALLTHRU */
3566 /* Virtual table reference. */
3578 {
3583 }
3588 }
3592 {
3596 /* If not both CALL_EXPRs are either internal or normal function
3597 functions, then they are not equal. */
3600 {
3601 /* If the CALL_EXPRs call different internal functions, then they
3602 are not equal. */
3605 }
3606 else
3607 {
3608 /* If the CALL_EXPRs call different functions, then they are not
3609 equal. */
3611 flags))
3613 }
3615 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3616 {
3620 else
3624 }
3626 /* Now see if all the arguments are the same. */
3627 {
3638 /* If we get here and both argument lists are exhausted
3639 then the CALL_EXPRs are equal. */
3641 }
3644 }
3647 /* Consider __builtin_sqrt equal to sqrt. */
3657 {
3658 /* Consider decls with the same name equal. The caller needs
3659 to make sure they refer to the same entity (such as a function
3660 formal parameter). */
3666 }
3671 {
3675 /* In GIMPLE constructors are used only to build vectors from
3676 elements. Individual elements in the constructor must be
3677 indexed in increasing order and form an initial sequence.
3679 We make no effort to compare constructors in generic.
3680 (see sem_variable::equals in ipa-icf which can do so for
3681 constants). */
3686 /* Be sure that vectors constructed have the same representation.
3687 We only tested element precision and modes to match.
3688 Vectors may be BLKmode and thus also check that the number of
3689 parts match. */
3702 {
3707 /* In GIMPLE the indexes can be either NULL or matching i.
3708 Double check this so we won't get false
3709 positives for GENERIC. */
3717 }
3719 }
3722 {
3723 /* Compare the STATEMENT_LISTs. */
3729 {
3730 /* The lists don't have the same number of statements. */
3736 flags & (OEP_LEXICOGRAPHIC
3739 }
3740 }
3745 {
3756 }
3760 }
3762 #undef OP_SAME
3763 #undef OP_SAME_WITH_NULL
3764 }
3766 /* Generate a hash value for an expression. This can be used iteratively
3767 by passing a previous result as the HSTATE argument. */
3769 void
3772 {
3778 {
3781 }
3791 {
3792 /* Alas, constants aren't shared, so we can't rely on pointer
3793 identity. */
3803 {
3807 else
3811 }
3813 {
3817 }
3827 {
3834 }
3836 /* We can just compare by pointer. */
3840 /* The node itself doesn't matter. */
3844 /* Ignore. */
3847 /* A list of expressions, for a CALL_EXPR or as the elements of a
3848 VECTOR_CST. */
3853 {
3859 {
3860 /* In GIMPLE the indexes can be either NULL or matching i. */
3865 }
3867 }
3869 {
3870 tree_stmt_iterator i;
3875 }
3884 /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
3885 Otherwise nodes that compare equal according to operand_equal_p might
3886 get different hash codes. However, don't do this for machine specific
3887 or front end builtins, since the function code is overloaded in those
3888 cases. */
3891 {
3894 }
3895 /* FALL THROUGH */
3898 {
3902 }
3906 {
3907 /* DECL's have a unique ID */
3909 }
3911 {
3912 /* For comparisons that can be swapped, use the lower
3913 tree code. */
3920 }
3922 {
3923 /* NOP_EXPR and CONVERT_EXPR are considered equal by
3924 operand_equal_p. */
3928 /* Don't hash the type, that can lead to having nodes which
3929 compare equal according to operand_equal_p, but which
3930 have different hash codes. Make sure to include signedness
3931 in the hash computation. */
3934 }
3935 /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */
3943 /* Don't ICE on FE specific trees, or their arguments etc.
3944 during operand_equal_p hash verification. */
3947 else
3948 {
3954 {
3970 {
3977 }
3991 {
3992 /* The multiplication operands are commutative. */
3999 }
4007 /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT.
4008 Usually different TARGET_EXPRs just should use
4009 different temporaries in their slots. */
4014 /* Virtual table reference. */
4022 {
4024 /* We compute mangled names only when free_lang_data is run.
4025 In that case we can hash precisely. */
4028 hstate.add_object
4029 (IDENTIFIER_HASH_VALUE
4031 }
4035 }
4037 /* Don't hash the type, that can lead to having nodes which
4038 compare equal according to operand_equal_p, but which
4039 have different hash codes. */
4041 {
4042 /* Make sure to include signness in the hash computation. */
4045 }
4048 {
4049 /* It's a commutative expression. We want to hash it the same
4050 however it appears. We do this by first hashing both operands
4051 and then rehashing based on the order of their independent
4052 hashes. */
4057 }
4058 else
4062 }
4064 }
4065 }
4067 bool
4070 {
4071 /* When checking and unless comparing DECL names, verify that if
4072 the outermost operand_equal_p call returns non-zero then ARG0
4073 and ARG1 have the same hash value. */
4075 {
4077 {
4079 {
4086 }
4088 }
4089 else
4093 }
4096 }
4101 /* Conveinece wrapper around operand_compare class because usually we do
4102 not need to play with the valueizer. */
4104 bool
4106 {
4108 }
4110 namespace inchash
4111 {
4113 /* Generate a hash value for an expression. This can be used iteratively
4114 by passing a previous result as the HSTATE argument.
4116 This function is intended to produce the same hash for expressions which
4117 would compare equal using operand_equal_p. */
4118 void
4120 {
4122 }
4124 }
4125 \f
4126 /* Similar to operand_equal_p, but see if ARG0 might be a variant of ARG1
4127 with a different signedness or a narrower precision. */
4129 static bool
4131 {
4139 /* Discard any conversions that don't change the modes of ARG0 and ARG1
4140 and see if the inner values are the same. This removes any
4141 signedness comparison, which doesn't matter here. */
4149 /* Discard a single widening conversion from ARG1 and see if the inner
4150 value is the same as ARG0. */
4159 }
4160 \f
4161 /* See if ARG is an expression that is either a comparison or is performing
4162 arithmetic on comparisons. The comparisons must only be comparing
4163 two different values, which will be stored in *CVAL1 and *CVAL2; if
4164 they are nonzero it means that some operands have already been found.
4165 No variables may be used anywhere else in the expression except in the
4166 comparisons.
4168 If this is true, return 1. Otherwise, return zero. */
4170 static bool
4172 {
4176 /* We can handle some of the tcc_expression cases here. */
4185 {
4204 /* First see if we can handle the first operand, then the second. For
4205 the second operand, we know *CVAL1 can't be zero. It must be that
4206 one side of the comparison is each of the values; test for the
4207 case where this isn't true by failing if the two operands
4208 are the same. */
4217 ;
4221 ;
4222 else
4226 ;
4230 ;
4231 else
4238 }
4239 }
4240 \f
4241 /* ARG is a tree that is known to contain just arithmetic operations and
4242 comparisons. Evaluate the operations in the tree substituting NEW0 for
4243 any occurrence of OLD0 as an operand of a comparison and likewise for
4244 NEW1 and OLD1. */
4246 static tree
4249 {
4254 /* We can handle some of the tcc_expression cases here. */
4262 {
4277 {
4296 }
4297 /* Fall through - ??? */
4300 {
4304 /* We need to check both for exact equality and tree equality. The
4305 former will be true if the operand has a side-effect. In that
4306 case, we know the operand occurred exactly once. */
4319 }
4323 }
4324 }
4325 \f
4326 /* Return a tree for the case when the result of an expression is RESULT
4327 converted to TYPE and OMITTED was previously an operand of the expression
4328 but is now not needed (e.g., we folded OMITTED * 0).
4330 If OMITTED has side effects, we must evaluate it. Otherwise, just do
4331 the conversion of RESULT to TYPE. */
4333 tree
4335 {
4338 /* If the resulting operand is an empty statement, just return the omitted
4339 statement casted to void. */
4349 }
4351 /* Return a tree for the case when the result of an expression is RESULT
4352 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
4353 of the expression but are now not needed.
4355 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
4356 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
4357 evaluated before OMITTED2. Otherwise, if neither has side effects,
4358 just do the conversion of RESULT to TYPE. */
4360 tree
4363 {
4372 }
4374 \f
4375 /* Return a simplified tree node for the truth-negation of ARG. This
4376 never alters ARG itself. We assume that ARG is an operation that
4377 returns a truth value (0 or 1).
4379 FIXME: one would think we would fold the result, but it causes
4380 problems with the dominator optimizer. */
4382 static tree
4384 {
4389 /* If this is a comparison, we can simply invert it, except for
4390 floating-point non-equality comparisons, in which case we just
4391 enclose a TRUTH_NOT_EXPR around what we have. */
4394 {
4397 && flag_trapping_math
4410 }
4413 {
4432 /* Here we can invert either operand. We invert the first operand
4433 unless the second operand is a TRUTH_NOT_EXPR in which case our
4434 result is the XOR of the first operand with the inside of the
4435 negation of the second operand. */
4440 else
4463 {
4470 /* A COND_EXPR may have a throw as one operand, which
4471 then has void type. Just leave void operands
4472 as they are. */
4478 }
4490 CASE_CONVERT:
4494 /* fall through */
4516 }
4517 }
4519 /* Fold the truth-negation of ARG. This never alters ARG itself. We
4520 assume that ARG is an operation that returns a truth value (0 or 1
4521 for scalars, 0 or -1 for vectors). Return the folded expression if
4522 folding is successful. Otherwise, return NULL_TREE. */
4524 static tree
4526 {
4529 ? BIT_NOT_EXPR
4532 }
4534 /* Return a simplified tree node for the truth-negation of ARG. This
4535 never alters ARG itself. We assume that ARG is an operation that
4536 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
4538 tree
4540 {
4546 ? BIT_NOT_EXPR
4549 }
4550 \f
4551 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
4552 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
4553 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
4554 is the original memory reference used to preserve the alias set of
4555 the access. */
4557 static tree
4561 {
4564 /* Attempt not to lose the access path if possible. */
4566 {
4568 machine_mode nmode;
4570 tree noffset;
4578 && !reversep
4579 && !nreversep
4581 {
4584 }
4585 }
4594 {
4601 }
4616 }
4618 /* Optimize a bit-field compare.
4620 There are two cases: First is a compare against a constant and the
4621 second is a comparison of two items where the fields are at the same
4622 bit position relative to the start of a chunk (byte, halfword, word)
4623 large enough to contain it. In these cases we can avoid the shift
4624 implicit in bitfield extractions.
4626 For constants, we emit a compare of the shifted constant with the
4627 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
4628 compared. For two fields at the same position, we do the ANDs with the
4629 similar mask and compare the result of the ANDs.
4631 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
4632 COMPARE_TYPE is the type of the comparison, and LHS and RHS
4633 are the left and right operands of the comparison, respectively.
4635 If the optimization described above can be done, we return the resulting
4636 tree. Otherwise we return zero. */
4638 static tree
4641 {
4645 tree unsigned_type;
4648 scalar_int_mode nmode;
4653 tree mask;
4654 tree offset;
4656 /* Get all the information about the extractions being done. If the bit size
4657 is the same as the size of the underlying object, we aren't doing an
4658 extraction at all and so can do nothing. We also don't want to
4659 do anything if the inner expression is a PLACEHOLDER_EXPR since we
4660 then will no longer be able to replace it. */
4675 else
4676 {
4677 /* If this is not a constant, we can only do something if bit positions,
4678 sizes, signedness and storage order are the same. */
4679 rinner
4692 }
4694 /* Honor the C++ memory model and mimic what RTL expansion does. */
4698 {
4702 }
4704 /* See if we can find a mode to refer to this field. We should be able to,
4705 but fail if we can't. */
4713 /* Set signed and unsigned types of the precision of this mode for the
4714 shifts below. */
4717 /* Compute the bit position and size for the new reference and our offset
4718 within it. If the new reference is the same size as the original, we
4719 won't optimize anything, so return zero. */
4729 /* Make the mask to be used against the extracted field. */
4736 {
4740 /* If not comparing with constant, just rework the comparison
4741 and return. */
4749 }
4751 /* Otherwise, we are handling the constant case. See if the constant is too
4752 big for the field. Warn and return a tree for 0 (false) if so. We do
4753 this not only for its own sake, but to avoid having to test for this
4754 error case below. If we didn't, we might generate wrong code.
4756 For unsigned fields, the constant shifted right by the field length should
4757 be all zero. For signed fields, the high-order bits should agree with
4758 the sign bit. */
4761 {
4763 {
4767 }
4768 }
4769 else
4770 {
4773 {
4777 }
4778 }
4783 /* Single-bit compares should always be against zero. */
4785 {
4788 }
4790 /* Make a new bitfield reference, shift the constant over the
4791 appropriate number of bits and mask it with the computed mask
4792 (in case this was a signed field). If we changed it, make a new one. */
4800 mask);
4805 }
4806 \f
4807 /* Subroutine for fold_truth_andor_1: decode a field reference.
4809 If EXP is a comparison reference, we return the innermost reference.
4811 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4812 set to the starting bit number.
4814 If the innermost field can be completely contained in a mode-sized
4815 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4817 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4818 otherwise it is not changed.
4820 *PUNSIGNEDP is set to the signedness of the field.
4822 *PREVERSEP is set to the storage order of the field.
4824 *PMASK is set to the mask used. This is either contained in a
4825 BIT_AND_EXPR or derived from the width of the field.
4827 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4829 Return 0 if this is not a component reference or is one that we can't
4830 do anything with. */
4832 static tree
4837 {
4842 tree unsigned_type;
4845 /* All the optimizations using this function assume integer fields.
4846 There are problems with FP fields since the type_for_size call
4847 below can fail for, e.g., XFmode. */
4851 /* We are interested in the bare arrangement of bits, so strip everything
4852 that doesn't affect the machine mode. However, record the type of the
4853 outermost expression if it may matter below. */
4860 {
4866 }
4877 /* Reject out-of-bound accesses (PR79731). */
4889 /* If the number of bits in the reference is the same as the bitsize of
4890 the outer type, then the outer type gives the signedness. Otherwise
4891 (in case of a small bitfield) the signedness is unchanged. */
4895 /* Compute the mask to access the bitfield. */
4903 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4911 }
4913 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4914 bit positions and MASK is SIGNED. */
4916 static bool
4918 {
4922 /* If this function returns true when the type of the mask is
4923 UNSIGNED, then there will be errors. In particular see
4924 gcc.c-torture/execute/990326-1.c. There does not appear to be
4925 any documentation paper trail as to why this is so. But the pre
4926 wide-int worked with that restriction and it has been preserved
4927 here. */
4932 }
4934 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4935 represents the sign bit of EXP's type. If EXP represents a sign
4936 or zero extension, also test VAL against the unextended type.
4937 The return value is the (sub)expression whose sign bit is VAL,
4938 or NULL_TREE otherwise. */
4940 tree
4942 {
4944 tree t;
4946 /* Tree EXP must have an integral type. */
4951 /* Tree VAL must be an integer constant. */
4960 /* Handle extension from a narrower type. */
4966 }
4968 /* Subroutine for fold_truth_andor_1 and simple_condition_p: determine if an
4969 operand is simple enough to be evaluated unconditionally. */
4971 static bool
4973 {
4974 /* Strip any conversions that don't change the machine mode. */
4983 /* Don't regard global variables as simple. They may be
4984 allocated in ways unknown to the compiler (shared memory,
4985 #pragma weak, etc). */
4988 /* Weakrefs are not safe to be read, since they can be NULL.
4989 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4990 have DECL_WEAK flag set. */
4992 /* Loading a static variable is unduly expensive, but global
4993 registers aren't expensive. */
4995 }
4997 /* Determine if an operand is simple enough to be evaluated unconditionally.
4998 In addition to simple_operand_p, we assume that comparisons, conversions,
4999 and logic-not operations are simple, if their operands are simple, too. */
5001 bool
5003 {
5022 }
5024 \f
5025 /* The following functions are subroutines to fold_range_test and allow it to
5026 try to change a logical combination of comparisons into a range test.
5028 For example, both
5029 X == 2 || X == 3 || X == 4 || X == 5
5030 and
5031 X >= 2 && X <= 5
5032 are converted to
5033 (unsigned) (X - 2) <= 3
5035 We describe each set of comparisons as being either inside or outside
5036 a range, using a variable named like IN_P, and then describe the
5037 range with a lower and upper bound. If one of the bounds is omitted,
5038 it represents either the highest or lowest value of the type.
5040 In the comments below, we represent a range by two numbers in brackets
5041 preceded by a "+" to designate being inside that range, or a "-" to
5042 designate being outside that range, so the condition can be inverted by
5043 flipping the prefix. An omitted bound is represented by a "-". For
5044 example, "- [-, 10]" means being outside the range starting at the lowest
5045 possible value and ending at 10, in other words, being greater than 10.
5046 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
5047 always false.
5049 We set up things so that the missing bounds are handled in a consistent
5050 manner so neither a missing bound nor "true" and "false" need to be
5051 handled using a special case. */
5053 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
5054 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
5055 and UPPER1_P are nonzero if the respective argument is an upper bound
5056 and zero for a lower. TYPE, if nonzero, is the type of the result; it
5057 must be specified for a comparison. ARG1 will be converted to ARG0's
5058 type if both are specified. */
5060 static tree
5063 {
5064 tree tem;
5068 /* If neither arg represents infinity, do the normal operation.
5069 Else, if not a comparison, return infinity. Else handle the special
5070 comparison rules. Note that most of the cases below won't occur, but
5071 are handled for consistency. */
5074 {
5079 }
5084 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
5085 for neither. In real maths, we cannot assume open ended ranges are
5086 the same. But, this is computer arithmetic, where numbers are finite.
5087 We can therefore make the transformation of any unbounded range with
5088 the value Z, Z being greater than any representable number. This permits
5089 us to treat unbounded ranges as equal. */
5093 {
5114 }
5117 }
5118 \f
5119 /* Helper routine for make_range. Perform one step for it, return
5120 new expression if the loop should continue or NULL_TREE if it should
5121 stop. */
5123 tree
5127 {
5133 {
5135 /* We can only do something if the range is testing for zero. */
5144 /* We can only do something if the range is testing for zero
5145 and if the second operand is an integer constant. Note that
5146 saying something is "in" the range we make is done by
5147 complementing IN_P since it will set in the initial case of
5148 being not equal to zero; "out" is leaving it alone. */
5155 {
5176 }
5178 /* If this is an unsigned comparison, we also know that EXP is
5179 greater than or equal to zero. We base the range tests we make
5180 on that fact, so we record it here so we can parse existing
5181 range tests. We test arg0_type since often the return type
5182 of, e.g. EQ_EXPR, is boolean. */
5184 {
5188 NULL_TREE))
5193 /* If the high bound is missing, but we have a nonzero low
5194 bound, reverse the range so it goes from zero to the low bound
5195 minus 1. */
5197 {
5202 }
5203 }
5211 /* If flag_wrapv and ARG0_TYPE is signed, make sure
5212 low and high are non-NULL, then normalize will DTRT. */
5215 {
5220 }
5222 /* (-x) IN [a,b] -> x in [-b, -a] */
5234 /* ~ X -> -X - 1 */
5243 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
5244 move a constant to the other side. */
5249 /* If EXP is signed, any overflow in the computation is undefined,
5250 so we don't worry about it so long as our computations on
5251 the bounds don't overflow. For unsigned, overflow is defined
5252 and this is exactly the right thing. */
5264 normalize:
5265 /* Check for an unsigned range which has wrapped around the maximum
5266 value thus making n_high < n_low, and normalize it. */
5268 {
5274 /* If the range is of the form +/- [ x+1, x ], we won't
5275 be able to normalize it. But then, it represents the
5276 whole range or the empty set, so make it
5277 +/- [ -, - ]. */
5281 else
5283 }
5284 else
5292 CASE_CONVERT:
5310 /* If we're converting arg0 from an unsigned type, to exp,
5311 a signed type, we will be doing the comparison as unsigned.
5312 The tests above have already verified that LOW and HIGH
5313 are both positive.
5315 So we have to ensure that we will handle large unsigned
5316 values the same way that the current signed bounds treat
5317 negative values. */
5320 {
5321 tree high_positive;
5322 tree equiv_type;
5323 /* For fixed-point modes, we need to pass the saturating flag
5324 as the 2nd parameter. */
5326 equiv_type
5331 else
5332 equiv_type
5335 /* A range without an upper bound is, naturally, unbounded.
5336 Since convert would have cropped a very large value, use
5337 the max value for the destination type. */
5338 high_positive
5345 high_positive),
5348 /* If the low bound is specified, "and" the range with the
5349 range for which the original unsigned value will be
5350 positive. */
5352 {
5355 integer_zero_node),
5356 high_positive))
5360 }
5361 else
5362 {
5363 /* Otherwise, "or" the range with the range of the input
5364 that will be interpreted as negative. */
5367 integer_zero_node),
5368 high_positive))
5372 }
5373 }
5375 /* Otherwise, if we are converting arg0 from signed type, to exp,
5376 an unsigned type, we will do the comparison as signed. If
5377 high is non-NULL, we punt above if it doesn't fit in the signed
5378 type, so if we get through here, +[-, high] or +[low, high] are
5379 equivalent to +[-, n_high] or +[n_low, n_high]. Similarly,
5380 +[-, -] or -[-, -] are equivalent too. But if low is specified and
5381 high is not, the +[low, -] range is equivalent to union of
5382 +[n_low, -] and +[-, -1] ranges, so +[low, -] is equivalent to
5383 -[0, n_low-1] and similarly -[low, -] to +[0, n_low-1], except for
5384 low being 0, which should be treated as [-, -]. */
5387 && low
5389 {
5392 else
5393 {
5398 }
5399 }
5408 }
5409 }
5411 /* Given EXP, a logical expression, set the range it is testing into
5412 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
5413 actually being tested. *PLOW and *PHIGH will be made of the same
5414 type as the returned expression. If EXP is not a comparison, we
5415 will most likely not be returning a useful value and range. Set
5416 *STRICT_OVERFLOW_P to true if the return value is only valid
5417 because signed overflow is undefined; otherwise, do not change
5418 *STRICT_OVERFLOW_P. */
5420 tree
5423 {
5431 /* Start with simply saying "EXP != 0" and then look at the code of EXP
5432 and see if we can refine the range. Some of the cases below may not
5433 happen, but it doesn't seem worth worrying about this. We "continue"
5434 the outer loop when we've changed something; otherwise we "break"
5435 the switch, which will "break" the while. */
5441 {
5447 {
5455 }
5464 }
5466 /* If EXP is a constant, we can evaluate whether this is true or false. */
5468 {
5475 }
5479 }
5481 /* Returns TRUE if [LOW, HIGH] range check can be optimized to
5482 a bitwise check i.e. when
5483 LOW == 0xXX...X00...0
5484 HIGH == 0xXX...X11...1
5485 Return corresponding mask in MASK and stem in VALUE. */
5487 static bool
5490 {
5513 }
5514 \f
5515 /* Helper routine for build_range_check and match.pd. Return the type to
5516 perform the check or NULL if it shouldn't be optimized. */
5518 tree
5520 {
5521 /* First make sure that arithmetics in this type is valid, then make sure
5522 that it wraps around. */
5527 {
5530 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
5531 for the type in question, as we rely on this here. */
5541 else
5543 }
5547 }
5549 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
5550 type, TYPE, return an expression to test if EXP is in (or out of, depending
5551 on IN_P) the range. Return 0 if the test couldn't be created. */
5553 tree
5556 {
5559 /* Disable this optimization for function pointer expressions
5560 on targets that require function pointer canonicalization. */
5567 {
5573 }
5595 value);
5598 {
5600 {
5604 }
5606 }
5608 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
5610 {
5614 {
5616 {
5619 etype
5621 else
5624 }
5627 }
5628 }
5630 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
5631 This requires wrap-around arithmetics for the type of the expression. */
5648 }
5649 \f
5650 /* Return the predecessor of VAL in its type, handling the infinite case. */
5652 static tree
5654 {
5660 else
5663 }
5665 /* Return the successor of VAL in its type, handling the infinite case. */
5667 static tree
5669 {
5675 else
5678 }
5680 /* Given two ranges, see if we can merge them into one. Return 1 if we
5681 can, 0 if we can't. Set the output range into the specified parameters. */
5683 bool
5686 {
5690 tree tem;
5700 /* Make range 0 be the range that starts first, or ends last if they
5701 start at the same value. Swap them if it isn't. */
5704 || (lowequal
5707 {
5711 }
5713 /* If the second range is != high1 where high1 is the type maximum of
5714 the type, try first merging with < high1 range. */
5716 && high1
5723 {
5728 /* Similarly for the second range != low1 where low1 is the type minimum
5729 of the type, try first merging with > low1 range. */
5734 }
5736 /* Now flag two cases, whether the ranges are disjoint or whether the
5737 second range is totally subsumed in the first. Note that the tests
5738 below are simplified by the ones above. */
5744 /* We now have four cases, depending on whether we are including or
5745 excluding the two ranges. */
5747 {
5748 /* If they don't overlap, the result is false. If the second range
5749 is a subset it is the result. Otherwise, the range is from the start
5750 of the second to the end of the first. */
5755 else
5757 }
5760 {
5761 /* If they don't overlap, the result is the first range. If they are
5762 equal, the result is false. If the second range is a subset of the
5763 first, and the ranges begin at the same place, we go from just after
5764 the end of the second range to the end of the first. If the second
5765 range is not a subset of the first, or if it is a subset and both
5766 ranges end at the same place, the range starts at the start of the
5767 first range and ends just before the second range.
5768 Otherwise, we can't describe this as a single range. */
5774 {
5779 {
5780 /* We are in the weird situation where high0 > high1 but
5781 high1 has no successor. Punt. */
5783 }
5784 }
5786 {
5791 {
5792 /* low0 < low1 but low1 has no predecessor. Punt. */
5794 }
5795 }
5796 else
5798 }
5801 {
5802 /* If they don't overlap, the result is the second range. If the second
5803 is a subset of the first, the result is false. Otherwise,
5804 the range starts just after the first range and ends at the
5805 end of the second. */
5810 else
5811 {
5816 {
5817 /* high1 > high0 but high0 has no successor. Punt. */
5819 }
5820 }
5821 }
5823 else
5824 {
5825 /* The case where we are excluding both ranges. Here the complex case
5826 is if they don't overlap. In that case, the only time we have a
5827 range is if they are adjacent. If the second is a subset of the
5828 first, the result is the first. Otherwise, the range to exclude
5829 starts at the beginning of the first range and ends at the end of the
5830 second. */
5832 {
5837 else
5838 {
5839 /* Canonicalize - [min, x] into - [-, x]. */
5842 {
5845 GET_MODE_BITSIZE
5848 /* FALLTHROUGH */
5861 }
5863 /* Canonicalize - [x, max] into - [x, -]. */
5866 {
5869 GET_MODE_BITSIZE
5872 /* FALLTHROUGH */
5888 }
5890 /* The ranges might be also adjacent between the maximum and
5891 minimum values of the given type. For
5892 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5893 return + [x + 1, y - 1]. */
5895 {
5902 }
5903 else
5905 }
5906 }
5909 else
5911 }
5915 }
5916 \f
5918 /* Subroutine of fold, looking inside expressions of the form
5919 A op B ? A : C, where (ARG00, COMP_CODE, ARG01), ARG1 and ARG2
5920 are the three operands of the COND_EXPR. This function is
5921 being used also to optimize A op B ? C : A, by reversing the
5922 comparison first.
5924 Return a folded expression whose code is not a COND_EXPR
5925 anymore, or NULL_TREE if no folding opportunity is found. */
5927 static tree
5931 {
5933 tree tem;
5938 /* If we have A op 0 ? A : -A, consider applying the following
5939 transformations:
5941 A == 0? A : -A same as -A
5942 A != 0? A : -A same as A
5943 A >= 0? A : -A same as abs (A)
5944 A > 0? A : -A same as abs (A)
5945 A <= 0? A : -A same as -abs (A)
5946 A < 0? A : -A same as -abs (A)
5948 None of these transformations work for modes with signed
5949 zeros. If A is +/-0, the first two transformations will
5950 change the sign of the result (from +0 to -0, or vice
5951 versa). The last four will fix the sign of the result,
5952 even though the original expressions could be positive or
5953 negative, depending on the sign of A.
5955 Note that all these transformations are correct if A is
5956 NaN, since the two alternatives (A and -A) are also NaNs. */
5963 /* In the case that A is of the form X-Y, '-A' (arg2) may
5964 have already been folded to Y-X, check for that. */
5972 {
5984 /* Fall through. */
5995 /* FALLTHRU */
6002 {
6003 /* A <= 0 ? A : -A for A INT_MIN is valid, but -abs(INT_MIN)
6004 is not, invokes UB both in abs and in the negation of it.
6005 So, use ABSU_EXPR instead. */
6010 }
6011 else
6012 {
6015 }
6019 }
6021 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
6022 A == 0 ? A : 0 is always 0 unless A is -0. Note that
6023 both transformations are correct when A is NaN: A != 0
6024 is then true, and A == 0 is false. */
6028 {
6033 }
6035 /* Try some transformations of A op B ? A : B.
6037 A == B? A : B same as B
6038 A != B? A : B same as A
6039 A >= B? A : B same as max (A, B)
6040 A > B? A : B same as max (B, A)
6041 A <= B? A : B same as min (A, B)
6042 A < B? A : B same as min (B, A)
6044 As above, these transformations don't work in the presence
6045 of signed zeros. For example, if A and B are zeros of
6046 opposite sign, the first two transformations will change
6047 the sign of the result. In the last four, the original
6048 expressions give different results for (A=+0, B=-0) and
6049 (A=-0, B=+0), but the transformed expressions do not.
6051 The first two transformations are correct if either A or B
6052 is a NaN. In the first transformation, the condition will
6053 be false, and B will indeed be chosen. In the case of the
6054 second transformation, the condition A != B will be true,
6055 and A will be chosen.
6057 The conversions to max() and min() are not correct if B is
6058 a number and A is not. The conditions in the original
6059 expressions will be false, so all four give B. The min()
6060 and max() versions would give a NaN instead. */
6063 /* Avoid these transformations if the COND_EXPR may be used
6064 as an lvalue in the C++ front-end. PR c++/19199. */
6065 && (in_gimple_form
6071 {
6077 {
6086 /* In C++ a ?: expression can be an lvalue, so put the
6087 operand which will be used if they are equal first
6088 so that we can convert this back to the
6089 corresponding COND_EXPR. */
6091 {
6099 }
6106 {
6114 }
6127 }
6128 }
6131 }
6134 \f
6135 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
6136 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
6137 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
6138 false) >= 2)
6139 #endif
6141 /* EXP is some logical combination of boolean tests. See if we can
6142 merge it into some range test. Return the new tree if so. */
6144 static tree
6147 {
6161 /* If op0 is known true or false and this is a short-circuiting
6162 operation we must not merge with op1 since that makes side-effects
6163 unconditional. So special-case this. */
6170 /* If this is an OR operation, invert both sides; we will invert
6171 again at the end. */
6175 /* If both expressions are the same, if we can merge the ranges, and we
6176 can build the range test, return it or it inverted. If one of the
6177 ranges is always true or always false, consider it to be the same
6178 expression as the other. */
6186 {
6190 }
6192 /* On machines where the branch cost is expensive, if this is a
6193 short-circuited branch and the underlying object on both sides
6194 is the same, make a non-short-circuit operation. */
6197 logical_op_non_short_circuit
6204 {
6205 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
6206 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
6207 which cases we can't do this. */
6215 {
6224 {
6227 WARN_STRICT_OVERFLOW_COMPARISON);
6231 }
6232 }
6233 }
6236 }
6237 \f
6238 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
6239 bit value. Arrange things so the extra bits will be set to zero if and
6240 only if C is signed-extended to its full width. If MASK is nonzero,
6241 it is an INTEGER_CST that should be AND'ed with the extra bits. */
6243 static tree
6245 {
6248 tree temp;
6253 /* We work by getting just the sign bit into the low-order bit, then
6254 into the high-order bit, then sign-extend. We then XOR that value
6255 with C. */
6259 /* We must use a signed type in order to get an arithmetic right shift.
6260 However, we must also avoid introducing accidental overflows, so that
6261 a subsequent call to integer_zerop will work. Hence we must
6262 do the type conversion here. At this point, the constant is either
6263 zero or one, and the conversion to a signed type can never overflow.
6264 We could get an overflow if this conversion is done anywhere else. */
6273 /* If necessary, convert the type back to match the type of C. */
6278 }
6279 \f
6280 /* For an expression that has the form
6281 (A && B) || ~B
6282 or
6283 (A || B) && ~B,
6284 we can drop one of the inner expressions and simplify to
6285 A || ~B
6286 or
6287 A && ~B
6288 LOC is the location of the resulting expression. OP is the inner
6289 logical operation; the left-hand side in the examples above, while CMPOP
6290 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
6291 removing a condition that guards another, as in
6292 (A != NULL && A->...) || A == NULL
6293 which we must not transform. If RHS_ONLY is true, only eliminate the
6294 right-most operand of the inner logical operation. */
6296 static tree
6299 {
6317 {
6320 {
6323 }
6324 }
6326 {
6329 {
6332 }
6333 }
6348 }
6350 /* Find ways of folding logical expressions of LHS and RHS:
6351 Try to merge two comparisons to the same innermost item.
6352 Look for range tests like "ch >= '0' && ch <= '9'".
6353 Look for combinations of simple terms on machines with expensive branches
6354 and evaluate the RHS unconditionally.
6356 For example, if we have p->a == 2 && p->b == 4 and we can make an
6357 object large enough to span both A and B, we can do this with a comparison
6358 against the object ANDed with the a mask.
6360 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
6361 operations to do this with one comparison.
6363 We check for both normal comparisons and the BIT_AND_EXPRs made this by
6364 function and the one above.
6366 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
6367 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
6369 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
6370 two operands.
6372 We return the simplified tree or 0 if no optimization is possible. */
6374 static tree
6377 {
6378 /* If this is the "or" of two comparisons, we can do something if
6379 the comparisons are NE_EXPR. If this is the "and", we can do something
6380 if the comparisons are EQ_EXPR. I.e.,
6381 (a->b == 2 && a->c == 4) can become (a->new == NEW).
6383 WANTED_CODE is this operation code. For single bit fields, we can
6384 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
6385 comparison for one-bit fields. */
6406 /* Start by getting the comparison codes. Fail if anything is volatile.
6407 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
6408 it were surrounded with a NE_EXPR. */
6417 {
6421 }
6424 {
6428 }
6439 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
6442 {
6445 {
6450 }
6453 {
6459 }
6460 }
6465 /* If the RHS can be evaluated unconditionally and its operands are
6466 simple, it wins to evaluate the RHS unconditionally on machines
6467 with expensive branches. In this case, this isn't a comparison
6468 that can be merged. */
6475 {
6476 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
6487 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
6497 }
6499 /* See if the comparisons can be merged. Then get all the parameters for
6500 each side. */
6525 /* It must be true that the inner operation on the lhs of each
6526 comparison must be the same if we are to be able to do anything.
6527 Then see if we have constants. If not, the same must be true for
6528 the rhs's. */
6537 {
6540 }
6545 else
6548 /* If either comparison code is not correct for our logical operation,
6549 fail. However, we can convert a one-bit comparison against zero into
6550 the opposite comparison against that bit being set in the field. */
6554 {
6556 {
6557 /* Make the left operand unsigned, since we are only interested
6558 in the value of one bit. Otherwise we are doing the wrong
6559 thing below. */
6562 }
6563 else
6565 }
6567 /* This is analogous to the code for l_const above. */
6569 {
6571 {
6574 }
6575 else
6577 }
6579 /* See if we can find a mode that contains both fields being compared on
6580 the left. If we can't, fail. Otherwise, update all constants and masks
6581 to be relative to a field of that size. */
6595 {
6598 }
6608 {
6617 {
6621 }
6622 }
6624 {
6633 {
6637 }
6638 }
6640 /* If the right sides are not constant, do the same for it. Also,
6641 disallow this optimization if a size, signedness or storage order
6642 mismatch occurs between the left and right sides. */
6644 {
6648 /* Make sure the two fields on the right
6649 correspond to the left without being swapped. */
6666 {
6669 }
6680 /* Make a mask that corresponds to both fields being compared.
6681 Do this for both items being compared. If the operands are the
6682 same size and the bits being compared are in the same position
6683 then we can do this by masking both and comparing the masked
6684 results. */
6691 {
6705 }
6707 /* There is still another way we can do something: If both pairs of
6708 fields being compared are adjacent, we may be able to make a wider
6709 field containing them both.
6711 Note that we still must mask the lhs/rhs expressions. Furthermore,
6712 the mask must be shifted to account for the shift done by
6713 make_bit_field_ref. */
6722 {
6723 tree type;
6741 /* Convert to the smaller type before masking out unwanted bits. */
6744 {
6746 {
6750 }
6752 {
6756 }
6757 }
6766 }
6769 }
6771 /* Handle the case of comparisons with constants. If there is something in
6772 common between the masks, those bits of the constants must be the same.
6773 If not, the condition is always false. Test for this to avoid generating
6774 incorrect code below. */
6779 {
6781 {
6784 }
6785 else
6786 {
6789 }
6790 }
6795 /* Construct the expression we will return. First get the component
6796 reference we will make. Unless the mask is all ones the width of
6797 that field, perform the mask operation. Then compare with the
6798 merged constant. */
6809 }
6810 \f
6811 /* T is an integer expression that is being multiplied, divided, or taken a
6812 modulus (CODE says which and what kind of divide or modulus) by a
6813 constant C. See if we can eliminate that operation by folding it with
6814 other operations already in T. WIDE_TYPE, if non-null, is a type that
6815 should be used for the computation if wider than our type.
6817 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6818 (X * 2) + (Y * 4). We must, however, be assured that either the original
6819 expression would not overflow or that overflow is undefined for the type
6820 in the language in question.
6822 If we return a non-null expression, it is an equivalent form of the
6823 original computation, but need not be in the original type.
6825 We set *STRICT_OVERFLOW_P to true if the return values depends on
6826 signed overflow being undefined. Otherwise we do not change
6827 *STRICT_OVERFLOW_P. */
6829 static tree
6832 {
6833 /* To avoid exponential search depth, refuse to allow recursion past
6834 three levels. Beyond that (1) it's highly unlikely that we'll find
6835 something interesting and (2) we've probably processed it before
6836 when we built the inner expression. */
6839 tree ret;
6844 depth++;
6846 depth--;
6849 }
6851 static tree
6854 {
6859 {
6862 {
6865 }
6869 }
6875 /* Don't deal with constants of zero here; they confuse the code below. */
6885 /* Note that we need not handle conditional operations here since fold
6886 already handles those cases. So just do arithmetic here. */
6888 {
6890 /* For a constant, we can always simplify if we are a multiply
6891 or (for divide and modulus) if it is a multiple of our constant. */
6895 {
6898 /* If the multiplication overflowed, we lost information on it.
6899 See PR68142 and PR69845. */
6903 }
6909 /* If op0 is an expression ... */
6915 /* ... and has wrapping overflow, and its type is smaller
6916 than ctype, then we cannot pass through as widening. */
6920 /* ... or this is a truncation (t is narrower than op0),
6921 then we cannot pass through this narrowing. */
6924 /* ... or signedness changes for division or modulus,
6925 then we cannot pass through this conversion. */
6929 /* ... or has undefined overflow while the converted to
6930 type has not, we cannot do the operation in the inner type
6931 as that would introduce undefined overflow. */
6936 /* Pass the constant down and see if we can make a simplification. If
6937 we can, replace this expression with the inner simplification for
6938 possible later conversion to our or some other type. */
6949 /* If widening the type changes it from signed to unsigned, then we
6950 must avoid building ABS_EXPR itself as unsigned. */
6952 {
6956 {
6959 }
6961 }
6962 /* If the constant is negative, we cannot simplify this. */
6965 /* FALLTHROUGH */
6967 /* For division and modulus, type can't be unsigned, as e.g.
6968 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6969 For signed types, even with wrapping overflow, this is fine. */
6978 /* If widening the type changes the signedness, then we can't perform
6979 this optimization as that changes the result. */
6983 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6989 {
6996 }
7000 /* If the second operand is constant, this is a multiplication
7001 or floor division, by a power of two, so we can treat it that
7002 way unless the multiplier or divisor overflows. Signed
7003 left-shift overflow is implementation-defined rather than
7004 undefined in C90, so do not convert signed left shift into
7005 multiplication. */
7008 /* const_binop may not detect overflow correctly,
7009 so check for it explicitly here. */
7018 ctype,
7020 t1),
7025 /* See if we can eliminate the operation on both sides. If we can, we
7026 can return a new PLUS or MINUS. If we can't, the only remaining
7027 cases where we can do anything are if the second operand is a
7028 constant. */
7035 /* If not multiplication, we can only do this if both operands
7036 are divisible by c. */
7039 {
7044 }
7046 /* If this was a subtraction, negate OP1 and set it to be an addition.
7047 This simplifies the logic below. */
7049 {
7051 /* If OP1 was not easily negatable, the constant may be OP0. */
7053 {
7056 }
7057 }
7062 /* If either OP1 or C are negative, this optimization is not safe for
7063 some of the division and remainder types while for others we need
7064 to change the code. */
7066 {
7074 }
7076 /* If it's a multiply or a division/modulus operation of a multiple
7077 of our constant, do the operation and verify it doesn't overflow. */
7081 {
7084 /* We allow the constant to overflow with wrapping semantics. */
7088 }
7089 else
7092 /* If we have an unsigned type, we cannot widen the operation since it
7093 will change the result if the original computation overflowed. */
7097 /* The last case is if we are a multiply. In that case, we can
7098 apply the distributive law to commute the multiply and addition
7099 if the multiplication of the constants doesn't overflow
7100 and overflow is defined. With undefined overflow
7101 op0 * c might overflow, while (op0 + orig_op1) * c doesn't.
7102 But fold_plusminus_mult_expr would factor back any power-of-two
7103 value so do not distribute in the first place in this case. */
7111 op1);
7116 /* We have a special case here if we are doing something like
7117 (C * 8) % 4 since we know that's zero. */
7120 /* If the multiplication can overflow we cannot optimize this. */
7125 {
7128 }
7130 /* ... fall through ... */
7134 /* If we can extract our operation from the LHS, do so and return a
7135 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
7136 do something only if the second operand is a constant. */
7152 /* If these are the same operation types, we can associate them
7153 assuming no overflow. */
7155 {
7170 }
7172 /* If these operations "cancel" each other, we have the main
7173 optimizations of this pass, which occur when either constant is a
7174 multiple of the other, in which case we replace this with either an
7175 operation or CODE or TCODE.
7177 If we have an unsigned type, we cannot do this since it will change
7178 the result if the original computation overflowed. */
7186 {
7189 {
7195 }
7198 {
7204 }
7205 }
7210 }
7213 }
7214 \f
7215 /* Return a node which has the indicated constant VALUE (either 0 or
7216 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
7217 and is of the indicated TYPE. */
7219 tree
7221 {
7230 else
7232 }
7235 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
7236 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
7237 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
7238 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
7239 COND is the first argument to CODE; otherwise (as in the example
7240 given here), it is the second argument. TYPE is the type of the
7241 original expression. Return NULL_TREE if no simplification is
7242 possible. */
7244 static tree
7249 {
7257 /* Do not move possibly trapping operations into the conditional as this
7258 pessimizes code and causes gimplification issues when applied late. */
7266 {
7270 /* If this operand throws an expression, then it does not make
7271 sense to try to perform a logical or arithmetic operation
7272 involving it. */
7277 }
7280 {
7285 }
7286 else
7287 /* Detect the case of mixing vector and scalar types - bail out. */
7293 /* This transformation is only worthwhile if we don't have to wrap ARG
7294 in a SAVE_EXPR and the operation can be simplified without recursing
7295 on at least one of the branches once its pushed inside the COND_EXPR. */
7304 {
7308 else
7310 }
7312 {
7316 else
7318 }
7320 /* Check that we have simplified at least one of the branches. */
7325 }
7327 \f
7328 /* Subroutine of fold() that checks for the addition of ARG +/- 0.0.
7330 If !NEGATE, return true if ZERO_ARG is +/-0.0 and, for all ARG of
7331 type TYPE, ARG + ZERO_ARG is the same as ARG. If NEGATE, return true
7332 if ARG - ZERO_ARG is the same as X.
7334 If ARG is NULL, check for any value of type TYPE.
7336 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
7337 and finite. The problematic cases are when X is zero, and its mode
7338 has signed zeros. In the case of rounding towards -infinity,
7339 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
7340 modes, X + 0 is not the same as X because -0 + 0 is 0. */
7342 bool
7345 {
7349 /* Don't allow the fold with -fsignaling-nans. */
7353 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
7357 /* There is no case that is safe for all rounding modes. */
7361 /* In a vector or complex, we would need to check the sign of all zeros. */
7367 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
7371 /* The mode has signed zeros, and we have to honor their sign.
7372 In this situation, there are only two cases we can return true for.
7373 (i) X - 0 is the same as X with default rounding.
7374 (ii) X + 0 is X when X can't possibly be -0.0. */
7376 }
7378 /* Subroutine of match.pd that optimizes comparisons of a division by
7379 a nonzero integer constant against an integer constant, i.e.
7380 X/C1 op C2.
7382 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
7383 GE_EXPR or LE_EXPR. ARG01 and ARG1 must be a INTEGER_CST. */
7385 enum tree_code
7388 {
7393 /* We have to do this the hard way to detect unsigned overflow.
7394 prod = int_const_binop (MULT_EXPR, c1, c2); */
7400 {
7404 /* Likewise *hi = int_const_binop (PLUS_EXPR, prod, tmp). */
7407 }
7409 {
7412 {
7431 }
7432 }
7433 else
7434 {
7435 /* A negative divisor reverses the relational operators. */
7440 {
7459 }
7460 }
7473 }
7475 /* Test whether it is preferable to swap two operands, ARG0 and
7476 ARG1, for example because ARG0 is an integer constant and ARG1
7477 isn't. */
7479 bool
7481 {
7495 /* It is preferable to swap two SSA_NAME to ensure a canonical form
7496 for commutative and comparison operators. Ensuring a canonical
7497 form allows the optimizers to find additional redundancies without
7498 having to explicitly check for both orderings. */
7504 /* Put SSA_NAMEs last. */
7510 /* Put variables last. */
7517 }
7520 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
7521 means A >= Y && A != MAX, but in this case we know that
7522 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
7524 static tree
7526 {
7533 else
7542 {
7545 }
7547 {
7550 }
7551 else
7558 {
7559 /* Convert the pointer types into integer before taking the difference. */
7563 }
7564 else
7571 }
7573 /* Fold a sum or difference of at least one multiplication.
7574 Returns the folded tree or NULL if no simplification could be made. */
7576 static tree
7579 {
7583 /* (A * C) +- (B * C) -> (A+-B) * C.
7584 (A * C) +- A -> A * (C+-1).
7585 We are most concerned about the case where C is a constant,
7586 but other combinations show up during loop reduction. Since
7587 it is not difficult, try all four possibilities. */
7590 {
7593 }
7595 {
7598 }
7599 else
7600 {
7601 /* We cannot generate constant 1 for fract. */
7606 }
7608 {
7611 }
7613 {
7615 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7616 the purpose of this canonicalization. */
7620 {
7623 }
7624 else
7626 }
7627 else
7628 {
7629 /* We cannot generate constant 1 for fract. */
7634 }
7637 /* Prefer factoring a common non-constant. */
7647 /* No identical multiplicands; see if we can find a common
7648 power-of-two factor in non-power-of-two multiplies. This
7649 can help in multi-dimensional array access. */
7651 {
7654 HOST_WIDE_INT tmp;
7656 tree maybe_same;
7658 /* Move min of absolute values to int11. */
7660 {
7665 }
7666 else
7673 /* The remainder should not be a constant, otherwise we
7674 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7675 increased the number of multiplications necessary. */
7677 {
7685 }
7686 }
7693 /* We are neither factoring zero nor minus one. */
7701 /* Same may be zero and thus the operation 'code' may overflow. Likewise
7702 same may be minus one and thus the multiplication may overflow. Perform
7703 the sum operation in an unsigned type. */
7708 /* If the sum evaluated to a constant that is not -INF the multiplication
7709 cannot overflow. */
7716 /* Do not resort to unsigned multiplication because
7717 we lose the no-overflow property of the expression. */
7719 }
7721 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7722 specified by EXPR into the buffer PTR of length LEN bytes.
7723 Return the number of bytes placed in the buffer, or zero
7724 upon failure. */
7726 static int
7728 {
7732 {
7738 {
7740 /* More work is needed when adding _BitInt support to PDP endian
7741 if limb is smaller than word, or if _BitInt limb ordering doesn't
7742 match target endianity here. */
7747 }
7748 else
7750 }
7751 else
7762 /* Dry run. */
7768 {
7770 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7771 number of bytes. */
7775 {
7782 else
7784 }
7785 else
7789 }
7791 }
7794 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7795 specified by EXPR into the buffer PTR of length LEN bytes.
7796 Return the number of bytes placed in the buffer, or zero
7797 upon failure. */
7799 static int
7801 {
7805 FIXED_VALUE_TYPE value;
7820 }
7823 /* Subroutine of native_encode_expr. Encode the REAL_CST
7824 specified by EXPR into the buffer PTR of length LEN bytes.
7825 Return the number of bytes placed in the buffer, or zero
7826 upon failure. */
7828 static int
7830 {
7836 /* There are always 32 bits in each long, no matter the size of
7837 the hosts long. We handle floating point representations with
7838 up to 192 bits. */
7847 /* Dry run. */
7856 {
7861 {
7868 else
7870 }
7871 else
7872 {
7875 {
7876 /* Reverse bytes within each long, or within the entire float
7877 if it's smaller than a long (for HFmode). */
7880 }
7881 }
7886 }
7888 }
7890 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7891 specified by EXPR into the buffer PTR of length LEN bytes.
7892 Return the number of bytes placed in the buffer, or zero
7893 upon failure. */
7895 static int
7897 {
7899 tree part;
7913 }
7915 /* Like native_encode_vector, but only encode the first COUNT elements.
7916 The other arguments are as for native_encode_vector. */
7918 static int
7921 {
7925 {
7926 /* This is the only case in which elements can be smaller than a byte.
7927 Element 0 is always in the lsb of the containing byte. */
7936 /* Zero the buffer and then set bits later where necessary. */
7945 {
7951 {
7954 }
7955 }
7957 }
7962 {
7964 {
7967 }
7978 }
7980 }
7982 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7983 specified by EXPR into the buffer PTR of length LEN bytes.
7984 Return the number of bytes placed in the buffer, or zero
7985 upon failure. */
7987 static int
7989 {
7994 }
7997 /* Subroutine of native_encode_expr. Encode the STRING_CST
7998 specified by EXPR into the buffer PTR of length LEN bytes.
7999 Return the number of bytes placed in the buffer, or zero
8000 upon failure. */
8002 static int
8004 {
8007 /* Wide-char strings are encoded in target byte-order so native
8008 encoding them is trivial. */
8023 else
8024 {
8027 {
8030 }
8032 }
8034 }
8037 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST, REAL_CST,
8038 FIXED_CST, COMPLEX_CST, STRING_CST, or VECTOR_CST specified by EXPR into
8039 the buffer PTR of size LEN bytes. If PTR is NULL, don't actually store
8040 anything, just do a dry run. Fail either if OFF is -1 and LEN isn't
8041 sufficient to encode the entire EXPR, or if OFF is out of bounds.
8042 Otherwise, start at byte offset OFF and encode at most LEN bytes.
8043 Return the number of bytes placed in the buffer, or zero upon failure. */
8045 int
8047 {
8048 /* We don't support starting at negative offset and -1 is special. */
8053 {
8074 }
8075 }
8077 /* Try to find a type whose byte size is smaller or equal to LEN bytes larger
8078 or equal to FIELDSIZE bytes, with underlying mode precision/size multiple
8079 of BITS_PER_UNIT. As native_{interpret,encode}_int works in term of
8080 machine modes, we can't just use build_nonstandard_integer_type. */
8082 tree
8084 {
8085 machine_mode mode;
8087 {
8094 {
8098 }
8099 }
8105 {
8113 }
8116 }
8118 /* Similar to native_encode_expr, but also handle CONSTRUCTORs, VCEs,
8119 NON_LVALUE_EXPRs and nops. If MASK is non-NULL (then PTR has
8120 to be non-NULL and OFF zero), then in addition to filling the
8121 bytes pointed by PTR with the value also clear any bits pointed
8122 by MASK that are known to be initialized, keep them as is for
8123 e.g. uninitialized padding bits or uninitialized fields. */
8125 int
8128 {
8131 /* We don't support starting at negative offset and -1 is special. */
8139 {
8143 mask);
8158 {
8159 tree min_index;
8177 {
8182 {
8185 }
8190 else
8194 {
8198 offset_int wpos
8206 offset_int wcount
8213 }
8215 {
8218 offset_int wpos
8226 }
8229 {
8231 {
8242 }
8244 {
8248 }
8249 }
8253 do
8254 {
8259 {
8261 {
8264 fieldsize);
8267 }
8269 ptr
8272 fieldsize,
8275 mask
8279 else
8280 {
8283 }
8284 }
8287 {
8288 /* Partial overlap. */
8294 {
8298 fieldsize);
8299 }
8300 else
8301 {
8305 }
8308 }
8310 }
8312 }
8314 }
8317 {
8327 {
8333 {
8336 }
8339 {
8348 }
8352 else
8356 {
8357 tree fld;
8359 {
8372 }
8374 {
8378 }
8381 {
8382 cnt--;
8388 }
8389 }
8394 {
8407 {
8412 }
8413 }
8414 else
8415 {
8420 }
8424 /* Prepare to deal with integral bit-fields and filter out other
8425 bit-fields that do not start and end on a byte boundary. */
8427 {
8432 {
8438 }
8444 }
8454 {
8455 /* FIXME: Handle PDP endian. */
8466 {
8469 }
8470 else
8471 {
8479 else
8480 {
8483 }
8484 }
8494 else
8507 /* If the bitfield does not start at byte boundary, handle
8508 the partial byte at the start. */
8511 {
8513 {
8518 {
8521 else
8523 }
8524 }
8525 else
8526 {
8531 {
8534 else
8538 }
8539 }
8540 }
8541 /* If the bitfield does not end at byte boundary, handle
8542 the partial byte at the end. */
8546 {
8548 {
8555 }
8556 else
8557 {
8564 }
8565 }
8569 {
8574 }
8575 else
8576 {
8577 /* Partial overlap. */
8581 {
8584 }
8588 }
8590 }
8595 {
8598 {
8601 {
8605 }
8608 }
8611 fldsize,
8621 }
8622 else
8623 {
8624 /* Partial overlap. */
8630 {
8634 fieldsize);
8635 }
8636 else
8637 {
8641 }
8644 }
8645 }
8647 }
8649 }
8650 }
8653 /* Subroutine of native_interpret_expr. Interpret the contents of
8654 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
8655 If the buffer cannot be interpreted, return NULL_TREE. */
8657 static tree
8659 {
8662 {
8668 {
8670 /* More work is needed when adding _BitInt support to PDP endian
8671 if limb is smaller than word, or if _BitInt limb ordering doesn't
8672 match target endianity here. */
8677 }
8678 else
8680 }
8681 else
8691 }
8694 /* Subroutine of native_interpret_expr. Interpret the contents of
8695 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
8696 If the buffer cannot be interpreted, return NULL_TREE. */
8698 static tree
8700 {
8703 double_int result;
8704 FIXED_VALUE_TYPE fixed_value;
8714 }
8717 /* Subroutine of native_interpret_expr. Interpret the contents of
8718 the buffer PTR of length LEN as a REAL_CST of type TYPE.
8719 If the buffer cannot be interpreted, return NULL_TREE. */
8721 tree
8723 {
8727 /* There are always 32 bits in each long, no matter the size of
8728 the hosts long. We handle floating point representations with
8729 up to 192 bits. */
8730 REAL_VALUE_TYPE r;
8740 {
8741 /* Both OFFSET and BYTE index within a long;
8742 bitpos indexes the whole float. */
8745 {
8752 else
8754 }
8755 else
8756 {
8759 {
8760 /* Reverse bytes within each long, or within the entire float
8761 if it's smaller than a long (for HFmode). */
8764 }
8765 }
8769 }
8773 }
8776 /* Subroutine of native_interpret_expr. Interpret the contents of
8777 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
8778 If the buffer cannot be interpreted, return NULL_TREE. */
8780 static tree
8782 {
8797 }
8799 /* Read a vector of type TYPE from the target memory image given by BYTES,
8800 which contains LEN bytes. The vector is known to be encodable using
8801 NPATTERNS interleaved patterns with NELTS_PER_PATTERN elements each.
8803 Return the vector on success, otherwise return null. */
8805 static tree
8809 {
8813 {
8814 /* This is the only case in which elements can be smaller than a byte.
8815 Element 0 is always in the lsb of the containing byte. */
8822 {
8829 }
8831 }
8839 {
8845 }
8847 }
8849 /* Subroutine of native_interpret_expr. Interpret the contents of
8850 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
8851 If the buffer cannot be interpreted, return NULL_TREE. */
8853 static tree
8855 {
8864 }
8867 /* Subroutine of fold_view_convert_expr. Interpret the contents of
8868 the buffer PTR of length LEN as a constant of type TYPE. For
8869 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
8870 we return a REAL_CST, etc... If the buffer cannot be interpreted,
8871 return NULL_TREE. */
8873 tree
8875 {
8877 {
8889 {
8890 /* For floating point values in composite modes, punt if this
8891 folding doesn't preserve bit representation. As the mode doesn't
8892 have fixed precision while GCC pretends it does, there could be
8893 valid values that GCC can't really represent accurately.
8894 See PR95450. Even for other modes, e.g. x86 XFmode can have some
8895 bit combinationations which GCC doesn't preserve. */
8905 }
8919 }
8920 }
8922 /* Returns true if we can interpret the contents of a native encoding
8923 as TYPE. */
8925 bool
8927 {
8929 {
8943 }
8944 }
8946 /* Attempt to interpret aggregate of TYPE from bytes encoded in target
8947 byte order at PTR + OFF with LEN bytes. Does not handle unions. */
8949 tree
8952 {
8955 {
8962 {
8966 }
8971 {
8976 {
8981 }
8985 eltsz);
8989 }
8991 }
8995 {
9004 {
9007 {
9008 poly_int64 bitoffset;
9013 else
9023 }
9024 else
9025 {
9043 HOST_WIDE_INT rpos;
9046 else
9047 {
9050 }
9059 }
9060 }
9063 {
9073 }
9077 {
9082 }
9089 {
9093 /* FIXME: Figure out how to handle PDP endian bitfields. */
9099 else
9103 }
9105 }
9107 }
9109 /* Routines for manipulation of native_encode_expr encoded data if the encoded
9110 or extracted constant positions and/or sizes aren't byte aligned. */
9112 /* Shift left the bytes in PTR of SZ elements by AMNT bits, carrying over the
9113 bits between adjacent elements. AMNT should be within
9114 [0, BITS_PER_UNIT).
9115 Example, AMNT = 2:
9116 00011111|11100000 << 2 = 01111111|10000000
9117 PTR[1] | PTR[0] PTR[1] | PTR[0]. */
9119 void
9122 {
9131 {
9137 {
9140 }
9141 }
9142 }
9144 /* Like shift_bytes_in_array_left but for big-endian.
9145 Shift right the bytes in PTR of SZ elements by AMNT bits, carrying over the
9146 bits between adjacent elements. AMNT should be within
9147 [0, BITS_PER_UNIT).
9148 Example, AMNT = 2:
9149 00011111|11100000 >> 2 = 00000111|11111000
9150 PTR[0] | PTR[1] PTR[0] | PTR[1]. */
9152 void
9155 {
9163 {
9170 }
9171 }
9173 /* Try to view-convert VECTOR_CST EXPR to VECTOR_TYPE TYPE by operating
9174 directly on the VECTOR_CST encoding, in a way that works for variable-
9175 length vectors. Return the resulting VECTOR_CST on success or null
9176 on failure. */
9178 static tree
9180 {
9192 /* We can only preserve the semantics of a stepped pattern if the new
9193 vector element is an integer of the same size. */
9198 /* The number of bits needed to encode one element from every pattern
9199 of the original vector. */
9200 unsigned int expr_sequence_bits
9203 /* The number of bits needed to encode one element from every pattern
9204 of the result. */
9205 unsigned int type_sequence_bits
9208 /* Don't try to read more bytes than are available, which can happen
9209 for constant-sized vectors if TYPE has larger elements than EXPR_TYPE.
9210 The general VIEW_CONVERT handling can cope with that case, so there's
9211 no point complicating things here. */
9214 BITS_PER_UNIT);
9219 /* Get enough bytes of EXPR to form the new encoding. */
9227 /* Reencode the bytes as TYPE. */
9231 }
9233 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
9234 TYPE at compile-time. If we're unable to perform the conversion
9235 return NULL_TREE. */
9237 static tree
9239 {
9240 /* We support up to 512-bit values (for V8DFmode). */
9244 /* Check that the host and target are sane. */
9257 }
9259 /* Build an expression for the address of T. Folds away INDIRECT_REF
9260 to avoid confusing the gimplify process. */
9262 tree
9264 {
9265 /* The size of the object is not relevant when talking about its address. */
9270 {
9275 }
9278 {
9283 }
9290 {
9295 }
9296 else
9300 }
9302 /* Build an expression for the address of T. */
9304 tree
9306 {
9310 }
9312 /* Fold a unary expression of code CODE and type TYPE with operand
9313 OP0. Return the folded expression if folding is successful.
9314 Otherwise, return NULL_TREE. */
9316 tree
9318 {
9319 tree tem;
9320 tree arg0;
9328 {
9331 {
9332 /* Don't use STRIP_NOPS, because signedness of argument type
9333 matters. */
9335 }
9336 else
9337 {
9338 /* Strip any conversions that don't change the mode. This
9339 is safe for every expression, except for a comparison
9340 expression because its signedness is derived from its
9341 operands.
9343 Note that this is done as an internal manipulation within
9344 the constant folder, in order to find the simplest
9345 representation of the arguments so that their form can be
9346 studied. In any cases, the appropriate type conversions
9347 should be put back in the tree that will get out of the
9348 constant folder. */
9350 }
9353 {
9356 {
9360 }
9361 }
9362 }
9369 {
9376 {
9390 /* If this was a conversion, and all we did was to move into
9391 inside the COND_EXPR, bring it back out. But leave it if
9392 it is a conversion from integer to integer and the
9393 result precision is no wider than a word since such a
9394 conversion is cheap and may be optimized away by combine,
9395 while it couldn't if it were outside the COND_EXPR. Then return
9396 so we don't get into an infinite recursion loop taking the
9397 conversion out and then back in. */
9409 && (INTEGRAL_TYPE_P
9422 }
9423 }
9426 {
9432 CASE_CONVERT:
9436 {
9437 /* If we have (type) (a CMP b) and type is an integral type, return
9438 new expression involving the new type. Canonicalize
9439 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
9440 non-integral type.
9441 Do not fold the result as that would not simplify further, also
9442 folding again results in recursions. */
9452 }
9454 /* Handle (T *)&A.B.C for A being of type T and B and C
9455 living at offset zero. This occurs frequently in
9456 C++ upcasting and then accessing the base. */
9460 {
9462 tree offset;
9463 machine_mode mode;
9465 tree base
9469 /* If the reference was to a (constant) zero offset, we can use
9470 the address of the base if it has the same base type
9471 as the result type and the pointer type is unqualified. */
9479 }
9483 /* Detect assigning a bitfield. */
9485 && DECL_BIT_FIELD
9487 {
9488 /* Don't leave an assignment inside a conversion
9489 unless assigning a bitfield. */
9491 /* First do the assignment, then return converted constant. */
9496 }
9498 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
9499 constants (if x has signed type, the sign bit cannot be set
9500 in c). This folds extension into the BIT_AND_EXPR.
9501 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
9502 very likely don't have maximal range for their precision and this
9503 transformation effectively doesn't preserve non-maximal ranges. */
9507 {
9518 <= HOST_BITS_PER_WIDE_INT
9520 {
9524 cst &= HOST_WIDE_INT_M1U
9528 && !flag_syntax_only
9531 {
9535 }
9536 }
9538 {
9543 }
9544 }
9546 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
9547 cast (T1)X will fold away. We assume that this happens when X itself
9548 is a cast. */
9552 {
9556 /* If -fsanitize=alignment, avoid this optimization in GENERIC
9557 when the pointed type needs higher alignment than
9558 the p+ first operand's pointed type. */
9565 /* Similarly, avoid this optimization in GENERIC for -fsanitize=null
9566 when type is a reference type and arg00's type is not,
9567 because arg00 could be validly nullptr and if arg01 doesn't return,
9568 we don't want false positive binding of reference to nullptr. */
9570 && !in_gimple_form
9577 }
9579 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
9580 of the same precision, and X is an integer type not narrower than
9581 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
9587 {
9593 }
9595 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
9596 type of X and Y (integer types only). */
9603 {
9604 /* Be careful not to introduce new overflows. */
9605 tree mult_type;
9608 else
9612 {
9619 }
9620 }
9626 {
9633 }
9644 /* Convert fabs((double)float) into (double)fabsf(float). */
9647 {
9653 targ0));
9654 }
9658 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
9677 /* Note that the operand of this must be an int
9678 and its values must be 0 or 1.
9679 ("true" is a fixed value perhaps depending on the language,
9680 but we don't handle values other than 1 correctly yet.) */
9687 /* Fold *&X to X if X is an lvalue. */
9689 {
9696 }
9702 }
9705 /* If the operation was a conversion do _not_ mark a resulting constant
9706 with TREE_OVERFLOW if the original constant was not. These conversions
9707 have implementation defined behavior and retaining the TREE_OVERFLOW
9708 flag here would confuse later passes such as VRP. */
9709 tree
9712 {
9721 }
9723 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
9724 operands OP0 and OP1. LOC is the location of the resulting expression.
9725 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
9726 Return the folded expression if folding is successful. Otherwise,
9727 return NULL_TREE. */
9728 static tree
9731 {
9732 tree tem;
9734 /* We only do these simplifications if we are optimizing. */
9738 /* Check for things like (A || B) && (A || C). We can convert this
9739 to A || (B && C). Note that either operator can be any of the four
9740 truth and/or operations and the transformation will still be
9741 valid. Also note that we only care about order for the
9742 ANDIF and ORIF operators. If B contains side effects, this
9743 might change the truth-value of A. */
9750 {
9770 /* This case if tricky because we must either have commutative
9771 operators or else A10 must not have side-effects. */
9777 a01);
9778 }
9780 /* See if we can build a range comparison. */
9786 {
9790 }
9794 {
9798 }
9800 /* Check for the possibility of merging component references. If our
9801 lhs is another similar operation, try to merge its rhs with our
9802 rhs. Then try to merge our lhs and rhs. */
9813 logical_op_non_short_circuit
9821 {
9828 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
9829 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
9830 We don't want to pack more than two leafs to a non-IF AND/OR
9831 expression.
9832 If tree-code of left-hand operand isn't an AND/OR-IF code and not
9833 equal to IF-CODE, then we don't want to add right-hand operand.
9834 If the inner right-hand side of left-hand operand has
9835 side-effects, or isn't simple, then we can't add to it,
9836 as otherwise we might destroy if-sequence. */
9839 /* Needed for sequence points to handle trappings, and
9840 side-effects. */
9842 {
9844 arg1);
9846 tem);
9847 }
9848 /* Same as above but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
9849 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
9852 /* Needed for sequence points to handle trappings, and
9853 side-effects. */
9855 {
9860 }
9861 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
9862 into (A OR B).
9863 For sequence point consistancy, we need to check for trapping,
9864 and side-effects. */
9868 }
9871 }
9873 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
9874 by changing CODE to reduce the magnitude of constants involved in
9875 ARG0 of the comparison.
9876 Returns a canonicalized comparison tree if a simplification was
9877 possible, otherwise returns NULL_TREE.
9878 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
9879 valid if signed overflow is undefined. */
9881 static tree
9885 {
9890 /* Match A +- CST code arg1. We can change this only if overflow
9891 is undefined. */
9894 /* In principle pointers also have undefined overflow behavior,
9895 but that causes problems elsewhere. */
9902 /* Identify the constant in arg0 and its sign. */
9906 /* Overflowed constants and zero will cause problems. */
9911 /* See if we can reduce the magnitude of the constant in
9912 arg0 by changing the comparison code. */
9913 /* A - CST < arg1 -> A - CST-1 <= arg1. */
9917 /* A + CST > arg1 -> A + CST-1 >= arg1. */
9921 /* A + CST <= arg1 -> A + CST-1 < arg1. */
9925 /* A - CST >= arg1 -> A - CST-1 > arg1. */
9929 else
9933 /* Now build the constant reduced in magnitude. But not if that
9934 would produce one outside of its types range. */
9950 }
9952 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
9953 overflow further. Try to decrease the magnitude of constants involved
9954 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
9955 and put sole constants at the second argument position.
9956 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
9958 static tree
9961 {
9962 tree t;
9967 /* Try canonicalization by simplifying arg0. */
9972 {
9976 }
9978 /* Try canonicalization by simplifying arg1 using the swapped
9979 comparison. */
9987 }
9989 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
9990 space. This is used to avoid issuing overflow warnings for
9991 expressions like &p->x which cannot wrap. */
9993 static bool
9995 {
10002 poly_wide_int wi_offset;
10008 else
10013 precision);
10028 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
10029 array. */
10038 }
10040 /* Return a positive integer when the symbol DECL is known to have
10041 a nonzero address, zero when it's known not to (e.g., it's a weak
10042 symbol), and a negative integer when the symbol is not yet in the
10043 symbol table and so whether or not its address is zero is unknown.
10044 For function local objects always return positive integer. */
10045 static int
10047 {
10048 /* Normally, don't do anything for variables and functions before symtab is
10049 built; it is quite possible that DECL will be declared weak later.
10050 But if folding_initializer, we need a constant answer now, so create
10051 the symtab entry and prevent later weak declaration. */
10054 = (folding_initializer
10059 /* Function local objects are never NULL. */
10067 }
10069 /* Subroutine of fold_binary. This routine performs all of the
10070 transformations that are common to the equality/inequality
10071 operators (EQ_EXPR and NE_EXPR) and the ordering operators
10072 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
10073 fold_binary should call fold_binary. Fold a comparison with
10074 tree code CODE and type TYPE with operands OP0 and OP1. Return
10075 the folded comparison or NULL_TREE. */
10077 static tree
10080 {
10090 /* For comparisons of pointers we can decompose it to a compile time
10091 comparison of the base objects and the offsets into the object.
10092 This requires at least one operand being an ADDR_EXPR or a
10093 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
10099 {
10102 machine_mode mode;
10106 /* Get base and offset for the access. Strip ADDR_EXPR for
10107 get_inner_reference, but put it back by stripping INDIRECT_REF
10108 off the base object if possible. indirect_baseN will be true
10109 if baseN is not an address but refers to the object itself. */
10112 {
10113 base0
10119 else
10121 }
10123 {
10127 {
10128 base0
10134 else
10136 }
10139 else
10143 {
10150 }
10151 }
10155 {
10156 base1
10162 else
10164 }
10166 {
10170 {
10171 base1
10177 else
10179 }
10182 else
10186 {
10193 }
10194 }
10196 /* If we have equivalent bases we might be able to simplify. */
10200 {
10201 /* We can fold this expression to a constant if the non-constant
10202 offset parts are equal. */
10206 && (equality_code
10207 || (indirect_base0
10210 {
10216 "occur when comparing P +- C1 with "
10218 WARN_STRICT_OVERFLOW_CONDITIONAL);
10221 {
10259 }
10260 }
10261 /* We can simplify the comparison to a comparison of the variable
10262 offset parts if the constant offset parts are equal.
10263 Be careful to use signed sizetype here because otherwise we
10264 mess with array offsets in the wrong way. This is possible
10265 because pointer arithmetic is restricted to retain within an
10266 object and overflow on pointer differences is undefined as of
10267 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
10269 && (equality_code
10270 || (indirect_base0
10273 {
10274 /* By converting to signed sizetype we cover middle-end pointer
10275 arithmetic which operates on unsigned pointer types of size
10276 type size and ARRAY_REF offsets which are properly sign or
10277 zero extended from their type in case it is narrower than
10278 sizetype. */
10281 else
10285 else
10292 "occur when comparing P +- C1 with "
10294 WARN_STRICT_OVERFLOW_COMPARISON);
10297 }
10298 }
10299 /* For equal offsets we can simplify to a comparison of the
10300 base addresses. */
10302 && (indirect_base0
10304 && (indirect_base1
10309 {
10315 }
10316 /* Comparison between an ordinary (non-weak) symbol and a null
10317 pointer can be eliminated since such symbols must have a non
10318 null address. In C, relational expressions between pointers
10319 to objects and null pointers are undefined. The results
10320 below follow the C++ rules with the additional property that
10321 every object pointer compares greater than a null pointer.
10322 */
10325 /* Avoid folding references to struct members at offset 0 to
10326 prevent tests like '&ptr->firstmember == 0' from getting
10327 eliminated. When ptr is null, although the -> expression
10328 is strictly speaking invalid, GCC retains it as a matter
10329 of QoI. See PR c/44555. */
10332 && indirect_base0
10333 /* The caller guarantees that when one of the arguments is
10334 constant (i.e., null in this case) it is second. */
10336 {
10338 {
10349 }
10350 }
10351 }
10353 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
10354 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
10355 the resulting offset is smaller in absolute value than the
10356 original one and has the same sign. */
10365 {
10370 tree cst;
10372 "occur when combining constants around "
10375 /* Put the constant on the side where it doesn't overflow and is
10376 of lower absolute value and of same sign than before. */
10383 {
10386 variable1,
10390 }
10398 {
10404 variable2);
10405 }
10406 }
10412 /* If we are comparing an expression that just has comparisons
10413 of two integer values, arithmetic expressions of those comparisons,
10414 and constants, we can simplify it. There are only three cases
10415 to check: the two values can either be equal, the first can be
10416 greater, or the second can be greater. Fold the expression for
10417 those three values. Since each value must be 0 or 1, we have
10418 eight possibilities, each of which corresponds to the constant 0
10419 or 1 or one of the six possible comparisons.
10421 This handles common cases like (a > b) == 0 but also handles
10422 expressions like ((x > y) - (y > x)) > 0, which supposedly
10423 occur in macroized code. */
10426 {
10430 /* Don't handle degenerate cases here; they should already
10431 have been handled anyway. */
10440 {
10444 /* We can't just pass T to eval_subst in case cval1 or cval2
10445 was the same as ARG1. */
10447 tree high_result
10451 arg1);
10452 tree equal_result
10456 arg1);
10457 tree low_result
10461 arg1);
10463 /* All three of these results should be 0 or 1. Confirm they are.
10464 Then use those values to select the proper code to use. */
10469 {
10470 /* Make a 3-bit mask with the high-order bit being the
10471 value for `>', the next for '=', and the low for '<'. */
10475 {
10477 /* Always false. */
10498 /* Always true. */
10500 }
10503 }
10504 }
10505 }
10508 }
10511 /* Subroutine of fold_binary. Optimize complex multiplications of the
10512 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
10513 argument EXPR represents the expression "z" of type TYPE. */
10515 static tree
10517 {
10522 {
10525 }
10527 {
10530 }
10531 else
10532 {
10536 }
10545 }
10548 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
10549 CONSTRUCTOR ARG into array ELTS, which has NELTS elements, and return
10550 true if successful. */
10552 static bool
10554 {
10559 {
10562 }
10564 {
10570 else
10572 }
10573 else
10579 }
10581 /* Helper routine for fold_vec_perm_cst to check if SEL is a suitable
10582 mask for VLA vec_perm folding.
10583 REASON if specified, will contain the reason why SEL is not suitable.
10584 Used only for debugging and unit-testing. */
10586 static bool
10590 {
10597 {
10601 }
10603 /* We want to avoid cases where sel.length is not a multiple of npatterns.
10604 For eg: sel.length = 2 + 2x, and sel npatterns = 4. */
10605 poly_uint64 esel;
10607 {
10611 }
10617 {
10620 HOST_WIDE_INT step;
10622 {
10626 }
10627 // FIXME: Punt on step < 0 for now, revisit later.
10634 {
10638 }
10640 /* Ensure that stepped sequence of the pattern selects elements
10641 only from the same input vector. */
10650 {
10654 }
10656 /* Ensure that the stepped sequence always selects from the same
10657 input pattern. */
10658 unsigned arg_npatterns
10663 {
10667 }
10668 }
10671 }
10673 /* Try to fold permutation of ARG0 and ARG1 with SEL selector when
10674 the input vectors are VECTOR_CST. Return NULL_TREE otherwise.
10675 REASON has same purpose as described in
10676 valid_mask_for_fold_vec_perm_cst_p. */
10678 static tree
10681 {
10685 /* (1) If SEL is a suitable mask as determined by
10686 valid_mask_for_fold_vec_perm_cst_p, then:
10687 res_npatterns = max of npatterns between ARG0, ARG1, and SEL
10688 res_nelts_per_pattern = max of nelts_per_pattern between
10689 ARG0, ARG1 and SEL.
10690 (2) If SEL is not a suitable mask, and TYPE is VLS then:
10691 res_npatterns = nelts in result vector.
10692 res_nelts_per_pattern = 1.
10693 This exception is made so that VLS ARG0, ARG1 and SEL work as before. */
10695 {
10696 res_npatterns
10701 res_nelts_per_pattern
10707 }
10709 {
10712 }
10713 else
10718 {
10721 poly_uint64 r;
10724 /* Punt if sel[i] /trunc_div len cannot be determined,
10725 because the input vector to be chosen will depend on
10726 runtime vector length.
10727 For example if len == 4 + 4x, and sel[i] == 4,
10728 If len at runtime equals 4, we choose arg1[0].
10729 For any other value of len > 4 at runtime, we choose arg0[4].
10730 which makes the element choice dependent on runtime vector length. */
10732 {
10736 }
10738 /* sel[i] % len will give the index of element in the chosen input
10739 vector. For example if sel[i] == 5 + 4x and len == 4 + 4x,
10740 we will choose arg1[1] since (5 + 4x) % (4 + 4x) == 1. */
10742 {
10746 }
10751 }
10754 }
10756 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
10757 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
10758 NULL_TREE otherwise. */
10760 tree
10762 {
10778 /* For fall back case, we want to ensure we have VLS vectors
10779 with equal length. */
10793 {
10794 HOST_WIDE_INT index;
10798 }
10800 }
10802 /* Try to fold a pointer difference of type TYPE two address expressions of
10803 array references AREF0 and AREF1 using location LOC. Return a
10804 simplified expression for the difference or NULL_TREE. */
10806 static tree
10810 {
10815 /* If the bases are array references as well, recurse. If the bases
10816 are pointer indirections compute the difference of the pointers.
10817 If the bases are equal, we are set. */
10820 && (base_offset
10822 use_pointer_diff)))
10825 && (base_offset
10826 = use_pointer_diff
10836 {
10842 base_offset,
10845 }
10847 }
10849 /* If the real or vector real constant CST of type TYPE has an exact
10850 inverse, return it, else return NULL. */
10852 tree
10854 {
10855 REAL_VALUE_TYPE r;
10856 tree unit_type;
10857 machine_mode mode;
10860 {
10870 {
10874 tree_vector_builder elts;
10879 {
10884 }
10887 }
10891 }
10892 }
10894 /* Mask out the tz least significant bits of X of type TYPE where
10895 tz is the number of trailing zeroes in Y. */
10896 static wide_int
10898 {
10903 }
10905 /* Return true when T is an address and is known to be nonzero.
10906 For floating point we further ensure that T is not denormal.
10907 Similar logic is present in nonzero_address in rtlanal.h.
10909 If the return value is based on the assumption that signed overflow
10910 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
10911 change *STRICT_OVERFLOW_P. */
10913 static bool
10915 {
10919 /* Doing something useful for floating point would need more work. */
10925 {
10928 strict_overflow_p);
10934 strict_overflow_p);
10942 }
10945 {
10948 strict_overflow_p);
10956 strict_overflow_p);
10970 strict_overflow_p);
10974 strict_overflow_p);
10977 {
10989 }
10993 }
10995 }
10997 /* Return true when T is an address and is known to be nonzero.
10998 Handle warnings about undefined signed overflow. */
11000 bool
11002 {
11009 "determining that expression is always "
11011 WARN_STRICT_OVERFLOW_MISC);
11013 }
11015 /* Return true if T is known not to be equal to an integer W. */
11017 bool
11019 {
11020 int_range_max vr;
11022 {
11032 else
11037 /* If T has some known zero bits and W has any of those bits set,
11038 then T is known not to be equal to W. */
11046 }
11047 }
11049 /* Fold a binary expression of code CODE and type TYPE with operands
11050 OP0 and OP1. LOC is the location of the resulting expression.
11051 Return the folded expression if folding is successful. Otherwise,
11052 return NULL_TREE. */
11054 tree
11057 {
11072 /* Strip any conversions that don't change the mode. This is
11073 safe for every expression, except for a comparison expression
11074 because its signedness is derived from its operands. So, in
11075 the latter case, only strip conversions that don't change the
11076 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
11077 preserved.
11079 Note that this is done as an internal manipulation within the
11080 constant folder, in order to find the simplest representation
11081 of the arguments so that their form can be studied. In any
11082 cases, the appropriate type conversions should be put back in
11083 the tree that will get out of the constant folder. */
11086 {
11089 }
11090 else
11091 {
11094 }
11096 /* Note that TREE_CONSTANT isn't enough: static var addresses are
11097 constant but we can't do arithmetic on them. */
11099 {
11102 {
11106 }
11107 }
11109 /* If this is a commutative operation, and ARG0 is a constant, move it
11110 to ARG1 to reduce the number of tests below. */
11115 /* Likewise if this is a comparison, and ARG0 is a constant, move it
11116 to ARG1 to reduce the number of tests below. */
11125 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
11127 First check for cases where an arithmetic operation is applied to a
11128 compound, conditional, or comparison operation. Push the arithmetic
11129 operation inside the compound or conditional to see if any folding
11130 can then be done. Convert comparison to conditional for this purpose.
11131 The also optimizes non-constant cases that used to be done in
11132 expand_expr.
11134 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
11135 one of the operands is a comparison and the other is a comparison, a
11136 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
11137 code below would make the expression more complex. Change it to a
11138 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
11139 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
11152 {
11156 boolean_type_node,
11164 }
11168 {
11170 {
11175 tem);
11176 }
11178 {
11183 tem);
11184 }
11189 {
11195 }
11200 {
11206 }
11207 }
11210 {
11212 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
11215 {
11221 }
11223 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
11226 {
11227 tree base;
11228 poly_int64 coffset;
11237 }
11242 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
11248 arg1),
11250 arg0)));
11256 {
11257 /* X + (X / CST) * -CST is X % CST. */
11262 {
11271 cst0));
11272 }
11273 }
11275 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
11276 one. Make sure the type is not saturating and has the signedness of
11277 the stripped operands, as fold_plusminus_mult_expr will re-associate.
11278 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
11285 {
11289 }
11292 {
11293 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
11294 (plus (plus (mult) (mult)) (foo)) so that we can
11295 take advantage of the factoring cases below. */
11304 {
11310 else
11323 parg0),
11325 marg)),
11329 return
11335 parg1)));
11336 }
11337 }
11338 else
11339 {
11340 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
11341 to __complex__ ( x, y ). This is not the same for SNaNs or
11342 if signed zeros are involved. */
11346 {
11353 {
11357 {
11363 }
11365 {
11371 }
11372 }
11373 }
11375 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
11376 We associate floats only if the user has specified
11377 -fassociative-math. */
11381 {
11386 {
11387 tree tree0;
11390 }
11391 }
11392 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
11393 We associate floats only if the user has specified
11394 -fassociative-math. */
11398 {
11403 {
11404 tree tree0;
11407 }
11408 }
11409 }
11411 bit_rotate:
11412 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
11413 is a rotate of A by C1 bits. */
11414 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
11415 is a rotate of A by B bits.
11416 Similarly for (A << B) | (A >> (-B & C3)) where C3 is Z-1,
11417 though in this case CODE must be | and not + or ^, otherwise
11418 it doesn't return A when B is 0. */
11419 {
11421 tree rtype;
11430 /* Only create rotates in complete modes. Other cases are not
11431 expanded properly. */
11434 {
11447 {
11452 }
11457 {
11460 code0 == LSHIFT_EXPR
11463 }
11465 {
11475 {
11479 orig_tree01);
11481 }
11482 }
11486 {
11497 {
11501 orig_tree01);
11503 }
11504 }
11505 }
11506 }
11508 associate:
11509 /* In most languages, can't associate operations on floats through
11510 parentheses. Rather than remember where the parentheses were, we
11511 don't associate floats at all, unless the user has specified
11512 -fassociative-math.
11513 And, we need to make sure type is not saturating. */
11518 {
11524 /* Split both trees into variables, constants, and literals. Then
11525 associate each group together, the constants with literals,
11526 then the result with variables. This increases the chances of
11527 literals being recombined later and of generating relocatable
11528 expressions for the sum of a constant and literal. */
11536 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
11540 /* With undefined overflow prefer doing association in a type
11541 which wraps on overflow, if that is one of the operand types. */
11544 {
11552 }
11554 /* With undefined overflow we can only associate constants with one
11555 variable, and constants whose association doesn't overflow. */
11558 {
11560 {
11561 /* ??? If split_tree would handle NEGATE_EXPR we could
11562 simply reject these cases and the allowed cases would
11563 be the var0/minus_var1 ones. */
11569 {
11572 }
11579 {
11582 }
11588 /* The only case we can still associate with two variables
11589 is if they cancel out. */
11593 }
11599 }
11601 /* Only do something if we found more than two objects. Otherwise,
11602 nothing has changed and we risk infinite recursion. */
11610 {
11622 {
11626 }
11628 {
11632 }
11634 /* Preserve the MINUS_EXPR if the negative part of the literal is
11635 greater than the positive part. Otherwise, the multiplicative
11636 folding code (i.e extract_muldiv) may be fooled in case
11637 unsigned constants are subtracted, like in the following
11638 example: ((X*2 + 4) - 8U)/2. */
11640 {
11644 /* But avoid ending up with only negated parts. */
11646 {
11650 }
11651 else
11652 {
11656 }
11657 }
11659 /* Don't introduce overflows through reassociation. */
11664 /* Eliminate lit0 and minus_lit0 to con0 and minus_con0. */
11671 /* Eliminate minus_con0. */
11673 {
11680 else
11683 }
11685 /* Eliminate minus_var0. */
11687 {
11691 else
11694 }
11696 return
11699 }
11700 }
11706 /* Fold &a[i] - &a[j] to i-j. */
11711 {
11715 code
11719 }
11721 /* Further transformations are not for pointers. */
11725 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
11728 /* If arg0 is e.g. unsigned int and type is int, then this could
11729 introduce UB, because if A is INT_MIN at runtime, the original
11730 expression can be well defined while the latter is not.
11731 See PR83269. */
11740 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
11741 __complex__ ( x, -y ). This is not the same for SNaNs or if
11742 signed zeros are involved. */
11746 {
11753 {
11757 {
11759 arg1r ? arg1r
11764 }
11766 {
11770 arg1i ? arg1i
11773 }
11774 }
11775 }
11777 /* A - B -> A + (-B) if B is easily negatable. */
11781 /* Avoid this transformation if B is a positive REAL_CST. */
11789 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
11790 one. Make sure the type is not saturating and has the signedness of
11791 the stripped operands, as fold_plusminus_mult_expr will re-associate.
11792 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
11799 {
11803 }
11809 {
11810 /* Transform x * -C into -x * C if x is easily negatable. */
11825 {
11828 "occur when simplifying "
11830 WARN_STRICT_OVERFLOW_MISC);
11832 }
11834 /* Optimize z * conj(z) for integer complex numbers. */
11841 }
11842 else
11843 {
11844 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
11845 This is not the same for NaNs or if signed zeros are
11846 involved. */
11852 {
11855 return
11861 return
11866 }
11868 /* Optimize z * conj(z) for floating point complex numbers.
11869 Guarded by flag_unsafe_math_optimizations as non-finite
11870 imaginary components don't produce scalar results. */
11879 }
11883 /* Canonicalize (X & C1) | C2. */
11887 {
11892 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11900 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11902 {
11905 }
11907 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11908 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11909 mode which allows further optimizations. */
11914 {
11919 {
11922 }
11923 }
11926 {
11931 }
11932 }
11934 /* See if this can be simplified into a rotate first. If that
11935 is unsuccessful continue in the association code. */
11939 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11947 /* See if this can be simplified into a rotate first. If that
11948 is unsuccessful continue in the association code. */
11952 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11957 {
11958 tree tem2;
11965 }
11966 /* Fold ~X & 1 as (X & 1) == 0. */
11970 {
11971 tree tem2;
11978 }
11979 /* Fold !X & 1 as X == 0. */
11982 {
11986 }
11988 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11989 multiple of 1 << CST. */
11991 {
11998 }
12000 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
12001 bits from CST2. */
12005 {
12007 wide_int masked
12014 {
12015 /* Avoid the transform if arg1 is a mask of some
12016 mode which allows further optimizations. */
12023 }
12024 }
12026 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
12029 {
12034 return
12036 }
12041 /* Don't touch a floating-point divide by zero unless the mode
12042 of the constant can represent infinity. */
12048 /* (-A) / (-B) -> A / B */
12060 /* Fall through */
12063 /* Simplify A / (B << N) where A and B are positive and B is
12064 a power of 2, to A >> (N + log2(B)). */
12069 {
12072 {
12080 WARN_STRICT_OVERFLOW_MISC);
12086 }
12087 }
12089 /* Fall through */
12097 /* Convert -A / -B to A / B when the type is signed and overflow is
12098 undefined. */
12102 {
12105 "when distributing negation across "
12107 WARN_STRICT_OVERFLOW_MISC);
12112 }
12116 {
12119 "when distributing negation across "
12121 WARN_STRICT_OVERFLOW_MISC);
12126 }
12128 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12129 operation, EXACT_DIV_EXPR.
12131 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12132 At one time others generated faster code, it's not clear if they do
12133 after the last round to changes to the DIV code in expmed.cc. */
12144 {
12148 WARN_STRICT_OVERFLOW_MISC);
12150 }
12162 {
12166 WARN_STRICT_OVERFLOW_MISC);
12168 }
12176 /* Since negative shift count is not well-defined,
12177 don't try to compute it in the compiler. */
12183 /* If we have a rotate of a bit operation with the rotate count and
12184 the second operand of the bit operation both constant,
12185 permute the two operations. */
12191 {
12199 }
12201 /* Two consecutive rotates adding up to the some integer
12202 multiple of the precision of the type can be ignored. */
12218 /* Note that the operands of this must be ints
12219 and their values must be 0 or 1.
12220 ("true" is a fixed value perhaps depending on the language.) */
12221 /* If first arg is constant zero, return it. */
12224 /* FALLTHRU */
12226 /* If either arg is constant true, drop it. */
12230 /* Preserve sequence points. */
12233 /* If second arg is constant zero, result is zero, but first arg
12234 must be evaluated. */
12237 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12238 case will be handled here. */
12242 /* !X && X is always false. */
12246 /* X && !X is always false. */
12251 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12252 means A >= Y && A != MAX, but in this case we know that
12253 A < X <= MAX. */
12257 {
12269 }
12278 /* Note that the operands of this must be ints
12279 and their values must be 0 or true.
12280 ("true" is a fixed value perhaps depending on the language.) */
12281 /* If first arg is constant true, return it. */
12284 /* FALLTHRU */
12286 /* If either arg is constant zero, drop it. */
12290 /* Preserve sequence points. */
12293 /* If second arg is constant true, result is true, but we must
12294 evaluate first arg. */
12297 /* Likewise for first arg, but note this only occurs here for
12298 TRUTH_OR_EXPR. */
12302 /* !X || X is always true. */
12306 /* X || !X is always true. */
12311 /* (X && !Y) || (!X && Y) is X ^ Y */
12314 {
12331 }
12340 /* If the second arg is constant zero, drop it. */
12343 /* If the second arg is constant true, this is a logical inversion. */
12345 {
12348 }
12349 /* Identical arguments cancel to zero. */
12353 /* !X ^ X is always true. */
12358 /* X ^ !X is always true. */
12374 /* bool_var != 1 becomes !bool_var. */
12381 /* bool_var == 0 becomes !bool_var. */
12388 /* !exp != 0 becomes !exp */
12393 /* If this is an EQ or NE comparison with zero and ARG0 is
12394 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12395 two operations, but the latter can be done in one less insn
12396 on machines that have only two-operand insns or on which a
12397 constant cannot be the first operand. */
12400 {
12405 {
12413 }
12416 {
12424 }
12425 }
12427 /* If this is a comparison of a field, we may be able to simplify it. */
12430 /* Handle the constant case even without -O
12431 to make sure the warnings are given. */
12433 {
12437 }
12439 /* Optimize comparisons of strlen vs zero to a compare of the
12440 first character of the string vs zero. To wit,
12441 strlen(ptr) == 0 => *ptr == 0
12442 strlen(ptr) != 0 => *ptr != 0
12443 Other cases should reduce to one of these two (or a constant)
12444 due to the return value of strlen being unsigned. */
12446 {
12454 {
12455 tree ptrtype
12457 TYPE_QUAL_CONST));
12463 }
12464 }
12466 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12467 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12471 {
12476 {
12478 {
12481 }
12484 }
12485 }
12487 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12488 (X & C) == 0 when C is a single bit. */
12493 {
12500 arg1));
12501 }
12503 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12504 constant C is a power of two, i.e. a single bit. */
12511 {
12515 }
12517 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12518 when is C is a power of two, i.e. a single bit. */
12525 {
12531 }
12535 {
12542 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12543 operand_equal_p guarantees no side-effects so we don't need
12544 to use omit_one_operand on Z. */
12548 arg10));
12552 arg11));
12556 arg10));
12560 arg11));
12562 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
12565 {
12571 }
12572 }
12574 /* Attempt to simplify equality/inequality comparisons of complex
12575 values. Only lower the comparison if the result is known or
12576 can be simplified to a single scalar comparison. */
12581 {
12586 {
12589 }
12590 else
12591 {
12594 }
12597 {
12600 }
12601 else
12602 {
12605 }
12609 {
12611 {
12616 }
12617 else
12618 {
12623 }
12624 }
12628 {
12630 {
12635 }
12636 else
12637 {
12642 }
12643 }
12644 }
12656 /* Transform comparisons of the form X +- C CMP X. */
12661 {
12666 /* (X - c) > X becomes false. */
12672 /* Likewise (X + c) < X becomes false. */
12678 /* Convert (X - c) <= X to true. */
12685 /* Convert (X + c) >= X to true. */
12691 }
12693 /* If we are comparing an ABS_EXPR with a constant, we can
12694 convert all the cases into explicit comparisons, but they may
12695 well not be faster than doing the ABS and one comparison.
12696 But ABS (X) <= C is a range comparison, which becomes a subtraction
12697 and a comparison, and is probably faster. */
12711 /* Convert ABS_EXPR<x> >= 0 to true. */
12718 {
12721 "when simplifying comparison of "
12723 WARN_STRICT_OVERFLOW_CONDITIONAL);
12726 arg0);
12727 }
12729 /* Convert ABS_EXPR<x> < 0 to false. */
12734 {
12737 "when simplifying comparison of "
12739 WARN_STRICT_OVERFLOW_CONDITIONAL);
12742 arg0);
12743 }
12745 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
12746 and similarly for >= into !=. */
12756 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
12757 otherwise Y might be >= # of bits in X's type and thus e.g.
12758 (unsigned char) (1 << Y) for Y 15 might be 0.
12759 If the cast is widening, then 1 << Y should have unsigned type,
12760 otherwise if Y is number of bits in the signed shift type minus 1,
12761 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
12762 31 might be 0xffffffff80000000. */
12775 {
12781 }
12793 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
12794 {
12806 }
12811 /* When pedantic, a compound expression can be neither an lvalue
12812 nor an integer constant expression. */
12815 /* Don't let (0, 0) be null pointer constant. */
12823 }
12825 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
12826 ((A & N) + B) & M -> (A + B) & M
12827 Similarly if (N & M) == 0,
12828 ((A | N) + B) & M -> (A + B) & M
12829 and for - instead of + (or unary - instead of +)
12830 and/or ^ instead of |.
12831 If B is constant and (B & M) == 0, fold into A & M.
12833 This function is a helper for match.pd patterns. Return non-NULL
12834 type in which the simplified operation should be performed only
12835 if any optimization is possible.
12837 ARG1 is M above, ARG00 is left operand of +/-, if CODE00 is BIT_*_EXPR,
12838 then ARG00{0,1} are operands of that bitop, otherwise CODE00 is ERROR_MARK.
12839 Similarly for ARG01, CODE01 and ARG01{0,1}, just for the right operand of
12840 +/-. */
12841 tree
12846 {
12861 wide_int cst0;
12863 /* Now we know that arg0 is (C + D) or (C - D) or -C and
12864 arg1 (M) is == (1LL << cst) - 1.
12865 Store C into PMOP[0] and D into PMOP[1]. */
12872 {
12879 {
12882 }
12885 /* If C or D is of the form (A & N) where
12886 (N & M) == M, or of the form (A | N) or
12887 (A ^ N) where (N & M) == 0, replace it with A. */
12893 /* If C or D is a N where (N & M) == 0, it can be
12894 omitted (replaced with 0). */
12899 /* Similarly, with C - N where (-N & M) == 0. */
12907 }
12909 /* Only build anything new if we optimized one or both arguments above. */
12915 else
12917 }
12919 /* Used by contains_label_[p1]. */
12921 struct contains_label_data
12922 {
12925 };
12927 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
12928 a LABEL_EXPR or CASE_LABEL_EXPR not inside of another SWITCH_EXPR; otherwise
12929 return NULL_TREE. Do not check the subtrees of GOTO_EXPR. */
12931 static tree
12933 {
12936 {
12947 {
12955 }
12964 }
12965 }
12967 /* Return whether the sub-tree ST contains a label which is accessible from
12968 outside the sub-tree. */
12970 static bool
12972 {
12976 }
12978 /* Fold a ternary expression of code CODE and type TYPE with operands
12979 OP0, OP1, and OP2. Return the folded expression if folding is
12980 successful. Otherwise, return NULL_TREE. */
12982 tree
12985 {
12986 tree tem;
12993 /* If this is a commutative operation, and OP0 is a constant, move it
12994 to OP1 to reduce the number of tests below. */
13003 /* Strip any conversions that don't change the mode. This is safe
13004 for every expression, except for a comparison expression because
13005 its signedness is derived from its operands. So, in the latter
13006 case, only strip conversions that don't change the signedness.
13008 Note that this is done as an internal manipulation within the
13009 constant folder, in order to find the simplest representation of
13010 the arguments so that their form can be studied. In any cases,
13011 the appropriate type conversions should be put back in the tree
13012 that will get out of the constant folder. */
13014 {
13017 }
13020 {
13023 }
13026 {
13029 }
13032 {
13036 {
13042 }
13047 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13048 so all simple results must be passed through pedantic_non_lvalue. */
13050 {
13053 /* Only optimize constant conditions when the selected branch
13054 has the same type as the COND_EXPR. This avoids optimizing
13055 away "c ? x : throw", where the throw has a void type.
13056 Avoid throwing away that operand which contains label. */
13063 }
13065 {
13072 {
13075 {
13083 }
13088 }
13089 }
13091 /* If we have A op B ? A : C, we may be able to convert this to a
13092 simpler expression, depending on the operation and the values
13093 of B and C. Signed zeros prevent all of these transformations,
13094 for reasons given above each one.
13096 Also try swapping the arguments and inverting the conditional. */
13100 {
13107 }
13112 {
13119 arg00,
13120 arg01,
13124 }
13126 /* If the second operand is simpler than the third, swap them
13127 since that produces better jump optimization results. */
13130 {
13132 /* See if this can be inverted. If it can't, possibly because
13133 it was a floating-point inequality comparison, don't do
13134 anything. */
13138 }
13140 /* Convert A ? 1 : 0 to simply A. */
13145 /* If we try to convert OP0 to our type, the
13146 call to fold will try to move the conversion inside
13147 a COND, which will recurse. In that case, the COND_EXPR
13148 is probably the best choice, so leave it alone. */
13152 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13153 over COND_EXPR in cases such as floating point comparisons. */
13162 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13167 {
13168 /* sign_bit_p looks through both zero and sign extensions,
13169 but for this optimization only sign extensions are
13170 usable. */
13173 {
13176 {
13179 }
13181 }
13182 /* sign_bit_p only checks ARG1 bits within A's precision.
13183 If <sign bit of A> has wider type than A, bits outside
13184 of A's precision in <sign bit of A> need to be checked.
13185 If they are all 0, this optimization needs to be done
13186 in unsigned A's type, if they are all 1 in signed A's type,
13187 otherwise this can't be done. */
13193 {
13195 tree tem_type;
13208 {
13211 }
13213 {
13216 }
13217 else
13219 }
13222 return
13228 arg1)));
13229 }
13231 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13232 already handled above. */
13237 {
13247 op1);
13248 }
13250 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13251 is probably obsolete because the first operand should be a
13252 truth value (that's why we have the two cases above), but let's
13253 leave it in until we can confirm this for all front-ends. */
13261 /* operand_equal_p compares just value, not precision, so e.g.
13262 arg1 could be 8-bit -128 and be power of two, but BIT_AND_EXPR
13263 second operand 32-bit -128, which is not a power of two (or vice
13264 versa. */
13268 /* Disable the transformations below for vectors, since
13269 fold_binary_op_with_conditional_arg may undo them immediately,
13270 yielding an infinite loop. */
13274 /* Convert A ? B : 0 into A && B if A and B are truth values. */
13283 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
13288 {
13290 /* Only perform transformation if ARG0 is easily inverted. */
13294 ? BIT_IOR_EXPR
13297 op1);
13298 }
13300 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
13305 {
13307 /* Only perform transformation if ARG0 is easily inverted. */
13313 op2);
13314 }
13316 /* Convert A ? 1 : B into A || B if A and B are truth values. */
13328 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
13329 of fold_ternary on them. */
13339 {
13341 unsigned HOST_WIDE_INT width
13352 {
13357 {
13359 {
13364 }
13370 }
13371 }
13372 }
13374 /* On constants we can use native encode/interpret to constant
13375 fold (nearly) all BIT_FIELD_REFs. */
13381 {
13384 /* Limit us to a reasonable amount of work. To relax the
13385 other limitations we need bit-shifting of the buffer
13386 and rounding up the size. */
13390 {
13392 unsigned HOST_WIDE_INT len
13397 {
13402 }
13403 }
13404 }
13409 /* Perform constant folding of BIT_INSERT_EXPR. */
13413 {
13414 /* Build a vector of integers from the tree mask. */
13415 vec_perm_builder builder;
13419 /* Create a vec_perm_indices for the integer vector. */
13424 }
13428 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
13431 {
13437 wide_int tem2
13441 }
13446 {
13448 unsigned HOST_WIDE_INT elsize
13451 {
13457 {
13463 }
13464 }
13465 }
13471 }
13473 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
13474 of an array (or vector). *CTOR_IDX if non-NULL is updated with the
13475 constructor element index of the value returned. If the element is
13476 not found NULL_TREE is returned and *CTOR_IDX is updated to
13477 the index of the element after the ACCESS_INDEX position (which
13478 may be outside of the CTOR array). */
13480 tree
13483 {
13489 {
13492 {
13493 /* Static constructors for variably sized objects makes no sense. */
13496 /* ??? When it is obvious that the range is signed, treat it so. */
13501 {
13503 low_bound
13505 SIGNED);
13506 }
13507 else
13508 {
13511 }
13512 }
13513 }
13517 index_sgn);
13529 {
13530 /* Array constructor might explicitly set index, or specify a range,
13531 or leave index NULL meaning that it is next index after previous
13532 one. */
13534 {
13536 max_index = index
13538 else
13539 {
13542 index_sgn);
13543 max_index
13545 index_sgn);
13547 }
13548 }
13550 {
13556 }
13557 else
13560 /* Do we have match? */
13562 {
13564 {
13568 }
13569 }
13571 /* We're past the element we search for. Note during parsing
13572 the elements might not be sorted.
13573 ??? We should use a binary search and a flag on the
13574 CONSTRUCTOR as to whether elements are sorted in declaration
13575 order. */
13577 }
13581 }
13583 /* Perform constant folding and related simplification of EXPR.
13584 The related simplifications include x*1 => x, x*0 => 0, etc.,
13585 and application of the associative law.
13586 NOP_EXPR conversions may be removed freely (as long as we
13587 are careful not to change the type of the overall expression).
13588 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
13589 but we can constant-fold them if they have constant operands. */
13591 #ifdef ENABLE_FOLD_CHECKING
13592 # define fold(x) fold_1 (x)
13594 static
13595 #endif
13596 tree
13598 {
13602 tree tem;
13605 /* Return right away if a constant. */
13609 /* CALL_EXPR-like objects with variable numbers of operands are
13610 treated specially. */
13612 {
13614 {
13617 }
13619 }
13622 {
13627 {
13645 }
13646 }
13649 {
13651 {
13658 {
13663 }
13666 }
13668 /* Return a VECTOR_CST if possible. */
13670 {
13676 tree val;
13682 }
13690 }
13692 #ifdef ENABLE_FOLD_CHECKING
13693 #undef fold
13700 /* When --enable-checking=fold, compute a digest of expr before
13701 and after actual fold call to see if fold did not accidentally
13702 change original expr. */
13704 tree
13706 {
13707 tree ret;
13727 }
13729 void
13731 {
13742 }
13744 static void
13746 {
13748 }
13750 static void
13753 {
13759 recursive_label:
13769 {
13770 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
13778 }
13786 {
13787 /* Allow these fields to be modified. */
13788 tree tmp;
13799 {
13802 }
13803 }
13805 {
13806 /* Allow the no-warning bit to be set. Perhaps we shouldn't allow
13807 that and change builtins.cc etc. instead - see PR89543. */
13813 }
13824 {
13827 {
13843 }
13847 {
13860 }
13877 {
13883 }
13886 {
13888 {
13891 }
13893 }
13904 {
13907 }
13915 }
13916 }
13918 /* Helper function for outputting the checksum of a tree T. When
13919 debugging with gdb, you can "define mynext" to be "next" followed
13920 by "call debug_fold_checksum (op0)", then just trace down till the
13921 outputs differ. */
13923 DEBUG_FUNCTION void
13925 {
13940 }
13942 #endif
13944 /* Fold a unary tree expression with code CODE of type TYPE with an
13945 operand OP0. LOC is the location of the resulting expression.
13946 Return a folded expression if successful. Otherwise, return a tree
13947 expression with code CODE of type TYPE with an operand OP0. */
13949 tree
13952 {
13953 tree tem;
13954 #ifdef ENABLE_FOLD_CHECKING
13963 #endif
13969 #ifdef ENABLE_FOLD_CHECKING
13976 #endif
13978 }
13980 /* Fold a binary tree expression with code CODE of type TYPE with
13981 operands OP0 and OP1. LOC is the location of the resulting
13982 expression. Return a folded expression if successful. Otherwise,
13983 return a tree expression with code CODE of type TYPE with operands
13984 OP0 and OP1. */
13986 tree
13989 MEM_STAT_DECL)
13990 {
13991 tree tem;
13992 #ifdef ENABLE_FOLD_CHECKING
14009 #endif
14015 #ifdef ENABLE_FOLD_CHECKING
14030 #endif
14032 }
14034 /* Fold a ternary tree expression with code CODE of type TYPE with
14035 operands OP0, OP1, and OP2. Return a folded expression if
14036 successful. Otherwise, return a tree expression with code CODE of
14037 type TYPE with operands OP0, OP1, and OP2. */
14039 tree
14042 {
14043 tree tem;
14044 #ifdef ENABLE_FOLD_CHECKING
14068 #endif
14075 #ifdef ENABLE_FOLD_CHECKING
14098 #endif
14100 }
14102 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14103 arguments in ARGARRAY, and a null static chain.
14104 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14105 of type TYPE from the given operands as constructed by build_call_array. */
14107 tree
14110 {
14111 tree tem;
14112 #ifdef ENABLE_FOLD_CHECKING
14131 #endif
14137 #ifdef ENABLE_FOLD_CHECKING
14153 #endif
14155 }
14157 /* Perform constant folding and related simplification of initializer
14158 expression EXPR. These behave identically to "fold_buildN" but ignore
14159 potential run-time traps and exceptions that fold must preserve. */
14161 #define START_FOLD_INIT \
14162 int saved_signaling_nans = flag_signaling_nans;\
14163 int saved_trapping_math = flag_trapping_math;\
14164 int saved_rounding_math = flag_rounding_math;\
14165 int saved_trapv = flag_trapv;\
14166 int saved_folding_initializer = folding_initializer;\
14167 flag_signaling_nans = 0;\
14168 flag_trapping_math = 0;\
14169 flag_rounding_math = 0;\
14170 flag_trapv = 0;\
14171 folding_initializer = 1;
14173 #define END_FOLD_INIT \
14174 flag_signaling_nans = saved_signaling_nans;\
14175 flag_trapping_math = saved_trapping_math;\
14176 flag_rounding_math = saved_rounding_math;\
14177 flag_trapv = saved_trapv;\
14178 folding_initializer = saved_folding_initializer;
14180 tree
14182 {
14183 tree result;
14184 START_FOLD_INIT;
14188 END_FOLD_INIT;
14190 }
14192 tree
14195 {
14196 tree result;
14197 START_FOLD_INIT;
14201 END_FOLD_INIT;
14203 }
14205 tree
14208 {
14209 tree result;
14210 START_FOLD_INIT;
14214 END_FOLD_INIT;
14216 }
14218 tree
14221 {
14222 tree result;
14223 START_FOLD_INIT;
14227 END_FOLD_INIT;
14229 }
14231 tree
14234 {
14235 tree result;
14236 START_FOLD_INIT;
14240 END_FOLD_INIT;
14242 }
14244 #undef START_FOLD_INIT
14245 #undef END_FOLD_INIT
14247 /* Determine if first argument is a multiple of second argument. Return
14248 false if it is not, or we cannot easily determined it to be.
14250 An example of the sort of thing we care about (at this point; this routine
14251 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14252 fold cases do now) is discovering that
14254 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14256 is a multiple of
14258 SAVE_EXPR (J * 8)
14260 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14262 This code also handles discovering that
14264 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14266 is a multiple of 8 so we don't have to worry about dealing with a
14267 possible remainder.
14269 Note that we *look* inside a SAVE_EXPR only to determine how it was
14270 calculated; it is not safe for fold to do much of anything else with the
14271 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14272 at run time. For example, the latter example above *cannot* be implemented
14273 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14274 evaluation time of the original SAVE_EXPR is not necessarily the same at
14275 the time the new expression is evaluated. The only optimization of this
14276 sort that would be valid is changing
14278 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14280 divided by 8 to
14282 SAVE_EXPR (I) * SAVE_EXPR (J)
14284 (where the same SAVE_EXPR (J) is used in the original and the
14285 transformed version).
14287 NOWRAP specifies whether all outer operations in TYPE should
14288 be considered not wrapping. Any type conversion within TOP acts
14289 as a barrier and we will fall back to NOWRAP being false.
14290 NOWRAP is mostly used to treat expressions in TYPE_SIZE and friends
14291 as not wrapping even though they are generally using unsigned arithmetic. */
14293 bool
14295 {
14306 {
14308 /* Bitwise and provides a power of two multiple. If the mask is
14309 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
14316 /* If the multiplication can wrap we cannot recurse further unless
14317 the bottom is a power of two which is where wrapping does not
14318 matter. */
14324 {
14330 {
14333 /* Handle multiple_of_p ((x * 2 + 2) * 4, 8). */
14335 {
14339 {
14342 }
14343 }
14345 }
14346 }
14351 /* Handle X << CST as X * (1 << CST) and only process the constant. */
14353 {
14356 {
14357 wide_int mul_op
14361 nowrap);
14362 }
14363 }
14368 /* If the addition or subtraction can wrap we cannot recurse further
14369 unless bottom is a power of two which is where wrapping does not
14370 matter. */
14376 /* Handle cases like op0 + 0xfffffffd as op0 - 3 if the expression has
14377 unsigned type. For example, (X / 3) + 0xfffffffd is multiple of 3,
14378 but 0xfffffffd is not. */
14381 && nowrap
14386 /* It is impossible to prove if op0 +- op1 is multiple of bottom
14387 precisely, so be conservative here checking if both op0 and op1
14388 are multiple of bottom. Note we check the second operand first
14389 since it's usually simpler. */
14393 CASE_CONVERT:
14394 /* Can't handle conversions from non-integral or wider integral type. */
14399 /* NOWRAP only extends to operations in the outermost type so
14400 make sure to strip it off here. */
14415 SIGNED);
14421 {
14424 /* Check for special cases to see if top is defined as multiple
14425 of bottom:
14427 top = (X & ~(bottom - 1) ; bottom is power of 2
14429 or
14431 Y = X % bottom
14432 top = X - Y. */
14451 }
14453 /* fall through */
14461 }
14462 }
14464 /* Return true if expression X cannot be (or contain) a NaN or infinity.
14465 This function returns true for integer expressions, and returns
14466 false if uncertain. */
14468 bool
14470 {
14475 {
14498 {
14499 CASE_CFN_FABS:
14500 CASE_CFN_FABS_FN:
14502 CASE_CFN_FMAX:
14503 CASE_CFN_FMAX_FN:
14504 CASE_CFN_FMIN:
14505 CASE_CFN_FMIN_FN:
14510 }
14514 }
14515 }
14517 /* Return true if expression X evaluates to an infinity.
14518 This function returns false for integer expressions. */
14520 bool
14522 {
14526 {
14539 }
14540 }
14542 /* Return true if expression X could evaluate to an infinity.
14543 This function returns false for integer expressions, and returns
14544 true if uncertain. */
14546 bool
14548 {
14552 {
14565 }
14566 }
14568 /* Return true if expression X evaluates to a signaling NaN.
14569 This function returns false for integer expressions. */
14571 bool
14573 {
14577 {
14588 }
14589 }
14591 /* Return true if expression X could evaluate to a signaling NaN.
14592 This function returns false for integer expressions, and returns
14593 true if uncertain. */
14595 bool
14597 {
14601 {
14621 {
14622 CASE_CFN_FABS:
14623 CASE_CFN_FABS_FN:
14625 CASE_CFN_FMAX:
14626 CASE_CFN_FMAX_FN:
14627 CASE_CFN_FMIN:
14628 CASE_CFN_FMIN_FN:
14633 }
14636 }
14637 }
14639 /* Return true if expression X evaluates to a NaN.
14640 This function returns false for integer expressions. */
14642 bool
14644 {
14648 {
14659 }
14660 }
14662 /* Return true if expression X could evaluate to a NaN.
14663 This function returns false for integer expressions, and returns
14664 true if uncertain. */
14666 bool
14668 {
14672 {
14697 {
14698 CASE_CFN_FABS:
14699 CASE_CFN_FABS_FN:
14701 CASE_CFN_FMAX:
14702 CASE_CFN_FMAX_FN:
14703 CASE_CFN_FMIN:
14704 CASE_CFN_FMIN_FN:
14709 }
14712 }
14713 }
14715 /* Return true if expression X could evaluate to -0.0.
14716 This function returns true if uncertain. */
14718 bool
14720 {
14724 {
14739 {
14740 CASE_CFN_FABS:
14741 CASE_CFN_FABS_FN:
14745 }
14748 }
14749 /* Ideally !(tree_expr_nonzero_p (X) || tree_expr_nonnegative_p (X))
14750 * but currently those predicates require tree and not const_tree. */
14752 }
14754 #define tree_expr_nonnegative_warnv_p(X, Y) \
14757 #define RECURSE(X) \
14758 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
14760 /* Return true if CODE or TYPE is known to be non-negative. */
14762 static bool
14764 {
14768 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14769 have a signed:1 type (where the value is -1 and 0). */
14772 }
14774 /* Return true if (CODE OP0) is known to be non-negative. If the return
14775 value is based on the assumption that signed overflow is undefined,
14776 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14777 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
14779 bool
14782 {
14787 {
14789 /* We can't return 1 if flag_wrapv is set because
14790 ABS_EXPR<INT_MIN> = INT_MIN. */
14794 {
14797 }
14805 CASE_CONVERT:
14806 {
14811 {
14815 {
14819 }
14820 }
14822 {
14828 }
14829 }
14834 }
14836 /* We don't know sign of `t', so be conservative and return false. */
14838 }
14840 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
14841 value is based on the assumption that signed overflow is undefined,
14842 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14843 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
14845 bool
14849 {
14854 {
14860 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14861 both unsigned and at least 2 bits shorter than the result. */
14865 {
14870 {
14874 }
14875 }
14880 {
14881 /* x * x is always non-negative for floating point x
14882 or without overflow. */
14885 {
14890 }
14891 }
14893 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14894 both unsigned and their total bits is shorter than the result. */
14898 {
14917 {
14927 }
14928 }
14935 /* Usually RECURSE (op0) || RECURSE (op1) but NaNs complicate
14936 things. */
14961 }
14963 /* We don't know sign of `t', so be conservative and return false. */
14965 }
14967 /* Return true if T is known to be non-negative. If the return
14968 value is based on the assumption that signed overflow is undefined,
14969 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14970 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
14972 bool
14974 {
14979 {
14993 /* Limit the depth of recursion to avoid quadratic behavior.
14994 This is expected to catch almost all occurrences in practice.
14995 If this code misses important cases that unbounded recursion
14996 would not, passes that need this information could be revised
14997 to provide it through dataflow propagation. */
15005 }
15006 }
15008 /* Return true if T is known to be non-negative. If the return
15009 value is based on the assumption that signed overflow is undefined,
15010 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15011 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
15013 bool
15016 {
15018 {
15019 CASE_CFN_ACOS:
15020 CASE_CFN_ACOS_FN:
15021 CASE_CFN_ACOSH:
15022 CASE_CFN_ACOSH_FN:
15023 CASE_CFN_CABS:
15024 CASE_CFN_CABS_FN:
15025 CASE_CFN_COSH:
15026 CASE_CFN_COSH_FN:
15027 CASE_CFN_ERFC:
15028 CASE_CFN_ERFC_FN:
15029 CASE_CFN_EXP:
15030 CASE_CFN_EXP_FN:
15031 CASE_CFN_EXP10:
15032 CASE_CFN_EXP2:
15033 CASE_CFN_EXP2_FN:
15034 CASE_CFN_FABS:
15035 CASE_CFN_FABS_FN:
15036 CASE_CFN_FDIM:
15037 CASE_CFN_FDIM_FN:
15038 CASE_CFN_HYPOT:
15039 CASE_CFN_HYPOT_FN:
15040 CASE_CFN_POW10:
15041 CASE_CFN_FFS:
15042 CASE_CFN_PARITY:
15043 CASE_CFN_POPCOUNT:
15044 CASE_CFN_CLZ:
15045 CASE_CFN_CLRSB:
15050 /* Always true. */
15053 CASE_CFN_SQRT:
15054 CASE_CFN_SQRT_FN:
15055 /* sqrt(-0.0) is -0.0. */
15060 CASE_CFN_ASINH:
15061 CASE_CFN_ASINH_FN:
15062 CASE_CFN_ATAN:
15063 CASE_CFN_ATAN_FN:
15064 CASE_CFN_ATANH:
15065 CASE_CFN_ATANH_FN:
15066 CASE_CFN_CBRT:
15067 CASE_CFN_CBRT_FN:
15068 CASE_CFN_CEIL:
15069 CASE_CFN_CEIL_FN:
15070 CASE_CFN_ERF:
15071 CASE_CFN_ERF_FN:
15072 CASE_CFN_EXPM1:
15073 CASE_CFN_EXPM1_FN:
15074 CASE_CFN_FLOOR:
15075 CASE_CFN_FLOOR_FN:
15076 CASE_CFN_FMOD:
15077 CASE_CFN_FMOD_FN:
15078 CASE_CFN_FREXP:
15079 CASE_CFN_FREXP_FN:
15080 CASE_CFN_ICEIL:
15081 CASE_CFN_IFLOOR:
15082 CASE_CFN_IRINT:
15083 CASE_CFN_IROUND:
15084 CASE_CFN_LCEIL:
15085 CASE_CFN_LDEXP:
15086 CASE_CFN_LFLOOR:
15087 CASE_CFN_LLCEIL:
15088 CASE_CFN_LLFLOOR:
15089 CASE_CFN_LLRINT:
15090 CASE_CFN_LLRINT_FN:
15091 CASE_CFN_LLROUND:
15092 CASE_CFN_LLROUND_FN:
15093 CASE_CFN_LRINT:
15094 CASE_CFN_LRINT_FN:
15095 CASE_CFN_LROUND:
15096 CASE_CFN_LROUND_FN:
15097 CASE_CFN_MODF:
15098 CASE_CFN_MODF_FN:
15099 CASE_CFN_NEARBYINT:
15100 CASE_CFN_NEARBYINT_FN:
15101 CASE_CFN_RINT:
15102 CASE_CFN_RINT_FN:
15103 CASE_CFN_ROUND:
15104 CASE_CFN_ROUND_FN:
15105 CASE_CFN_ROUNDEVEN:
15106 CASE_CFN_ROUNDEVEN_FN:
15107 CASE_CFN_SCALB:
15108 CASE_CFN_SCALBLN:
15109 CASE_CFN_SCALBLN_FN:
15110 CASE_CFN_SCALBN:
15111 CASE_CFN_SCALBN_FN:
15112 CASE_CFN_SIGNBIT:
15113 CASE_CFN_SIGNIFICAND:
15114 CASE_CFN_SINH:
15115 CASE_CFN_SINH_FN:
15116 CASE_CFN_TANH:
15117 CASE_CFN_TANH_FN:
15118 CASE_CFN_TRUNC:
15119 CASE_CFN_TRUNC_FN:
15120 /* True if the 1st argument is nonnegative. */
15123 CASE_CFN_FMAX:
15124 CASE_CFN_FMAX_FN:
15125 /* Usually RECURSE (arg0) || RECURSE (arg1) but NaNs complicate
15126 things. In the presence of sNaNs, we're only guaranteed to be
15127 non-negative if both operands are non-negative. In the presence
15128 of qNaNs, we're non-negative if either operand is non-negative
15129 and can't be a qNaN, or if both operands are non-negative. */
15138 CASE_CFN_FMIN:
15139 CASE_CFN_FMIN_FN:
15140 /* True if the 1st AND 2nd arguments are nonnegative. */
15143 CASE_CFN_COPYSIGN:
15144 CASE_CFN_COPYSIGN_FN:
15145 /* True if the 2nd argument is nonnegative. */
15148 CASE_CFN_POWI:
15149 /* True if the 1st argument is nonnegative or the second
15150 argument is an even integer. */
15156 CASE_CFN_POW:
15157 CASE_CFN_POW_FN:
15158 /* True if the 1st argument is nonnegative or the second
15159 argument is an even integer valued real. */
15161 {
15162 REAL_VALUE_TYPE c;
15163 HOST_WIDE_INT n;
15168 {
15169 REAL_VALUE_TYPE cint;
15173 }
15174 }
15179 }
15181 }
15183 /* Return true if T is known to be non-negative. If the return
15184 value is based on the assumption that signed overflow is undefined,
15185 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15186 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
15188 static bool
15190 {
15196 {
15198 {
15202 /* If the initializer is non-void, then it's a normal expression
15203 that will be assigned to the slot. */
15207 /* Otherwise, the initializer sets the slot in some way. One common
15208 way is an assignment statement at the end of the initializer. */
15210 {
15218 else
15220 }
15226 }
15229 {
15235 arg0,
15236 arg1,
15238 }
15251 }
15252 }
15254 #undef RECURSE
15255 #undef tree_expr_nonnegative_warnv_p
15257 /* Return true if T is known to be non-negative. If the return
15258 value is based on the assumption that signed overflow is undefined,
15259 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15260 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
15262 bool
15264 {
15271 {
15293 }
15296 {
15321 }
15322 }
15324 /* Return true if `t' is known to be non-negative. Handle warnings
15325 about undefined signed overflow. */
15327 bool
15329 {
15336 "determining that expression is always "
15338 WARN_STRICT_OVERFLOW_MISC);
15340 }
15343 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15344 For floating point we further ensure that T is not denormal.
15345 Similar logic is present in nonzero_address in rtlanal.h.
15347 If the return value is based on the assumption that signed overflow
15348 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15349 change *STRICT_OVERFLOW_P. */
15351 bool
15354 {
15356 {
15359 strict_overflow_p);
15362 {
15368 strict_overflow_p));
15369 }
15374 strict_overflow_p);
15378 }
15381 }
15383 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15384 For floating point we further ensure that T is not denormal.
15385 Similar logic is present in nonzero_address in rtlanal.h.
15387 If the return value is based on the assumption that signed overflow
15388 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15389 change *STRICT_OVERFLOW_P. */
15391 bool
15393 tree type,
15394 tree op0,
15396 {
15399 {
15403 {
15404 /* With the presence of negative values it is hard
15405 to say something. */
15412 /* One of operands must be positive and the other non-negative. */
15413 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15414 overflows, on a twos-complement machine the sum of two
15415 nonnegative numbers can never be zero. */
15417 strict_overflow_p)
15419 strict_overflow_p));
15420 }
15425 {
15427 strict_overflow_p)
15429 strict_overflow_p))
15430 {
15433 }
15434 }
15443 {
15446 }
15453 {
15457 /* When both operands are nonzero, then MAX must be too. */
15459 strict_overflow_p))
15462 /* MAX where operand 0 is positive is positive. */
15464 strict_overflow_p);
15465 }
15466 /* MAX where operand 1 is positive is positive. */
15471 {
15475 }
15480 strict_overflow_p)
15482 strict_overflow_p));
15486 }
15489 }
15491 /* Return true when T is an address and is known to be nonzero.
15492 For floating point we further ensure that T is not denormal.
15493 Similar logic is present in nonzero_address in rtlanal.h.
15495 If the return value is based on the assumption that signed overflow
15496 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15497 change *STRICT_OVERFLOW_P. */
15499 bool
15501 {
15504 {
15509 {
15521 /* For objects in symbol table check if we know they are non-zero.
15522 Don't do anything for variables and functions before symtab is built;
15523 it is quite possible that they will be declared weak later. */
15528 /* Constants are never weak. */
15533 }
15541 {
15545 }
15555 }
15557 }
15559 #define integer_valued_real_p(X) \
15562 #define RECURSE(X) \
15563 ((integer_valued_real_p) (X, depth + 1))
15565 /* Return true if the floating point result of (CODE OP0) has an
15566 integer value. We also allow +Inf, -Inf and NaN to be considered
15567 integer values. Return false for signaling NaN.
15569 DEPTH is the current nesting depth of the query. */
15571 bool
15573 {
15575 {
15582 CASE_CONVERT:
15583 {
15590 }
15594 }
15596 }
15598 /* Return true if the floating point result of (CODE OP0 OP1) has an
15599 integer value. We also allow +Inf, -Inf and NaN to be considered
15600 integer values. Return false for signaling NaN.
15602 DEPTH is the current nesting depth of the query. */
15604 bool
15606 {
15608 {
15618 }
15620 }
15622 /* Return true if the floating point result of calling FNDECL with arguments
15623 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
15624 considered integer values. Return false for signaling NaN. If FNDECL
15625 takes fewer than 2 arguments, the remaining ARGn are null.
15627 DEPTH is the current nesting depth of the query. */
15629 bool
15631 {
15633 {
15634 CASE_CFN_CEIL:
15635 CASE_CFN_CEIL_FN:
15636 CASE_CFN_FLOOR:
15637 CASE_CFN_FLOOR_FN:
15638 CASE_CFN_NEARBYINT:
15639 CASE_CFN_NEARBYINT_FN:
15640 CASE_CFN_RINT:
15641 CASE_CFN_RINT_FN:
15642 CASE_CFN_ROUND:
15643 CASE_CFN_ROUND_FN:
15644 CASE_CFN_ROUNDEVEN:
15645 CASE_CFN_ROUNDEVEN_FN:
15646 CASE_CFN_TRUNC:
15647 CASE_CFN_TRUNC_FN:
15650 CASE_CFN_FMIN:
15651 CASE_CFN_FMIN_FN:
15652 CASE_CFN_FMAX:
15653 CASE_CFN_FMAX_FN:
15658 }
15660 }
15662 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
15663 has an integer value. We also allow +Inf, -Inf and NaN to be
15664 considered integer values. Return false for signaling NaN.
15666 DEPTH is the current nesting depth of the query. */
15668 bool
15670 {
15672 {
15680 /* Limit the depth of recursion to avoid quadratic behavior.
15681 This is expected to catch almost all occurrences in practice.
15682 If this code misses important cases that unbounded recursion
15683 would not, passes that need this information could be revised
15684 to provide it through dataflow propagation. */
15688 depth));
15692 }
15694 }
15696 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
15697 has an integer value. We also allow +Inf, -Inf and NaN to be
15698 considered integer values. Return false for signaling NaN.
15700 DEPTH is the current nesting depth of the query. */
15702 static bool
15704 {
15706 {
15717 }
15719 }
15721 #undef RECURSE
15722 #undef integer_valued_real_p
15724 /* Return true if the floating point expression T has an integer value.
15725 We also allow +Inf, -Inf and NaN to be considered integer values.
15726 Return false for signaling NaN.
15728 DEPTH is the current nesting depth of the query. */
15730 bool
15732 {
15740 {
15756 }
15759 {
15765 {
15774 }
15778 }
15779 }
15781 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15782 attempt to fold the expression to a constant without modifying TYPE,
15783 OP0 or OP1.
15785 If the expression could be simplified to a constant, then return
15786 the constant. If the expression would not be simplified to a
15787 constant, then return NULL_TREE. */
15789 tree
15791 {
15794 }
15796 /* Given the components of a unary expression CODE, TYPE and OP0,
15797 attempt to fold the expression to a constant without modifying
15798 TYPE or OP0.
15800 If the expression could be simplified to a constant, then return
15801 the constant. If the expression would not be simplified to a
15802 constant, then return NULL_TREE. */
15804 tree
15806 {
15809 }
15811 /* If EXP represents referencing an element in a constant string
15812 (either via pointer arithmetic or array indexing), return the
15813 tree representing the value accessed, otherwise return NULL. */
15815 tree
15817 {
15821 {
15823 tree index;
15824 tree string;
15829 else
15830 {
15834 /* Optimize the special-case of a zero lower bound.
15836 We convert the low_bound to sizetype to avoid some problems
15837 with constant folding. (E.g. suppose the lower bound is 1,
15838 and its mode is QI. Without the conversion,l (ARRAY
15839 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15840 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15846 }
15848 scalar_int_mode char_mode;
15860 }
15862 }
15864 /* Folds a read from vector element at IDX of vector ARG. */
15866 tree
15868 {
15873 {
15877 {
15884 }
15885 }
15887 }
15889 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15890 an integer constant, real, or fixed-point constant.
15892 TYPE is the type of the result. */
15894 static tree
15896 {
15900 {
15906 {
15907 FIXED_VALUE_TYPE f;
15912 /* Propagate overflow flags. */
15916 }
15920 {
15927 }
15930 }
15933 }
15935 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15936 an integer constant or real constant.
15938 TYPE is the type of the result. */
15940 tree
15942 {
15946 {
15948 {
15949 /* If the value is unsigned or non-negative, then the absolute value
15950 is the same as the ordinary value. */
15954 ;
15956 /* If the value is negative, then the absolute value is
15957 its negation. */
15958 else
15961 /* Force to the destination type, set TREE_OVERFLOW for signed
15962 TYPE only. */
15964 }
15970 else
15976 }
15979 }
15981 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15982 constant. TYPE is the type of the result. */
15984 static tree
15986 {
15990 }
15992 /* Given CODE, a relational operator, the target type, TYPE and two
15993 constant operands OP0 and OP1, return the result of the
15994 relational operation. If the result is not a compile time
15995 constant, then return NULL_TREE. */
15997 static tree
15999 {
16002 /* From here on, the only cases we handle are when the result is
16003 known to be a constant. */
16006 {
16010 /* Handle the cases where either operand is a NaN. */
16012 {
16014 {
16042 }
16045 }
16048 }
16051 {
16055 }
16057 /* Handle equality/inequality of complex constants. */
16059 {
16070 else
16072 }
16075 {
16077 {
16078 /* Have vector comparison with scalar boolean result. */
16086 {
16094 }
16096 }
16097 tree_vector_builder elts;
16102 {
16115 }
16118 }
16120 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16122 To compute GT, swap the arguments and do LT.
16123 To compute GE, do LT and invert the result.
16124 To compute LE, swap the arguments, do LT and invert the result.
16125 To compute NE, do EQ and invert the result.
16127 Therefore, the code below must handle only EQ and LT. */
16130 {
16133 }
16135 /* Note that it is safe to invert for real values here because we
16136 have already handled the one case that it matters. */
16140 {
16143 }
16145 /* Compute a result for LT or EQ if args permit;
16146 Otherwise return T. */
16148 {
16151 else
16153 }
16154 else
16160 }
16162 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16163 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16164 itself. */
16166 tree
16168 {
16169 /* If the expression does not have side effects then we don't have to wrap
16170 it with a cleanup point expression. */
16174 /* If the expression is a return, check to see if the expression inside the
16175 return has no side effects or the right hand side of the modify expression
16176 inside the return. If either don't have side effects set we don't need to
16177 wrap the expression in a cleanup point expression. Note we don't check the
16178 left hand side of the modify because it should always be a return decl. */
16180 {
16187 }
16190 }
16192 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16193 of an indirection through OP0, or NULL_TREE if no simplification is
16194 possible. */
16196 tree
16198 {
16200 tree subtype;
16201 poly_uint64 const_op01;
16210 {
16214 /* *&CONST_DECL -> to the value of the const decl. */
16217 /* *&p => p; make sure to handle *&"str"[cst] here. */
16219 {
16223 else
16225 }
16226 /* *(foo *)&fooarray => fooarray[0] */
16229 && (!in_gimple_form
16231 {
16241 }
16242 /* *(foo *)&complexfoo => __real__ complexfoo */
16246 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16249 {
16253 index);
16254 }
16255 }
16259 {
16265 {
16266 tree op00type;
16270 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16273 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
16274 but we want to treat offsets with MSB set as negative.
16275 For the code below negative offsets are invalid and
16276 TYPE_SIZE of the element is something unsigned, so
16277 check whether op01 fits into poly_int64, which implies
16278 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
16279 then just use poly_uint64 because we want to treat the
16280 value as unsigned. */
16282 {
16284 poly_uint64 max_offset
16288 {
16293 }
16294 }
16295 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16298 {
16300 const_op01))
16302 }
16303 /* ((foo *)&fooarray)[1] => fooarray[1] */
16306 {
16315 {
16320 }
16321 }
16322 }
16323 }
16325 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16328 && (!in_gimple_form
16330 {
16331 tree type_domain;
16341 NULL_TREE);
16342 }
16345 }
16347 /* Builds an expression for an indirection through T, simplifying some
16348 cases. */
16350 tree
16352 {
16360 }
16362 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16364 tree
16366 {
16371 else
16373 }
16375 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16376 whose result is ignored. The type of the returned tree need not be
16377 the same as the original expression. */
16379 tree
16381 {
16387 {
16398 else
16404 {
16420 }
16425 }
16426 }
16428 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16430 tree
16432 {
16438 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16439 have to do anything. Only do this when we are not given a const,
16440 because in that case, this check is more expensive than just
16441 doing it. */
16443 {
16448 }
16450 /* If divisor is a power of two, simplify this to bit manipulation. */
16452 {
16454 {
16468 }
16469 else
16470 {
16471 tree t;
16477 }
16478 }
16479 else
16480 {
16485 }
16488 }
16490 /* Likewise, but round down. */
16492 tree
16494 {
16501 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16502 have to do anything. Only do this when we are not given a const,
16503 because in that case, this check is more expensive than just
16504 doing it. */
16506 {
16511 }
16513 /* If divisor is a power of two, simplify this to bit manipulation. */
16515 {
16516 tree t;
16520 }
16521 else
16522 {
16527 }
16530 }
16532 /* Returns the pointer to the base of the object addressed by EXP and
16533 extracts the information about the offset of the access, storing it
16534 to PBITPOS and POFFSET. */
16536 static tree
16539 {
16540 tree core;
16541 machine_mode mode;
16543 poly_int64 bitsize;
16552 {
16557 }
16559 {
16565 {
16566 poly_offset_int tem
16572 }
16573 }
16574 else
16575 {
16579 }
16582 }
16584 /* Returns true if addresses of E1 and E2 differ by a constant, false
16585 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16587 bool
16589 {
16604 {
16614 }
16616 {
16617 /* If only one of the offsets is non-constant, the difference cannot
16618 be a constant. */
16620 }
16621 else
16626 }
16628 /* Return OFF converted to a pointer offset type suitable as offset for
16629 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
16630 tree
16632 {
16636 }
16638 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
16639 tree
16641 {
16644 }
16646 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
16647 tree
16649 {
16652 }
16654 /* Return a pointer to a NUL-terminated string containing the sequence
16655 of bytes corresponding to the representation of the object referred to
16656 by SRC (or a subsequence of such bytes within it if SRC is a reference
16657 to an initialized constant array plus some constant offset).
16658 Set *STRSIZE the number of bytes in the constant sequence including
16659 the terminating NUL byte. *STRSIZE is equal to sizeof(A) - OFFSET
16660 where A is the array that stores the constant sequence that SRC points
16661 to and OFFSET is the byte offset of SRC from the beginning of A. SRC
16662 need not point to a string or even an array of characters but may point
16663 to an object of any type. */
16667 {
16668 /* The offset into the array A storing the string, and A's byte size. */
16669 tree offset_node;
16670 tree mem_size;
16677 else
16684 {
16687 else
16689 }
16694 /* ARRAY_SIZE is the byte size of the array the constant sequence
16695 is stored in and equal to sizeof A. INIT_BYTES is the number
16696 of bytes in the constant sequence used to initialize the array,
16697 including any embedded NULs as well as the terminating NUL (for
16698 strings), but not including any trailing zeros/NULs past
16699 the terminating one appended implicitly to a string literal to
16700 zero out the remainder of the array it's stored in. For example,
16701 given:
16702 const char a[7] = "abc\0d";
16703 n = strlen (a + 1);
16704 ARRAY_SIZE is 7, INIT_BYTES is 6, and OFFSET is 1. For a valid
16705 (i.e., nul-terminated) string with no embedded nuls, INIT_BYTES
16706 is equal to strlen (A) + 1. */
16711 /* Ideally this would turn into a gcc_checking_assert over time. */
16719 {
16720 /* Compute and store the number of characters from the beginning
16721 of the substring at OFFSET to the end, including the terminating
16722 nul. Offsets past the initial length refer to null strings. */
16725 else
16727 }
16728 else
16729 {
16731 /* Support only properly NUL-terminated single byte strings. */
16736 }
16739 }
16741 /* Return a pointer to a NUL-terminated string corresponding to
16742 the expression STR referencing a constant string, possibly
16743 involving a constant offset. Return null if STR either doesn't
16744 reference a constant string or if it involves a nonconstant
16745 offset. */
16749 {
16751 }
16753 /* Given a tree T, compute which bits in T may be nonzero. */
16755 wide_int
16757 {
16759 {
16777 CASE_CONVERT:
16783 {
16788 }
16792 {
16800 }
16804 {
16812 }
16816 }
16819 }
16821 /* Helper function for address compare simplifications in match.pd.
16822 OP0 and OP1 are ADDR_EXPR operands being compared by CODE.
16823 TYPE is the type of comparison operands.
16824 BASE0, BASE1, OFF0 and OFF1 are set by the function.
16825 GENERIC is true if GENERIC folding and false for GIMPLE folding.
16826 Returns 0 if OP0 is known to be unequal to OP1 regardless of OFF{0,1},
16827 1 if bases are known to be equal and OP0 cmp OP1 depends on OFF0 cmp OFF1,
16828 and 2 if unknown. */
16830 int
16834 {
16844 {
16847 }
16849 {
16852 }
16857 /* Punt in GENERIC on variables with value expressions;
16858 the value expressions might point to fields/elements
16859 of other vars etc. */
16865 {
16869 }
16877 /* Assume different STRING_CSTs with the same content will be
16878 merged. */
16887 {
16890 /* If the offsets are equal we can ignore overflow. */
16893 /* Or if we compare using pointers to decls or strings. */
16898 }
16904 /* At this point we know (or assume) the two pointers point at
16905 different objects. */
16909 /* Punt on non-zero offsets from functions. */
16913 /* Or if the bases are neither decls nor string literals. */
16918 /* For initializers, assume addresses of different functions are
16919 different. */
16925 /* Compute whether one address points to the start of one
16926 object and another one to the end of another one. */
16929 {
16932 else
16934 }
16937 else
16938 {
16942 else
16944 }
16946 {
16949 else
16951 }
16954 else
16955 {
16959 else
16961 }
16963 {
16964 /* If one offset is pointing (or could be) to the beginning of one
16965 object and the other is pointing to one past the last byte of the
16966 other object, punt. */
16971 /* If both offsets are the same, there are some cases we know that are
16972 ok. Either if we know they aren't zero, or if we know both sizes
16973 are no zero. */
16979 }
16981 /* At this point, equal is 2 if either one or both pointers are out of
16982 bounds of their object, or one points to start of its object and the
16983 other points to end of its object. This is unspecified behavior
16984 e.g. in C++. Otherwise equal is 0. */
16988 /* When both pointers point to string literals, even when equal is 0,
16989 due to tail merging of string literals the pointers might be the same. */
16991 {
16998 /* If the bytes in the string literals starting at the pointers
16999 differ, the pointers need to be different. */
17004 {
17009 /* If even the bytes in the string literal before the
17010 pointers are the same, the string literals could be
17011 tail merged. */
17013 }
17015 }
17020 /* If this is a pointer comparison, ignore for now even
17021 valid equalities where one pointer is the offset zero
17022 of one object and the other to one past end of another one. */
17026 /* Assume that string literals can't be adjacent to variables
17027 (automatic or global). */
17031 /* Assume that automatic variables can't be adjacent to global
17032 variables. */
17037 }
17039 /* Return the single non-zero element of a CONSTRUCTOR or NULL_TREE. */
17040 tree
17042 {
17051 {
17055 }
17057 }
17059 #if CHECKING_P
17063 /* Helper functions for writing tests of folding trees. */
17065 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
17067 static void
17069 tree constant)
17070 {
17072 }
17074 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
17075 wrapping WRAPPED_EXPR. */
17077 static void
17079 tree wrapped_expr)
17080 {
17085 }
17087 /* Verify that various arithmetic binary operations are folded
17088 correctly. */
17090 static void
17092 {
17098 /* Addition. */
17099 /* 1 <-- (0 + 1) */
17101 one);
17103 one);
17105 /* (nonlvalue)x <-- (x + 0) */
17107 x);
17109 /* Subtraction. */
17110 /* 0 <-- (x - x) */
17112 zero);
17114 x);
17116 /* Multiplication. */
17117 /* 0 <-- (x * 0) */
17119 zero);
17121 /* (nonlvalue)x <-- (x * 1) */
17123 x);
17124 }
17128 /* Build a VECTOR_CST corresponding to VMODE, and has
17129 encoding given by NPATTERNS, NELTS_PER_PATTERN and STEP.
17130 Fill it with randomized elements, using rand() % THRESHOLD. */
17132 static tree
17136 {
17141 // Fill a0 for each pattern
17148 // Fill a1 for each pattern
17156 {
17161 }
17164 }
17166 /* Validate result of VEC_PERM_EXPR folding for the unit-tests below,
17167 when result is VLA. */
17169 static void
17172 {
17173 /* Actual npatterns and encoded_elts in res may be less than expected due
17174 to canonicalization. */
17181 }
17183 /* Validate result of VEC_PERM_EXPR folding for the unit-tests below,
17184 when the result is VLS. */
17186 static void
17188 {
17192 }
17194 /* Helper routine to push multiple elements into BUILDER. */
17198 {
17201 }
17203 #define ARG0(index) vector_cst_elt (arg0, index)
17204 #define ARG1(index) vector_cst_elt (arg1, index)
17206 /* Test cases where result is VNx4SI and input vectors are V4SI. */
17208 static void
17210 {
17212 {
17213 /* Case 1:
17214 sel = { 0, 4, 1, 5, ... }
17215 res = { arg[0], arg1[0], arg0[1], arg1[1], ...} // (4, 1) */
17216 {
17220 tree inner_type
17234 }
17236 /* Case 2: Same as case 1, but contains an out of bounds access which
17237 should wrap around.
17238 sel = {0, 8, 4, 12, ...} (4, 1)
17239 res = { arg0[0], arg0[0], arg1[0], arg1[0], ... } (4, 1). */
17240 {
17244 tree inner_type
17258 }
17259 }
17260 }
17262 /* Test cases where result is V4SI and input vectors are VNx4SI. */
17264 static void
17266 {
17268 {
17269 /* Case 1:
17270 sel = { 0, 1, 2, 3}
17271 res = { arg0[0], arg0[1], arg0[2], arg0[3] }. */
17272 {
17276 tree inner_type
17290 }
17292 /* Case 2: Same as Case 1, but crossing input vector.
17293 sel = {0, 2, 4, 6}
17294 In this case,the index 4 is ambiguous since len = 4 + 4x.
17295 Since we cannot determine, which vector to choose from during
17296 compile time, should return NULL_TREE. */
17297 {
17301 tree inner_type
17316 }
17317 }
17318 }
17320 /* Test all input vectors. */
17322 static void
17324 {
17325 /* Test with 10 different inputs. */
17327 {
17332 /* Case 1: mask = {0, ...} // (1, 1)
17333 res = { arg0[0], ... } // (1, 1) */
17334 {
17341 }
17343 /* Case 2: mask = {len, ...} // (1, 1)
17344 res = { arg1[0], ... } // (1, 1) */
17345 {
17353 }
17354 }
17355 }
17357 /* Test all vectors which contain at-least 2 elements. */
17359 static void
17361 {
17363 {
17364 /* Case 1: mask = { 0, len, ... } // (2, 1)
17365 res = { arg0[0], arg1[0], ... } // (2, 1) */
17366 {
17380 }
17382 /* Case 2: mask = { 0, len, 1, len+1, ... } // (2, 2)
17383 res = { arg0[0], arg1[0], arg0[1], arg1[1], ... } // (2, 2) */
17384 {
17398 }
17400 /* Case 4: mask = {0, 0, 1, ...} // (1, 3)
17401 Test that the stepped sequence of the pattern selects from
17402 same input pattern. Since input vectors have npatterns = 2,
17403 and step (a2 - a1) = 1, step is not a multiple of npatterns
17404 in input vector. So return NULL_TREE. */
17405 {
17420 }
17422 /* Case 5: mask = {len, 0, 1, ...} // (1, 3)
17423 Test that stepped sequence of the pattern selects from arg0.
17424 res = { arg1[0], arg0[0], arg0[1], ... } // (1, 3) */
17425 {
17439 }
17440 }
17441 }
17443 /* Test all vectors which contain at-least 4 elements. */
17445 static void
17447 {
17449 {
17450 /* Case 1: mask = { 0, len, 1, len+1, ... } // (4, 1)
17451 res: { arg0[0], arg1[0], arg0[1], arg1[1], ... } // (4, 1) */
17452 {
17466 }
17468 /* Case 2: sel = {0, 1, 2, ...} // (1, 3)
17469 res: { arg0[0], arg0[1], arg0[2], ... } // (1, 3) */
17470 {
17483 }
17485 /* Case 3: sel = {len, len+1, len+2, ...} // (1, 3)
17486 res: { arg1[0], arg1[1], arg1[2], ... } // (1, 3) */
17487 {
17500 }
17502 /* Case 4:
17503 sel = { len, 0, 2, ... } // (1, 3)
17504 This should return NULL because we cross the input vectors.
17505 Because,
17506 Let's assume len = C + Cx
17507 a1 = 0
17508 S = 2
17509 esel = arg0_len / sel_npatterns = C + Cx
17510 ae = 0 + (esel - 2) * S
17511 = 0 + (C + Cx - 2) * 2
17512 = 2(C-2) + 2Cx
17514 For C >= 4:
17515 Let q1 = a1 / arg0_len = 0 / (C + Cx) = 0
17516 Let qe = ae / arg0_len = (2(C-2) + 2Cx) / (C + Cx) = 1
17517 Since q1 != qe, we cross input vectors.
17518 So return NULL_TREE. */
17519 {
17533 }
17535 /* Case 5: npatterns(arg0) = 4 > npatterns(sel) = 2
17536 mask = { 0, len, 1, len + 1, ...} // (2, 2)
17537 res = { arg0[0], arg1[0], arg0[1], arg1[1], ... } // (2, 2)
17539 Note that fold_vec_perm_cst will set
17540 res_npatterns = max(4, max(4, 2)) = 4
17541 However after canonicalizing, we will end up with shape (2, 2). */
17542 {
17555 }
17557 /* Case 6: Test combination in sel, where one pattern is dup and other
17558 is stepped sequence.
17559 sel = { 0, 0, 0, 1, 0, 2, ... } // (2, 3)
17560 res = { arg0[0], arg0[0], arg0[0],
17561 arg0[1], arg0[0], arg0[2], ... } // (2, 3) */
17562 {
17577 }
17579 /* Case 7: PR111048: Check that we set arg_npatterns correctly,
17580 when arg0, arg1 and sel have different number of patterns.
17581 arg0 is of shape (1, 1)
17582 arg1 is of shape (4, 1)
17583 sel is of shape (2, 3) = {1, len, 2, len+1, 3, len+2, ...}
17585 In this case the pattern: {len, len+1, len+2, ...} chooses arg1.
17586 However,
17587 step = (len+2) - (len+1) = 1
17588 arg_npatterns = VECTOR_CST_NPATTERNS (arg1) = 4
17589 Since step is not a multiple of arg_npatterns,
17590 valid_mask_for_fold_vec_perm_cst should return false,
17591 and thus fold_vec_perm_cst should return NULL_TREE. */
17592 {
17607 }
17608 }
17609 }
17611 /* Test all vectors which contain at-least 8 elements. */
17613 static void
17615 {
17617 {
17618 /* Case 1: sel_npatterns (4) > input npatterns (2)
17619 sel: { 0, 0, 1, len, 2, 0, 3, len, 4, 0, 5, len, ...} // (4, 3)
17620 res: { arg0[0], arg0[0], arg0[0], arg1[0],
17621 arg0[2], arg0[0], arg0[3], arg1[0],
17622 arg0[4], arg0[0], arg0[5], arg1[0], ... } // (4, 3) */
17623 {
17640 }
17641 }
17642 }
17644 /* Test vectors for which nunits[0] <= 4. */
17646 static void
17648 {
17649 /* Case 1: mask = {0, 4, ...} // (1, 2)
17650 This should return NULL_TREE because the index 4 may choose
17651 from either arg0 or arg1 depending on vector length. */
17652 {
17667 }
17668 }
17670 #undef ARG0
17671 #undef ARG1
17673 /* Return true if SIZE is of the form C + Cx and C is power of 2. */
17675 static bool
17677 {
17685 }
17687 /* Execute fold_vec_perm_cst unit tests. */
17689 static void
17691 {
17695 machine_mode vmode;
17697 {
17698 /* Obtain modes corresponding to VNx4SI and V4SI,
17699 to call mixed mode tests below.
17700 FIXME: Is there a better way to do this ? */
17702 {
17709 }
17726 }
17731 {
17734 }
17735 }
17738 /* Verify that various binary operations on vectors are folded
17739 correctly. */
17741 static void
17743 {
17750 /* Verify equality tests that return a scalar boolean result. */
17763 }
17765 /* Verify folding of VEC_DUPLICATE_EXPRs. */
17767 static void
17769 {
17772 /* This will be 1 if VEC_MODE isn't a vector mode. */
17779 }
17781 /* Run all of the selftests within this file. */
17783 void
17785 {
17790 }