Lines Matching refs:XEXP
296 for (it = reg_equiv_alt_mem_list [regno]; it; it = XEXP (it, 1))
297 if (rtx_equal_p (XEXP (it, 0), mem))
612 mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
630 find_reloads_address (mode, &loc, XEXP (loc, 0), &XEXP (loc, 0),
766 && MATCHES (XEXP (rld[i].in, 0), in))
769 && MATCHES (XEXP (in, 0), rld[i].in)))
955 switch (GET_CODE (XEXP (in, 0)))
958 in = replace_equiv_address_nv (in, XEXP (XEXP (in, 0), 0));
962 out = replace_equiv_address_nv (out, XEXP (XEXP (out, 0), 0));
1189 && reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
1527 for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1529 && REG_P (XEXP (note, 0))
1530 && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER
1531 && reg_mentioned_p (XEXP (note, 0), in)
1534 && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1536 ORIGINAL_REGNO (XEXP (note, 0))))
1562 <= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
1843 for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
1845 && REG_P (XEXP (note, 0))
1846 && ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
1848 && REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1849 && HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
1851 REGNO (XEXP (note, 0)))
1852 && (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
1853 <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
1859 REGNO (XEXP (note, 0))))
1863 REGNO (XEXP (note, 0)))))))
1864 && ! fixed_regs[REGNO (XEXP (note, 0))]
1867 && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
1869 ORIGINAL_REGNO (XEXP (note, 0)))))
1873 REGNO (XEXP (note, 0)));
2208 return operands_match_p (XEXP (x, 0), y);
2217 return operands_match_p (x, XEXP (y, 0)) ? 2 : 0;
2237 return XEXP (x, 0) == XEXP (y, 0);
2266 val = operands_match_p (XEXP (x, i), XEXP (y, i));
2323 rtx addr = XEXP (x, 0);
2328 val.base = XEXP (addr, 0);
2337 if (GET_CODE (XEXP (addr, 1)) == PLUS
2338 && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
2339 && CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
2341 val.base = XEXP (addr, 0);
2342 val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
2343 val.end = INTVAL (XEXP (XEXP (addr, 1), 1));
2351 addr = XEXP (addr, 0);
2356 if (CONSTANT_P (XEXP (addr, 0)))
2358 base = XEXP (addr, 1);
2359 offset = XEXP (addr, 0);
2361 else if (CONSTANT_P (XEXP (addr, 1)))
2363 base = XEXP (addr, 0);
2364 offset = XEXP (addr, 1);
2374 offset = XEXP (offset, 0);
2377 if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
2379 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
2380 offset = XEXP (offset, 0);
2382 else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
2384 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
2385 offset = XEXP (offset, 1);
2794 XEXP (recog_data.operand[i], 0),
2795 &XEXP (recog_data.operand[i], 0),
2956 operand = XEXP (operand, 0);
3210 && (GET_CODE (XEXP (operand, 0)) == PRE_DEC
3211 || GET_CODE (XEXP (operand, 0)) == POST_DEC))
3218 && (GET_CODE (XEXP (operand, 0)) == PRE_INC
3219 || GET_CODE (XEXP (operand, 0)) == POST_INC))
3234 && !(REG_P (XEXP (operand, 0))
3236 || reg_equiv_address[REGNO (XEXP (operand, 0))] != 0)))
3865 && CONST_POOL_OK_P (XEXP (recog_data.operand[i], 1))
3866 && (PREFERRED_RELOAD_CLASS (XEXP (recog_data.operand[i], 1),
3872 XEXP (recog_data.operand[i], 1));
3874 XEXP (recog_data.operand[i], 0), tem);
3909 address_mode = GET_MODE (XEXP (recog_data.operand[i], 0));
3914 = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX,
3915 &XEXP (recog_data.operand[i], 0), (rtx*) 0,
4132 && !find_reg_note (insn, REG_LABEL, XEXP (substitution, 0)))
4134 XEXP (substitution, 0),
4186 && GET_CODE (XEXP (PATTERN (insn), 0)) == CONST_INT)
4590 i = find_reloads_address (GET_MODE (x), &x, XEXP (x, 0), &XEXP (x, 0),
4604 i = find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
4666 XEXP (reg_equiv_mem[regno], 0))
4677 rtx new_part = find_reloads_toplev (XEXP (x, i), opnum, type,
4685 if (new_part != XEXP (x, i) && ! CONSTANT_P (new_part) && ! copied)
4690 XEXP (x, i) = new_part;
4705 = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
4800 if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
4804 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
4805 &XEXP (tem, 0), opnum,
4817 && (REG_P (XEXP (tem, 0))
4818 || (GET_CODE (XEXP (tem, 0)) == PLUS
4819 && REG_P (XEXP (XEXP (tem, 0), 0))
4820 && CONSTANT_P (XEXP (XEXP (tem, 0), 1)))))
4871 && GET_CODE (XEXP (ad, 1)) == CONST_INT
4872 && REG_P (XEXP (ad, 0))
4873 && reg_equiv_constant[REGNO (XEXP (ad, 0))] == 0)
4898 XEXP (*memrefloc, 0) = ad;
4899 move_replacements (&ad, &XEXP (*memrefloc, 0));
4911 loc = &XEXP (ad, 0);
4926 find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
4935 copy_replacements (tem, XEXP (*memrefloc, 0));
4936 loc = &XEXP (*memrefloc, 0);
4938 loc = &XEXP (*loc, 0);
4946 || (GET_CODE (XEXP (tem, 0)) == SYMBOL_REF && ! indirect_symref_ok)
4947 || MEM_P (XEXP (tem, 0))
4948 || ! (REG_P (XEXP (tem, 0))
4949 || (GET_CODE (XEXP (tem, 0)) == PLUS
4950 && REG_P (XEXP (XEXP (tem, 0), 0))
4951 && GET_CODE (XEXP (XEXP (tem, 0), 1)) == CONST_INT)))
4971 && REG_P (XEXP (ad, 0))
4972 && REGNO (XEXP (ad, 0)) < FIRST_PSEUDO_REGISTER
4973 && GET_CODE (XEXP (ad, 1)) == CONST_INT
4974 && regno_ok_for_base_p (REGNO (XEXP (ad, 0)), mode, PLUS,
4982 loc = &XEXP (*memrefloc, 0);
4984 loc = &XEXP (*loc, 0);
4994 find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1),
5045 inner_code = GET_CODE (XEXP (ad, 0));
5047 && GET_CODE (XEXP (ad, 1)) == CONST_INT
5051 operand = XEXP (XEXP (ad, 0), op_index);
5055 addend = XEXP (XEXP (ad, 0), 1 - op_index);
5068 &XEXP (XEXP (ad, 0), 1 - op_index)))
5073 offset_reg = plus_constant (operand, INTVAL (XEXP (ad, 1)));
5076 if (GET_CODE (XEXP (ad, 0)) == PLUS)
5087 find_reloads_address_part (XEXP (ad, op_index),
5088 &XEXP (ad, op_index), cls,
5091 XEXP (ad, 1 - op_index), 1, GET_CODE (ad),
5092 GET_CODE (XEXP (ad, op_index)),
5093 &XEXP (ad, 1 - op_index), opnum,
5133 loc = &XEXP (*memrefloc, 0);
5135 loc = &XEXP (*loc, 0);
5202 if (XEXP (ad, 0) == frame_pointer_rtx
5203 && GET_CODE (XEXP (ad, 1)) == CONST_INT)
5214 XEXP (ad, i) = subst_reg_equivs (XEXP (ad, i), insn);
5245 if (GET_CODE (x) == PLUS && CONSTANT_P (XEXP (x, 1)))
5246 return form_sum (XEXP (x, 0), form_sum (XEXP (x, 1), y));
5250 if (GET_CODE (y) == PLUS && CONSTANT_P (XEXP (y, 1)))
5251 return form_sum (form_sum (x, XEXP (y, 0)), XEXP (y, 1));
5258 x = XEXP (x, 0);
5260 y = XEXP (y, 0);
5291 op0 = XEXP (addr, 0), op1 = XEXP (addr, 1), op2 = 0;
5313 op2 = XEXP (op1, 1), op1 = XEXP (op1, 0);
5315 op2 = op1, op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5346 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
5348 && (int) REGNO (XEXP (link, 0)) == regno)
5349 push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5407 rtx orig_op0 = XEXP (x, 0);
5408 rtx orig_op1 = XEXP (x, 1);
5447 find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5459 &XEXP (x, 0), opnum, type, ind_levels,
5462 &XEXP (x, 1), opnum, type, ind_levels,
5470 &XEXP (x, 0), opnum, type, ind_levels,
5473 &XEXP (x, 1), opnum, type, ind_levels,
5480 &XEXP (x, 1), opnum, type, ind_levels,
5486 &XEXP (x, 0), opnum, type, ind_levels,
5499 &XEXP (x, 0), opnum, type, ind_levels,
5503 &XEXP (x, 1), opnum, type, ind_levels,
5507 &XEXP (x, 0), opnum, type, ind_levels,
5511 &XEXP (x, 1), opnum, type, ind_levels,
5516 &XEXP (x, 0), opnum, type, ind_levels,
5519 &XEXP (x, 1), opnum, type, ind_levels,
5527 &XEXP (x, 0), opnum, type, ind_levels,
5530 &XEXP (x, 1), opnum, type, ind_levels,
5537 &XEXP (x, 1), opnum, type, ind_levels,
5540 &XEXP (x, 0), opnum, type, ind_levels,
5550 rtx op0 = XEXP (x, 0);
5551 rtx op1 = XEXP (x, 1);
5563 gcc_assert (op0 == XEXP (op1, 0));
5575 if (REG_P (XEXP (op1, 1)))
5576 if (!REGNO_OK_FOR_INDEX_P (REGNO (XEXP (op1, 1))))
5577 find_reloads_address_1 (mode, XEXP (op1, 1), 1, code, SCRATCH,
5578 &XEXP (op1, 1), opnum, RELOAD_OTHER,
5581 gcc_assert (REG_P (XEXP (op1, 0)));
5583 regno = REGNO (XEXP (op1, 0));
5584 index_code = GET_CODE (XEXP (op1, 1));
5596 rtx tem = make_memloc (XEXP (x, 0), regno);
5607 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5608 &XEXP (tem, 0), opnum,
5617 reloadnum = push_reload (tem, tem, &XEXP (x, 0),
5618 &XEXP (op1, 0),
5635 reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
5636 &XEXP (op1, 0), &XEXP (x, 0),
5651 if (REG_P (XEXP (x, 0)))
5653 int regno = REGNO (XEXP (x, 0));
5666 rtx tem = make_memloc (XEXP (x, 0), regno);
5676 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5677 &XEXP (tem, 0), opnum, type,
5714 rtx equiv = (MEM_P (XEXP (x, 0))
5715 ? XEXP (x, 0)
5734 loc = &XEXP (x_orig, 0);
5735 x = XEXP (x, 0);
5750 = find_inc_amount (PATTERN (this_insn), XEXP (x_orig, 0));
5755 update_auto_inc_notes (this_insn, REGNO (XEXP (x_orig, 0)),
5761 else if (MEM_P (XEXP (x, 0)))
5768 rtx tem ATTRIBUTE_UNUSED = XEXP (x, 0);
5781 find_reloads_address (GET_MODE (x), &XEXP (x, 0),
5782 XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
5789 = find_inc_amount (PATTERN (this_insn), XEXP (x, 0));
5793 push_replacement (&XEXP (link, 0), reloadnum, VOIDmode);
5809 find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0),
5810 context, code, SCRATCH, &XEXP (x, 0), opnum,
5830 find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5868 find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
5869 &XEXP (x, 0), opnum, ADDR_TYPE (type),
5954 find_reloads_address_1 (mode, XEXP (x, i), context, code, SCRATCH,
5955 &XEXP (x, i), opnum, type, ind_levels, insn);
5991 find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
5996 && CONSTANT_P (XEXP (x, 1))
5997 && (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
5998 || PREFERRED_RELOAD_CLASS (XEXP (x, 1), class) == NO_REGS))
6002 tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
6003 x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
6004 find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
6073 XEXP (tem, 0) = plus_constant (XEXP (tem, 0), offset);
6083 base = XEXP (tem, 0);
6086 if (GET_CODE (XEXP (base, 1)) == CONST_INT
6087 && INTVAL (XEXP (base, 1)) % outer_size != 0)
6089 base = XEXP (base, 0);
6098 XEXP (tem, 0), &XEXP (tem, 0),
6115 && strict_memory_address_p (orig_mode, XEXP (tem, 0))
6117 XEXP (tem, 0)))
6118 push_reload (XEXP (tem, 0), NULL_RTX, &XEXP (tem, 0), (rtx*) 0,
6120 GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0,
6191 XEXP (*r->where, 0),
6193 JUMP_LABEL (insn) = XEXP (*r->where, 0);
6288 copy_replacements_1 (&XEXP (x, i), &XEXP (y, i), orig_replacements);
6367 rtx x = find_replacement (&XEXP (*loc, 0));
6368 rtx y = find_replacement (&XEXP (*loc, 1));
6370 if (x != XEXP (*loc, 0) || y != XEXP (*loc, 1))
6476 if (fmt[i] == 'e' && loc != &XEXP (x, i))
6480 x = XEXP (x, 0);
6485 XEXP (x, i), loc))
6518 x = XEXP (x, 0);
6564 in = XEXP (in, 0);
6569 || reg_overlap_mentioned_for_reload_p (x, XEXP (in, 0))
6570 || reg_overlap_mentioned_for_reload_p (x, XEXP (in, 1)));
6571 else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
6572 || reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
6600 && (MEM_P (XEXP (x, i))
6601 || refers_to_mem_for_reload_p (XEXP (x, i))))
6658 enum rtx_code code = GET_CODE (XEXP (goal, 0));
6681 && XEXP (goal, 0) == stack_pointer_rtx
6682 && CONSTANT_P (XEXP (goal, 1)))
6685 && XEXP (goal, 0) == frame_pointer_rtx
6686 && CONSTANT_P (XEXP (goal, 1)))
6747 && ((rtx_equal_p (XEXP (tem, 0), goal)
6751 && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6752 && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
6755 = operand_subword (XEXP (tem, 0), 0, 0,
6765 && GET_CODE (XEXP (tem, 0)) == CONST_DOUBLE
6766 && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
6768 && 0 != (goaltry = operand_subword (XEXP (tem, 0), 1, 0,
6879 goal_mem_addr_varies = !CONSTANT_ADDRESS_P (XEXP (goal, 0));
6934 dest = XEXP (dest, 0);
6977 dest = XEXP (dest, 0);
7016 for (link = CALL_INSN_FUNCTION_USAGE (p); XEXP (link, 1) != 0;
7017 link = XEXP (link, 1))
7019 pat = XEXP (link, 0);
7060 for (link = REG_NOTES (p); link; link = XEXP (link, 1))
7062 && REG_P (XEXP (link, 0)))
7064 int incno = REGNO (XEXP (link, 0));
7070 && reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
7094 rtx addr = XEXP (x, 0);
7099 && XEXP (addr, 0) == inced)
7103 && GET_CODE (XEXP (addr, 1)) == PLUS
7104 && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
7105 && XEXP (addr, 0) == inced
7106 && GET_CODE (XEXP (XEXP (addr, 1), 1)) == CONST_INT)
7108 i = INTVAL (XEXP (XEXP (addr, 1), 1));
7118 int tem = find_inc_amount (XEXP (x, i), inced);
7153 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
7156 unsigned int test = (int) REGNO (XEXP (link, 0));
7186 && REG_P (XEXP (PATTERN (insn), 0)))
7188 unsigned int test = REGNO (XEXP (PATTERN (insn), 0));
7205 && REG_P (XEXP (elt, 0)))
7207 unsigned int test = REGNO (XEXP (elt, 0));