Lines Matching refs:set
29 #include "hard-reg-set.h"
236 a comparison, else it is set to UNKNOWN and the other two
324 /* The SUBREG that was set when REG_TICK was last incremented. Set
409 Each set of expressions with equivalent values
433 The `is_const' flag is set if the element is a constant (including
471 register (hard registers may require `do_not_record' to be set). */
515 /* Get the SUBREG set at the last increment to REG_TICK (-1 if not a
1254 (set (reg:si 100) (reg:si 5))
1255 (set (reg:si 5) (reg:si 100))
1256 (set (reg:di 101) (reg:di 5))
1258 We would now set REG_QTY (101) = REG_QTY (5), but the
1501 The in_memory field in the hash table element is set to 0.
1502 The caller must set it nonzero if appropriate.
1595 /* If this is a constant being set equivalent to a register or a register
1596 being set equivalent to a constant, note the constant equivalence.
2186 a MEM rtx which does not have the RTX_UNCHANGING_P bit set.
2478 does not have the RTX_UNCHANGING_P bit set. */
2581 it isn't, due to it being set with the different alias set.
3086 was (const_int 0), *PARG1 and *PARG2 will be set to the objects that were
3188 be equivalent to a comparison operation that would set ARG1 to
3246 Otherwise, set up for the next iteration. */
3585 rtx set;
3588 jumptable into a reg, we don't want to set the reg
3595 set = single_set (insn);
3597 if (! set || SET_SRC (set) != x)
3601 if (SET_DEST (set) == pc_rtx)
3652 set (reg1)
3656 set (reg2)
4018 /* See what items are actually being compared and set FOLDED_ARG[01]
4020 constant, set CONST_ARG0 and CONST_ARG1 appropriately. We needn't
4552 rtx set;
4560 set = pc_set (insn);
4564 cond_known_true = (XEXP (SET_SRC (set), 2) == pc_rtx);
4566 cond_known_true = (XEXP (SET_SRC (set), 1) == pc_rtx);
4571 code = GET_CODE (XEXP (SET_SRC (set), 0));
4572 op0 = fold_rtx (XEXP (XEXP (SET_SRC (set), 0), 0), insn);
4573 op1 = fold_rtx (XEXP (XEXP (SET_SRC (set), 0), 1), insn);
4833 struct set
4877 /* Records what this insn does to set CC0. */
4888 struct set *sets = (struct set *) 0;
4893 Record all the SETs in the array `set' and count them.
4909 sets = alloca (sizeof (struct set));
4923 /* Don't count call-insns, (set (reg 0) (call ...)), as a set.
4944 sets = alloca (lim * sizeof (struct set));
5036 is handled specially for this case, and if it isn't set, then there will
5095 and set set[i] to zero so they will be ignored
5266 table, also set `sets[i].src_const_hash'). */
5301 isn't, set ELT to it. */
5653 /* We don't normally have an insn matching (set (pc) (pc)), so
5890 /* If only one set in a JUMP_INSN and it is now a no-op, we can delete
5897 /* No more processing for this set. */
5971 /* If setting CC0, record what it was set to, or a constant, if it
5972 is equivalent to a constant. If it is being set to a floating-point
6017 /* Check to see if src_eqv_elt is the same as a set source which
6018 does not yet have an elt, and if so set the elt of the set source
6146 /* Now invalidate everything set by this instruction.
6147 If a SUBREG or other funny destination is being set,
6149 a part of which is being set. */
6272 /* Don't record values of destinations set inside a libcall block
6273 since we might delete the libcall. Things should have been set
6292 /* STRICT_LOW_PART isn't part of the value BEING set,
6314 /* If we have (set (subreg:m1 (reg:m2 foo) 0) (bar:m1)), M1 is no
6316 we are also doing (set (reg:m2 foo) (subreg:m2 (bar:m1) 0)) so
6409 /* Special handling for (set REG0 REG1) where REG0 is the
6412 (set REG1 REG0) and replace REG1 with REG0 in the previous insn
6423 register to be set in the middle of a libcall, and we then get bad code
6496 /* If the previous insn set CC0 and this insn no longer references CC0,
6692 invalidate_skipped_set (rtx dest, rtx set, void *data ATTRIBUTE_UNUSED)
6710 if (GET_CODE (set) == CLOBBER
6754 path size is specified, the block should be rescanned and a different set
6844 registers set in the block when following the jump. */
6939 /* If all jumps in the path are not taken, set our path length to zero
7213 /* ??? Perhaps it would be smarter to set TO
7308 /* Count the number of times registers are used (not set) in X.
7315 DEST is set to pc_rtx for a trapping insn, which means that we must count
7435 /* Return true if set is live. */
7437 set_live_p (rtx set, rtx insn ATTRIBUTE_UNUSED, /* Only used with HAVE_cc0. */
7444 if (set_noop_p (set))
7448 else if (GET_CODE (SET_DEST (set)) == CC0
7449 && !side_effects_p (SET_SRC (set))
7455 else if (!REG_P (SET_DEST (set))
7456 || REGNO (SET_DEST (set)) < FIRST_PSEUDO_REGISTER
7457 || counts[REGNO (SET_DEST (set))] != 0
7458 || side_effects_p (SET_SRC (set)))
7498 rtx note, set, new;
7509 set = single_set (insn);
7510 if (!set)
7520 if (validate_change (insn, &SET_SRC (set), new, 0))
7530 new = force_const_mem (GET_MODE (SET_DEST (set)), new);
7531 if (new && validate_change (insn, &SET_SRC (set), new, 0))
7567 /* Go from the last insn to the first and delete insns that only set unused
7694 register which is set to CC_SRC. Look through the successors of BB
7744 rtx set;
7755 set = single_set (insn);
7756 if (set
7757 && REG_P (SET_DEST (set))
7758 && REGNO (SET_DEST (set)) == REGNO (cc_reg))
7765 set_mode = GET_MODE (SET_SRC (set));
7767 if (rtx_equal_p (cc_src, SET_SRC (set)))
7770 && GET_CODE (SET_SRC (set)) == COMPARE
7773 XEXP (SET_SRC (set), 0))
7775 XEXP (SET_SRC (set), 1)))
7856 /* Now INSN_COUNT is the number of instructions we found which set
7918 successor blocks for instructions which set the condition
7941 rtx set;
7945 set = single_set (insn);
7946 if (set
7947 && REG_P (SET_DEST (set))
7948 && REGNO (SET_DEST (set)) == REGNO (cc_reg))
7951 cc_src = SET_SRC (set);
7967 register is set, and CC_SRC is still meaningful at the end of