Lines Matching refs:op0
115 simplify_gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0,
121 tem = simplify_binary_operation (code, mode, op0, op1);
127 && swap_commutative_operands_p (op0, op1))
128 tem = op0, op0 = op1, op1 = tem;
130 return gen_rtx_fmt_ee (code, mode, op0, op1);
235 enum machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
241 op0, op1, op2)))
244 return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
252 enum machine_mode cmp_mode, rtx op0, rtx op1)
257 op0, op1)))
260 return gen_rtx_fmt_ee (code, mode, op0, op1);
273 rtx op0, op1, op2;
285 op0 = XEXP (x, 0);
286 op_mode = GET_MODE (op0);
287 op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
288 if (op0 == XEXP (x, 0))
290 return simplify_gen_unary (code, mode, op0, op_mode);
294 op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
296 if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
298 return simplify_gen_binary (code, mode, op0, op1);
302 op0 = XEXP (x, 0);
304 op_mode = GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
305 op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
307 if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
309 return simplify_gen_relational (code, mode, op_mode, op0, op1);
313 op0 = XEXP (x, 0);
314 op_mode = GET_MODE (op0);
315 op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
318 if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1) && op2 == XEXP (x, 2))
321 op_mode = GET_MODE (op0);
322 return simplify_gen_ternary (code, mode, op_mode, op0, op1, op2);
328 op0 = simplify_replace_rtx (SUBREG_REG (x), old_rtx, new_rtx);
329 if (op0 == SUBREG_REG (x))
331 op0 = simplify_gen_subreg (GET_MODE (x), op0,
334 return op0 ? op0 : x;
341 op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
342 if (op0 == XEXP (x, 0))
344 return replace_equiv_address_nv (x, op0);
348 op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
352 if (GET_CODE (op0) == HIGH && rtx_equal_p (XEXP (op0, 0), op1))
355 if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
357 return gen_rtx_LO_SUM (mode, op0, op1);
1398 rtx op0, rtx op1)
1406 if (GET_CODE (op0) == code)
1408 tem = simplify_gen_binary (code, mode, op0, XEXP (op1, 0));
1413 if (! swap_commutative_operands_p (op1, op0))
1414 return simplify_gen_binary (code, mode, op1, op0);
1416 tem = op0;
1417 op0 = op1;
1421 if (GET_CODE (op0) == code)
1424 if (swap_commutative_operands_p (XEXP (op0, 1), op1))
1426 tem = simplify_gen_binary (code, mode, XEXP (op0, 0), op1);
1427 return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1431 tem = swap_commutative_operands_p (XEXP (op0, 1), op1)
1432 ? simplify_binary_operation (code, mode, op1, XEXP (op0, 1))
1433 : simplify_binary_operation (code, mode, XEXP (op0, 1), op1);
1435 return simplify_gen_binary (code, mode, XEXP (op0, 0), tem);
1438 tem = swap_commutative_operands_p (XEXP (op0, 0), op1)
1439 ? simplify_binary_operation (code, mode, op1, XEXP (op0, 0))
1440 : simplify_binary_operation (code, mode, XEXP (op0, 0), op1);
1442 return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1456 rtx op0, rtx op1)
1470 && swap_commutative_operands_p (op0, op1))
1472 tem = op0, op0 = op1, op1 = tem;
1475 trueop0 = avoid_constant_pool_reference (op0);
1481 return simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
1491 rtx op0, rtx op1, rtx trueop0, rtx trueop1)
1508 return op0;
1512 if (GET_CODE (op0) == NEG)
1513 return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
1515 return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
1519 && GET_CODE (op0) == NOT
1521 return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
1529 if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode
1531 return plus_constant (op0, INTVAL (op1));
1533 && GET_CODE (op0) == CONST_INT)
1534 return plus_constant (op1, INTVAL (op0));
1546 rtx lhs = op0, rhs = op1;
1596 rtx orig = gen_rtx_PLUS (mode, op0, op1);
1613 && GET_CODE (op0) == XOR
1614 && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1615 || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1617 return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1619 XEXP (op0, 1)));
1622 if (GET_CODE (op0) == MULT
1623 && GET_CODE (XEXP (op0, 0)) == NEG)
1627 in1 = XEXP (XEXP (op0, 0), 0);
1628 in2 = XEXP (op0, 1);
1637 if (COMPARISON_P (op0)
1640 && (reversed = reversed_comparison (op0, mode)))
1651 && (plus_minus_operand_p (op0)
1653 && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1661 tem = simplify_associative_operation (code, mode, op0, op1);
1678 return op0;
1682 if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
1683 || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
1684 && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
1686 rtx xop00 = XEXP (op0, 0);
1707 && ! side_effects_p (op0)
1728 return op0;
1740 rtx lhs = op0, rhs = op1;
1790 rtx orig = gen_rtx_MINUS (mode, op0, op1);
1806 return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
1809 if (GET_CODE (op0) == NEG
1815 return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
1819 if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
1821 op0,
1827 if (rtx_equal_p (op0, XEXP (op1, 0)))
1831 return simplify_gen_binary (AND, mode, op0, tem);
1833 if (rtx_equal_p (op0, XEXP (op1, 1)))
1837 return simplify_gen_binary (AND, mode, op0, tem);
1860 op0);
1866 && GET_CODE (op0) == NEG)
1875 XEXP (op0, 0));
1886 && (plus_minus_operand_p (op0)
1888 && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1894 return simplify_gen_unary (NEG, mode, op0, mode);
1903 && ! side_effects_p (op0))
1910 return op0;
1921 return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
1927 && GET_MODE (op0) == mode
1930 return simplify_gen_binary (ASHIFT, mode, op0,
1936 && GET_MODE (op0) == mode)
1942 return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
1946 return simplify_gen_unary (NEG, mode, op0, mode);
1951 && GET_CODE (op0) == NEG
1953 && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
1954 && !side_effects_p (XEXP (op0, 0)))
1955 return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
1959 && GET_CODE (op0) == ABS
1961 && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
1962 && !side_effects_p (XEXP (op0, 0)))
1963 return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
1970 tem = simplify_associative_operation (code, mode, op0, op1);
1978 return op0;
1983 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1984 return op0;
1986 if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1987 || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1988 && ! side_effects_p (op0)
1995 && (nonzero_bits (op0, mode) & ~INTVAL (op1)) == 0)
1999 if (GET_CODE (op0) == AND
2000 && (rtx_equal_p (XEXP (op0, 0), op1)
2001 || rtx_equal_p (XEXP (op0, 1), op1))
2002 && ! side_effects_p (XEXP (op0, 0))
2003 && ! side_effects_p (XEXP (op0, 1)))
2013 opright = op0;
2018 opleft = op0;
2054 && GET_CODE (op0) == AND
2055 && GET_CODE (XEXP (op0, 1)) == CONST_INT
2057 && (INTVAL (XEXP (op0, 1)) & INTVAL (op1)) != 0)
2060 (AND, mode, XEXP (op0, 0),
2061 GEN_INT (INTVAL (XEXP (op0, 1))
2070 if (GET_CODE (trueop1) == CONST_INT && GET_CODE (op0) == ASHIFTRT
2071 && GET_CODE (XEXP (op0, 0)) == PLUS
2072 && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
2073 && GET_CODE (XEXP (op0, 1)) == CONST_INT
2074 && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT)
2076 int count = INTVAL (XEXP (op0, 1));
2080 && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0)
2082 plus_constant (XEXP (op0, 0), mask),
2083 XEXP (op0, 1));
2086 tem = simplify_associative_operation (code, mode, op0, op1);
2093 return op0;
2097 return simplify_gen_unary (NOT, mode, op0, mode);
2099 && ! side_effects_p (op0)
2107 return simplify_gen_binary (PLUS, mode, op0, op1);
2111 && GET_CODE (op0) == PLUS
2112 && (GET_CODE (XEXP (op0, 1)) == CONST_INT
2113 || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
2114 && mode_signbit_p (mode, XEXP (op0, 1)))
2115 return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
2117 XEXP (op0, 1)));
2124 && (nonzero_bits (op0, mode)
2126 return (simplify_gen_binary (IOR, mode, op0, op1));
2134 if (GET_CODE (op0) == NOT)
2135 num_negated++, op0 = XEXP (op0, 0);
2140 return simplify_gen_binary (XOR, mode, op0, op1);
2143 simplify_gen_binary (XOR, mode, op0, op1),
2151 if (GET_CODE (op0) == AND
2152 && rtx_equal_p (XEXP (op0, 1), op1)
2156 XEXP (op0, 0), mode),
2159 else if (GET_CODE (op0) == AND
2160 && rtx_equal_p (XEXP (op0, 0), op1)
2164 XEXP (op0, 1), mode),
2171 && COMPARISON_P (op0)
2172 && (reversed = reversed_comparison (op0, mode)))
2181 && GET_CODE (op0) == LSHIFTRT
2182 && GET_CODE (XEXP (op0, 1)) == CONST_INT
2183 && INTVAL (XEXP (op0, 1)) == GET_MODE_BITSIZE (mode) - 1)
2184 return gen_rtx_GE (mode, XEXP (op0, 0), const0_rtx);
2192 && COMPARISON_P (op0)
2193 && (reversed = reversed_comparison (op0, mode)))
2198 tem = simplify_associative_operation (code, mode, op0, op1);
2204 if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
2211 return op0;
2212 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)
2214 return op0;
2216 if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
2217 || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
2218 && ! side_effects_p (op0)
2224 if ((GET_CODE (op0) == SIGN_EXTEND
2225 || GET_CODE (op0) == ZERO_EXTEND)
2228 && (~GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))
2231 enum machine_mode imode = GET_MODE (XEXP (op0, 0));
2232 tem = simplify_gen_binary (AND, imode, XEXP (op0, 0),
2240 if (GET_CODE (op0) == XOR
2241 && rtx_equal_p (XEXP (op0, 0), op1)
2245 XEXP (op0, 1), mode),
2248 if (GET_CODE (op0) == XOR
2249 && rtx_equal_p (XEXP (op0, 1), op1)
2253 XEXP (op0, 0), mode),
2257 if (GET_CODE (op0) == NOT
2258 && GET_CODE (XEXP (op0, 0)) == XOR
2259 && rtx_equal_p (XEXP (XEXP (op0, 0), 0), op1)
2261 return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 1), op1);
2263 if (GET_CODE (op0) == NOT
2264 && GET_CODE (XEXP (op0, 0)) == XOR
2265 && rtx_equal_p (XEXP (XEXP (op0, 0), 1), op1)
2267 return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 0), op1);
2270 if (GET_CODE (op0) == IOR
2271 && (rtx_equal_p (XEXP (op0, 0), op1)
2272 || rtx_equal_p (XEXP (op0, 1), op1))
2273 && ! side_effects_p (XEXP (op0, 0))
2274 && ! side_effects_p (XEXP (op0, 1)))
2286 && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
2291 pmop[0] = XEXP (op0, 0);
2292 pmop[1] = XEXP (op0, 1);
2316 if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
2318 tem = simplify_gen_binary (GET_CODE (op0), mode,
2323 tem = simplify_associative_operation (code, mode, op0, op1);
2338 return rtl_hooks.gen_lowpart_no_emit (mode, op0);
2342 return simplify_gen_binary (LSHIFTRT, mode, op0, GEN_INT (val));
2357 return op0;
2361 return op0;
2372 return simplify_gen_unary (NEG, mode, op0, mode);
2381 return simplify_gen_binary (MULT, mode, op0, tem);
2396 return rtl_hooks.gen_lowpart_no_emit (mode, op0);
2400 rtx x = rtl_hooks.gen_lowpart_no_emit (mode, op0);
2417 if (side_effects_p (op0))
2418 return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
2424 return simplify_gen_binary (AND, mode, op0,
2439 if (side_effects_p (op0))
2440 return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
2449 return op0;
2451 return op0;
2456 return op0;
2462 return op0;
2464 return op0;
2469 return op0;
2471 return op0;
2473 if (GET_CODE (op0) == CLZ
2478 enum machine_mode imode = GET_MODE (XEXP (op0, 0));
2485 XEXP (op0, 0), const0_rtx);
2493 && ! side_effects_p (op0))
2495 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2496 return op0;
2497 tem = simplify_associative_operation (code, mode, op0, op1);
2507 && ! side_effects_p (op0))
2509 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2510 return op0;
2511 tem = simplify_associative_operation (code, mode, op0, op1);
2517 if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
2519 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2520 return op0;
2521 tem = simplify_associative_operation (code, mode, op0, op1);
2527 if (trueop1 == constm1_rtx && ! side_effects_p (op0))
2529 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2530 return op0;
2531 tem = simplify_associative_operation (code, mode, op0, op1);
2684 rtx op0, rtx op1)
2692 && GET_CODE (op0) == CONST_VECTOR
2696 enum machine_mode op0mode = GET_MODE (op0);
2708 CONST_VECTOR_ELT (op0, i),
2720 && CONSTANT_P (op0) && CONSTANT_P (op1))
2728 gcc_assert (GET_CODE (op0) != CONST_VECTOR);
2731 RTVEC_ELT (v, 0) = op0;
2736 unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0));
2740 gcc_assert (GET_CODE (op0) == CONST_VECTOR);
2745 RTVEC_ELT (v, i) = XVECEXP (op0, 0, i);
2754 && GET_CODE (op0) == CONST_DOUBLE
2756 && mode == GET_MODE (op0) && mode == GET_MODE (op1))
2767 real_to_target (tmp0, CONST_DOUBLE_REAL_VALUE (op0),
2768 GET_MODE (op0));
2796 REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
2878 && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT)
2884 if (GET_CODE (op0) == CONST_DOUBLE)
2885 l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
2887 l1 = INTVAL (op0), h1 = HWI_SIGN_EXTEND (l1);
3014 if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
3020 arg0 = INTVAL (op0);
3220 simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
3235 ops[0].op = op0;
3514 enum machine_mode cmp_mode, rtx op0, rtx op1)
3519 cmp_mode = GET_MODE (op0);
3523 tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
3570 if (swap_commutative_operands_p (op0, op1)
3571 || (op0 == const0_rtx && op1 != const0_rtx))
3572 tem = op0, op0 = op1, op1 = tem, code = swap_condition (code);
3574 /* If op0 is a compare, extract the comparison arguments from it. */
3575 if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
3577 XEXP (op0, 0), XEXP (op0, 1));
3580 || CC0_P (op0))
3583 trueop0 = avoid_constant_pool_reference (op0);
3597 enum machine_mode cmp_mode, rtx op0, rtx op1)
3599 enum rtx_code op0code = GET_CODE (op0);
3603 if (INTVAL (op1) == 0 && COMPARISON_P (op0))
3605 /* If op0 is a comparison, extract the comparison arguments
3609 if (GET_MODE (op0) == mode)
3610 return simplify_rtx (op0);
3612 return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
3613 XEXP (op0, 0), XEXP (op0, 1));
3617 enum rtx_code new_code = reversed_comparison_code (op0, NULL_RTX);
3620 XEXP (op0, 0), XEXP (op0, 1));
3629 && CONSTANT_P (XEXP (op0, 1))
3632 rtx x = XEXP (op0, 0);
3633 rtx c = XEXP (op0, 1);
3649 && nonzero_bits (op0, cmp_mode) == 1
3652 ? simplify_gen_unary (ZERO_EXTEND, mode, op0, cmp_mode)
3653 : lowpart_subreg (mode, op0, cmp_mode);
3660 XEXP (op0, 0), XEXP (op0, 1));
3665 && rtx_equal_p (XEXP (op0, 0), op1)
3666 && !side_effects_p (XEXP (op0, 0)))
3668 XEXP (op0, 1), const0_rtx);
3673 && rtx_equal_p (XEXP (op0, 1), op1)
3674 && !side_effects_p (XEXP (op0, 1)))
3676 XEXP (op0, 0), const0_rtx);
3683 && (GET_CODE (XEXP (op0, 1)) == CONST_INT
3684 || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE))
3685 return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
3687 XEXP (op0, 1), op1));
3700 rtx op0, rtx op1)
3708 || (GET_MODE (op0) == VOIDmode
3711 /* If op0 is a compare, extract the comparison arguments from it. */
3712 if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
3714 op1 = XEXP (op0, 1);
3715 op0 = XEXP (op0, 0);
3717 if (GET_MODE (op0) != VOIDmode)
3718 mode = GET_MODE (op0);
3727 if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
3731 if (swap_commutative_operands_p (op0, op1))
3733 tem = op0, op0 = op1, op1 = tem;
3737 trueop0 = avoid_constant_pool_reference (op0);
3752 && ! ((REG_P (op0) || GET_CODE (trueop0) == CONST_INT)
3754 && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
3933 if (trueop1 == const0_rtx && nonzero_address_p (op0))
3938 if (trueop1 == const0_rtx && nonzero_address_p (op0))
4050 enum machine_mode op0_mode, rtx op0, rtx op1,
4063 if (GET_CODE (op0) == CONST_INT
4070 HOST_WIDE_INT val = INTVAL (op0);
4102 if (GET_CODE (op0) == CONST_INT)
4103 return op0 != const0_rtx ? op1 : op2;
4106 if (rtx_equal_p (op1, op2) && ! side_effects_p (op0))
4110 if (GET_CODE (op0) == NE
4111 && ! side_effects_p (op0)
4114 && ((rtx_equal_p (XEXP (op0, 0), op1)
4115 && rtx_equal_p (XEXP (op0, 1), op2))
4116 || (rtx_equal_p (XEXP (op0, 0), op2)
4117 && rtx_equal_p (XEXP (op0, 1), op1))))
4121 if (GET_CODE (op0) == EQ
4122 && ! side_effects_p (op0)
4125 && ((rtx_equal_p (XEXP (op0, 0), op1)
4126 && rtx_equal_p (XEXP (op0, 1), op2))
4127 || (rtx_equal_p (XEXP (op0, 0), op2)
4128 && rtx_equal_p (XEXP (op0, 1), op1))))
4131 if (COMPARISON_P (op0) && ! side_effects_p (op0))
4133 enum machine_mode cmp_mode = (GET_MODE (XEXP (op0, 0)) == VOIDmode
4134 ? GET_MODE (XEXP (op0, 1))
4135 : GET_MODE (XEXP (op0, 0)));
4145 code = GET_CODE (op0);
4149 tmp = reversed_comparison_code (op0, NULL_RTX);
4158 XEXP (op0, 0), XEXP (op0, 1));
4163 temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
4164 cmp_mode, XEXP (op0, 0),
4165 XEXP (op0, 1));
4179 gcc_assert (GET_MODE (op0) == mode);
4192 return op0;
4194 op0 = avoid_constant_pool_reference (op0);
4196 if (GET_CODE (op0) == CONST_VECTOR
4204 ? CONST_VECTOR_ELT (op0, i)