Lines Matching refs:SET_SRC
889 && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
909 && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
938 && ! unmentioned_reg_p (note, SET_SRC (set))
946 rtx orig = SET_SRC (set);
947 SET_SRC (set) = note;
956 SET_SRC (set) = orig;
1095 rtx src = SET_SRC (set);
1122 num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
1254 /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
1256 || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1266 src = SET_SRC (set), dest = SET_DEST (set);
1500 rtx src = SET_SRC (set);
1636 src = SET_SRC (set);
1839 /* SET_DEST and SET_SRC of I2 and I1. */
1892 and I3 is a SET whose SET_SRC is a SET_DEST in I2. In that case,
1907 && REG_P (SET_SRC (PATTERN (i3)))
1908 && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
1909 && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
1918 && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
1945 && SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
1953 i2dest = SET_SRC (PATTERN (i3));
1973 && (GET_CODE (SET_SRC (temp)) == CONST_INT
1974 || GET_CODE (SET_SRC (temp)) == CONST_DOUBLE)
1976 && (GET_CODE (SET_SRC (PATTERN (i3))) == CONST_INT
1977 || GET_CODE (SET_SRC (PATTERN (i3))) == CONST_DOUBLE)
2022 rtx inner = SET_SRC (PATTERN (i3));
2023 rtx outer = SET_SRC (temp);
2094 SUBST (SET_SRC (temp),
2121 && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
2122 && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
2125 && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
2126 SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
2145 SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
2186 && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
2198 && REG_P (SET_SRC (PATTERN (i3)))
2277 && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
2278 && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
2279 && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
2287 SUBST (XEXP (SET_SRC (newpat), 0), i2src);
2320 SUBST (SET_SRC (newpat),
2421 || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
2528 && ! side_effects_p (SET_SRC (set1)))
2541 && ! side_effects_p (SET_SRC (set0)))
2773 if (BINARY_P (SET_SRC (newpat))
2774 && split_mode == GET_MODE (SET_SRC (newpat))
2775 && ! side_effects_p (SET_SRC (newpat)))
2777 rtx setsrc = SET_SRC (newpat);
2867 the SET_DEST and SET_SRC have the same mode.
2877 && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
2879 == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
2881 && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2882 XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
2883 && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2903 SET_SRC (XVECEXP (newpat, 0, 1)))
2912 SUBST (SET_SRC (newpat),
2913 gen_lowpart (GET_MODE (SET_SRC (newpat)), ni2dest));
2937 && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
2943 && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
2944 && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1))))
3344 i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
3367 i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
3415 && SET_SRC (newpat) == pc_rtx
3552 SET_SRC (PATTERN (seq)))
3557 SET_SRC (PATTERN (NEXT_INSN (seq)))))
3559 rtx src1 = SET_SRC (PATTERN (seq));
3560 rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
3596 /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
3602 && GET_CODE (SET_SRC (x)) != COMPARE
3603 && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
3604 && !OBJECT_P (SET_SRC (x))
3605 && ! (GET_CODE (SET_SRC (x)) == SUBREG
3606 && OBJECT_P (SUBREG_REG (SET_SRC (x)))))
3607 return &SET_SRC (x);
3610 /* See if we can split SET_SRC as it stands. */
3611 split = find_split_point (&SET_SRC (x), insn);
3612 if (split && split != &SET_SRC (x))
3627 && GET_CODE (SET_SRC (x)) == CONST_INT
3635 unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
3646 SUBST (SET_SRC (x),
3651 SUBST (SET_SRC (x),
3660 split = find_split_point (&SET_SRC (x), insn);
3661 if (split && split != &SET_SRC (x))
3667 code = GET_CODE (SET_SRC (x));
3681 if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3682 && REG_P (XEXP (SET_SRC (x), 0))
3683 && (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
3691 XEXP (SET_SRC (x), 0),
3695 SUBST (SET_SRC (x), extraction);
3704 if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
3705 && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
3707 (nonzero_bits (XEXP (SET_SRC (x), 0),
3708 GET_MODE (XEXP (SET_SRC (x), 0))))))
3710 enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
3712 SUBST (SET_SRC (x),
3715 XEXP (SET_SRC (x), 0),
3718 split = find_split_point (&SET_SRC (x), insn);
3719 if (split && split != &SET_SRC (x))
3725 inner = XEXP (SET_SRC (x), 0);
3731 || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
3741 if (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT
3742 && GET_CODE (XEXP (SET_SRC (x), 2)) == CONST_INT)
3744 inner = XEXP (SET_SRC (x), 0);
3745 len = INTVAL (XEXP (SET_SRC (x), 1));
3746 pos = INTVAL (XEXP (SET_SRC (x), 2));
3760 enum machine_mode mode = GET_MODE (SET_SRC (x));
3770 SUBST (SET_SRC (x),
3777 split = find_split_point (&SET_SRC (x), insn);
3778 if (split && split != &SET_SRC (x))
3783 SUBST (SET_SRC (x),
3792 split = find_split_point (&SET_SRC (x), insn);
3793 if (split && split != &SET_SRC (x))
3801 if (BINARY_P (SET_SRC (x))
3802 && CONSTANT_P (XEXP (SET_SRC (x), 1))
3803 && (OBJECT_P (XEXP (SET_SRC (x), 0))
3804 || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
3805 && OBJECT_P (SUBREG_REG (XEXP (SET_SRC (x), 0))))))
3806 return &XEXP (SET_SRC (x), 1);
3813 if ((BINARY_P (SET_SRC (x)) || UNARY_P (SET_SRC (x)))
3814 && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
3815 return &XEXP (SET_SRC (x), 0);
3964 && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
4002 SET_SRC are handled via the IN_DEST operand. */
5192 rtx src = SET_SRC (x);
5211 SUBST (SET_SRC (x), src);
5255 rtx new = simplify_rtx (SET_SRC (pat));
5257 SUBST (SET_SRC (pat), new);
5262 SUBST (SET_SRC (x), pc_rtx);
5353 SUBST (SET_SRC (x), op0);
5363 SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
5364 src = SET_SRC (x);
5368 SUBST (SET_SRC (x), op0);
5369 src = SET_SRC (x);
5374 SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
5375 src = SET_SRC (x);
5380 /* Get SET_SRC in a form where we have placed back any
5383 SUBST (SET_SRC (x), src);
5421 SUBST (SET_SRC (x), SUBREG_REG (src));
5423 src = SET_SRC (x), dest = SET_DEST (x);
5444 SUBST (SET_SRC (x), inner);
5445 src = SET_SRC (x);
5462 SUBST (SET_SRC (x),
5466 src = SET_SRC (x);
5470 /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
5517 SUBST (SET_SRC (x),
5523 src = SET_SRC (x);
5899 SET_SRC (x)));
5946 gen_lowpart (compute_mode, SET_SRC (x)),
7803 rtx src = SET_SRC (x);
11037 record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
11045 SET_SRC (setter)));
11152 if (REG_P (SET_SRC (set)))
11154 regno = REGNO (SET_SRC (set));
11649 mark_used_regs_combine (SET_SRC (x));
11817 move_deaths (SET_SRC (x), maybe_kill_insn, from_cuid, to_insn, pnotes);
12269 if (set != 0 && ! side_effects_p (SET_SRC (set))
12272 && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))