Lines Matching refs:REGNO
539 unsigned int regno = REGNO (x);
563 || REGNO (regno_reg_rtx[regno]) != regno);
718 unsigned regno = REGNO (SET_DEST (set));
937 && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
940 && (REGNO (XEXP (XEXP (x, 0), 0))
1132 else if (reg && REG_P (reg) && (int)REGNO (reg) != i)
1216 && (REGNO (SET_SRC (PATTERN (insn)))
1217 == REGNO (SET_DEST (PATTERN (insn)))))
1344 SET_HARD_REG_BIT (clobbered, REGNO (XEXP (t, 0)));
1493 && REGNO (SET_SRC (set)) >= FIRST_PSEUDO_REGISTER)
1495 && reg_renumber[REGNO (SET_SRC (set))] < 0
1496 && reg_renumber[REGNO (SET_DEST (set))] < 0
1497 && reg_equiv_memory_loc (REGNO (SET_SRC (set))) != NULL
1498 && reg_equiv_memory_loc (REGNO (SET_DEST (set))) != NULL
1499 && rtx_equal_p (reg_equiv_memory_loc (REGNO (SET_SRC (set))),
1500 reg_equiv_memory_loc (REGNO (SET_DEST (set)))))))
1504 ira_mark_memory_move_deletion (REGNO (SET_DEST (set)),
1505 REGNO (SET_SRC (set)));
1591 && reg_renumber[REGNO (SET_DEST (set))] < 0
1592 && (reg_equiv_constant (REGNO (SET_DEST (set)))
1593 || reg_equiv_invariant (REGNO (SET_DEST (set)))))
1595 unsigned regno = REGNO (SET_DEST (set));
1903 if (rl->in && REG_P (rl->in) && REGNO (rl->in) == regno)
1905 if (rl->out && REG_P (rl->out) && REGNO (rl->out) == regno)
1976 chain->rld[i].regno = REGNO (chain->rld[i].reg_rtx);
2111 && find_regno_note (insn, REG_DEAD, REGNO (prev_dest))
2298 pseudo-reg number REGNO, accessed in MODE. */
2314 used by pseudo-reg number REGNO. */
2492 && REGNO (x) >= FIRST_PSEUDO_REGISTER
2493 && reg_equiv_init (REGNO (x))
2494 && reg_equiv_invariant (REGNO (x)))
2496 rtx t = reg_equiv_invariant (REGNO (x));
2503 ira_adjust_equiv_reg_cost (REGNO (x), -cost * freq);
2566 regno = REGNO (x);
2585 /* There exists at least one use of REGNO that cannot be
2611 && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
2664 && REGNO (new1) >= FIRST_PSEUDO_REGISTER
2665 && reg_renumber[REGNO (new1)] < 0
2667 && reg_equiv_constant (REGNO (new1)) != 0)
2668 new1 = reg_equiv_constant (REGNO (new1));
2670 && REGNO (new0) >= FIRST_PSEUDO_REGISTER
2671 && reg_renumber[REGNO (new0)] < 0
2672 && reg_equiv_constant (REGNO (new0)) != 0)
2673 new0 = reg_equiv_constant (REGNO (new0));
2695 && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
2837 && reg_equiv_memory_loc (REGNO (SUBREG_REG (x))) != 0)
2989 regno = REGNO (x);
3078 && reg_equiv_memory_loc (REGNO (SUBREG_REG (x))) != 0)
3180 if (code == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
3284 if (!REG_P (reg) || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
3563 && REGNO (SET_DEST (old_set)) < FIRST_PSEUDO_REGISTER)
4072 i = REGNO (SET_DEST (set));
4161 /* Kick all pseudos out of hard register REGNO.
4372 unsigned int regno = REGNO (SUBREG_REG (x));
4647 REGNO (rld[i].reg_rtx))
4650 && ((unsigned) reg_reloaded_contents[REGNO (rld[i].reg_rtx)]
4651 == REGNO (XEXP (in_reg, 0))))
4705 REGNO (reload_reg));
4707 REGNO (XEXP (in_reg, 0)));
4715 REGNO (rld[i].reg_rtx))
4718 && ((unsigned) reg_reloaded_contents[REGNO (rld[i].reg_rtx)]
4719 == REGNO (XEXP (in_reg, 0))))
4722 REGNO (rld[i].reg_rtx));
4724 REGNO (XEXP (in_reg, 0)));
4729 int in_regno = REGNO (XEXP (in_reg, 0));
4736 in_hard_regno = REGNO (reg_last_reload_reg[in_regno]);
4840 regno = REGNO (x);
4945 /* Mark reg REGNO as in use for a reload of the sort spec'd by OPNUM and
5003 /* Similarly, but show REGNO is no longer in use for a reload. */
5110 /* 1 if reg REGNO is free as a reload reg for a reload of the sort
5271 /* Return 1 if the value in reload reg REGNO, as used by the reload with
5272 the number RELOADNUM, is still available in REGNO at the end of the insn.
5296 if (regno >= REGNO (reg) && regno < END_REGNO (reg))
5444 for (i = REGNO (reg); i < END_REGNO (reg); i++)
5941 /* Return 1 if the value in reload reg REGNO, as used by a reload
5952 test should not be for using register REGNO as reload register, but
5953 for copying from register REGNO into the reload register.
6272 mark_reload_reg_in_use (REGNO (rld[i].reg_rtx), rld[i].opnum,
6352 reload_spill_index[j] = REGNO (rld[j].reg_rtx);
6461 regno = REGNO (rld[r].in);
6466 regno = REGNO (rld[r].in_reg);
6472 regno = REGNO (SUBREG_REG (rld[r].in_reg));
6486 regno = REGNO (XEXP (rld[r].in_reg, 0));
6492 /* This won't work, since REGNO can be a pseudo reg number.
6508 (REGNO (reg_last_reload_reg[regno]),
6515 i = REGNO (last_reg);
6658 regno = REGNO (equiv);
6955 && REGNO (tem) < FIRST_PSEUDO_REGISTER
6957 (rld[r].inmode, REGNO_REG_CLASS (REGNO (tem)),
7006 int nregno = REGNO (rld[r].out_reg);
7078 unsigned regno = REGNO (reg);
7155 && REGNO (oldequiv) < FIRST_PSEUDO_REGISTER
7156 && spill_reg_store[REGNO (oldequiv)]
7158 && (dead_or_set_p (insn, spill_reg_stored_to[REGNO (oldequiv)])
7159 || rtx_equal_p (spill_reg_stored_to[REGNO (oldequiv)],
7161 delete_output_reload (insn, j, REGNO (oldequiv), reloadreg);
7232 && REGNO (old) >= FIRST_PSEUDO_REGISTER
7237 && free_for_value_p (REGNO (reloadreg), rl->mode, rl->opnum,
7272 && REGNO (SET_SRC (PATTERN (temp))) < FIRST_PSEUDO_REGISTER)
7274 spill_reg_store[REGNO (SET_SRC (PATTERN (temp)))] = 0;
7275 spill_reg_stored_to[REGNO (SET_SRC (PATTERN (temp)))] = 0;
7280 if (REG_N_DEATHS (REGNO (old)) == 1
7281 && REG_N_SETS (REGNO (old)) == 1)
7283 reg_renumber[REGNO (old)] = REGNO (reloadreg);
7286 ira_mark_allocation_change (REGNO (old));
7287 alter_reg (REGNO (old), -1, false);
7348 && REGNO (tmp) >= FIRST_PSEUDO_REGISTER
7349 && (reg_equiv_memory_loc (REGNO (tmp)) != 0
7350 || reg_equiv_constant (REGNO (tmp)) != 0))
7352 if (! reg_equiv_mem (REGNO (tmp))
7357 real_oldequiv = reg_equiv_mem (REGNO (tmp));
7364 && REGNO (tmp) >= FIRST_PSEUDO_REGISTER
7365 && (reg_equiv_memory_loc (REGNO (tmp)) != 0
7366 || reg_equiv_constant (REGNO (tmp)) != 0))
7368 if (! reg_equiv_mem (REGNO (tmp))
7373 real_old = reg_equiv_mem (REGNO (tmp));
7542 && REGNO (oldequiv) >= FIRST_PSEUDO_REGISTER
7543 && (reg_equiv_memory_loc (REGNO (oldequiv)) != 0
7544 || reg_equiv_constant (REGNO (oldequiv)) != 0))
7547 && (REGNO (SUBREG_REG (oldequiv))
7549 && ((reg_equiv_memory_loc (REGNO (SUBREG_REG (oldequiv))) != 0)
7550 || (reg_equiv_constant (REGNO (SUBREG_REG (oldequiv))) != 0)))
7553 REGNO_REG_CLASS (REGNO (reloadreg)))
7607 if (REG_P (old) && REGNO (old) >= FIRST_PSEUDO_REGISTER
7608 && reg_equiv_mem (REGNO (old)) != 0)
7609 real_old = reg_equiv_mem (REGNO (old));
7694 || !((REGNO (old) < FIRST_PSEUDO_REGISTER)
7695 && regno_clobbered_p (REGNO (old), insn, rl->mode, 0)))
7719 int src = REGNO (SET_SRC (set));
7755 REGNO (s_reg));
7756 new_spill_reg_store[REGNO (s_reg)] = next;
7760 new_spill_reg_store[REGNO (rl_reg_rtx)] = p;
7863 && spill_reg_store[REGNO (reg_rtx)] != 0
7868 && !HARD_REGISTER_P (spill_reg_stored_to[REGNO (reg_rtx)])
7873 && (dead_or_set_p (insn, spill_reg_stored_to[REGNO (reg_rtx)])
7874 || rtx_equal_p (spill_reg_stored_to[REGNO (reg_rtx)], rl->out_reg)))
7875 delete_output_reload (insn, j, REGNO (reg_rtx), reg_rtx);
7909 rl->out = gen_rtx_REG (mode, REGNO (reg_rtx));
7920 && REGNO (pseudo) >= FIRST_PSEUDO_REGISTER
7921 && reg_last_reload_reg[REGNO (pseudo)])
7923 int pseudo_no = REGNO (pseudo);
7924 int last_regno = REGNO (reg_last_reload_reg[pseudo_no]);
8020 for (i = REGNO (rld[j].reg_rtx); i < END_REGNO (rld[j].reg_rtx); i++)
8105 && REGNO (reg) >= FIRST_PSEUDO_REGISTER
8106 && !REGNO_REG_SET_P (®_has_output_reload, REGNO (reg)))
8108 int nregno = REGNO (reg);
8112 int last_regno = REGNO (reg_last_reload_reg[nregno]);
8161 int regno = REGNO (reg);
8168 int out_regno = REGNO (out);
8213 REGNO (rld[r].in)))
8216 REGNO (rld[r].in_reg))))
8233 regno = REGNO (reg);
8236 && REGNO (rld[r].in) >= FIRST_PSEUDO_REGISTER)
8242 in_regno = REGNO (in);
8300 int out_regno = REGNO (out);
8334 store_insn = new_spill_reg_store[REGNO (src_reg)];
8360 && REGNO (src_reg) < FIRST_PSEUDO_REGISTER)
8366 src_regno = REGNO (src_reg);
8426 int out_regno = REGNO (XEXP (out, 0));
8561 && REGNO (out) == REGNO (XEXP (in, 1)))
8590 && REGNO (op1) >= FIRST_PSEUDO_REGISTER)
8624 && REGNO (tem1) < FIRST_PSEUDO_REGISTER
8625 && REGNO (tem2) < FIRST_PSEUDO_REGISTER
8627 REGNO_REG_CLASS (REGNO (tem1)),
8628 REGNO_REG_CLASS (REGNO (tem2))))
8662 out_moded = gen_rtx_REG (GET_MODE (op1), REGNO (out));
8736 substed = reg_equiv_memory_loc (REGNO (reg));
8769 for (rtx i1 = reg_equiv_alt_mem_list (REGNO (reg)); i1; i1 = XEXP (i1, 1))
8777 regno = REGNO (reg);
8822 && REG_N_DEATHS (REGNO (reg)) == 1
8823 && REG_N_SETS (REGNO (reg)) == 1
8824 && REG_BASIC_BLOCK (REGNO (reg)) >= NUM_FIXED_BLOCKS
8825 && find_regno_note (insn, REG_DEAD, REGNO (reg)))
8870 reg_renumber[REGNO (reg)] = REGNO (new_reload_reg);
8873 ira_mark_allocation_change (REGNO (reg));
8874 alter_reg (REGNO (reg), -1, false);
8948 if (spill_reg_order[REGNO (x)] < 0)
9027 reg_reloaded_contents[REGNO (dst)] = -1;
9060 reg_last_reload_reg[REGNO (incloc)] = 0;