Lines Matching refs:GET_MODE
345 && (GET_MODE_SIZE (GET_MODE (x))
346 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
349 reload_mode = GET_MODE (x);
817 && GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
818 && ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
819 != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
923 inmode = GET_MODE (in);
925 outmode = GET_MODE (out);
1002 && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (in)), inmode, class)
1011 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1014 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1017 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1018 && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in)))
1019 && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != UNKNOWN)
1023 < GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))
1025 ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) - 1)
1035 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1037 && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1040 [GET_MODE (SUBREG_REG (in))]))
1043 && (secondary_reload_class (1, class, GET_MODE (SUBREG_REG (in)),
1050 (REGNO (SUBREG_REG (in)), GET_MODE (SUBREG_REG (in)), inmode))
1061 gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode));
1063 inmode = GET_MODE (in);
1082 = find_valid_class (inmode, GET_MODE (SUBREG_REG (in)),
1084 GET_MODE (SUBREG_REG (in)),
1086 GET_MODE (in)),
1108 && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SUBREG_REG (out)), outmode, class)
1116 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1119 < GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))
1121 ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) - 1)
1128 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1130 && ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
1133 [GET_MODE (SUBREG_REG (out))]))
1136 && (secondary_reload_class (0, class, GET_MODE (SUBREG_REG (out)),
1143 GET_MODE (SUBREG_REG (out)),
1153 || GET_MODE_SIZE (GET_MODE (out))
1156 outmode = GET_MODE (out);
1176 find_valid_class (outmode, GET_MODE (SUBREG_REG (out)),
1178 GET_MODE (SUBREG_REG (out)),
1180 GET_MODE (out)),
1198 in = gen_rtx_REG (GET_MODE (in), subreg_regno (in));
1205 out = gen_rtx_REG (GET_MODE (out), subreg_regno (out));
1235 class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (in)), class);
1240 class = LIMIT_RELOAD_CLASS (GET_MODE (SUBREG_REG (out)), class);
1556 && (((GET_MODE_SIZE (GET_MODE (in)) + (UNITS_PER_WORD - 1))
1558 == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
1562 <= GET_MODE_SIZE (GET_MODE (XEXP (note, 0))))
1853 <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
1926 GET_MODE (SUBREG_REG (out)),
1928 GET_MODE (out));
1936 GET_MODE (SUBREG_REG (in)),
1938 GET_MODE (in));
2012 (GET_MODE (out) != VOIDmode
2013 ? GET_MODE (out) : outmode))
2099 && r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
2167 GET_MODE (SUBREG_REG (x)),
2169 GET_MODE (x));
2180 GET_MODE (SUBREG_REG (y)),
2182 GET_MODE (y));
2191 if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
2192 && SCALAR_INT_MODE_P (GET_MODE (x))
2194 i += hard_regno_nregs[i][GET_MODE (x)] - 1;
2195 if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
2196 && SCALAR_INT_MODE_P (GET_MODE (y))
2198 j += hard_regno_nregs[j][GET_MODE (y)] - 1;
2227 if (GET_MODE (x) != GET_MODE (y))
2329 val.start = -GET_MODE_SIZE (GET_MODE (x));
2330 val.end = GET_MODE_SIZE (GET_MODE (x));
2379 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
2384 base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
2389 base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2395 base = gen_rtx_PLUS (GET_MODE (base), base, offset);
2400 base = gen_rtx_CONST (GET_MODE (base), base);
2405 val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
2421 val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
2434 val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
2624 && REGISTER_MOVE_COST (GET_MODE (SET_SRC (body)),
2787 operand_mode[i] = GET_MODE (recog_data.operand[i]);
2792 = find_reloads_address (GET_MODE (recog_data.operand[i]),
2819 && (GET_MODE_SIZE (GET_MODE (reg))
2820 >= GET_MODE_SIZE (GET_MODE (op))))
2851 operand_mode[i] = GET_MODE (recog_data.operand[i]);
2973 GET_MODE (SUBREG_REG (operand)),
2975 GET_MODE (operand)))
2978 GET_MODE (SUBREG_REG (operand)),
2980 GET_MODE (operand));
3015 && (((GET_MODE_BITSIZE (GET_MODE (operand))
3018 > GET_MODE_SIZE (GET_MODE (operand))))
3022 && (GET_MODE_SIZE (GET_MODE (operand))
3025 > GET_MODE_SIZE (GET_MODE (operand)))
3026 && INTEGRAL_MODE_P (GET_MODE (operand))
3027 && LOAD_EXTEND_OP (GET_MODE (operand)) != UNKNOWN)
3281 && (GET_MODE_CLASS (GET_MODE (operand))
3296 && GET_MODE (operand) == VOIDmode))
3307 && GET_MODE (operand) == VOIDmode))
3411 if (GET_MODE (operand) == BLKmode)
3416 offset, GET_MODE (recog_data.operand[i])))
3909 address_mode = GET_MODE (XEXP (recog_data.operand[i], 0));
3920 = GET_MODE_SIZE (GET_MODE (recog_data.operand[i]));
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),
4630 && (tem = gen_lowpart_common (GET_MODE (x),
4639 simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
4640 GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
4660 && (GET_MODE_SIZE (GET_MODE (x))
4661 <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
4665 && (! strict_memory_address_p (GET_MODE (x),
4713 tem = adjust_address_nv (tem, GET_MODE (ad), 0);
4731 rtx reg = gen_rtx_REG (GET_MODE (tem), max_reg_num ());
4800 if (! strict_memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
4804 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
4856 GET_MODE (ad), VOIDmode, 0, 0, opnum, type);
4892 LEGITIMIZE_RELOAD_ADDRESS (ad, GET_MODE (*memrefloc), opnum, type,
4926 find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
4956 base_reg_class (mode, MEM, SCRATCH), GET_MODE (tem),
4995 INDEX_REG_CLASS, GET_MODE (ad), opnum,
5077 ad = gen_rtx_PLUS (GET_MODE (ad),
5081 ad = gen_rtx_LO_SUM (GET_MODE (ad),
5089 GET_MODE (ad), opnum, type, ind_levels);
5230 enum machine_mode mode = GET_MODE (x);
5233 mode = GET_MODE (y);
5422 GET_MODE (SUBREG_REG (orig_op0)),
5424 GET_MODE (orig_op0))));
5434 op1 = gen_rtx_REG (GET_MODE (op1),
5437 GET_MODE (SUBREG_REG (orig_op1)),
5439 GET_MODE (orig_op1))));
5447 find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5451 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5607 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5621 GET_MODE (x), GET_MODE (x), 0,
5633 if (!regno_ok_for_base_p (regno, GET_MODE (x), code, index_code))
5638 GET_MODE (x), GET_MODE (x), 0, 0,
5676 find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
5682 x = gen_rtx_fmt_e (GET_CODE (x), GET_MODE (x), tem);
5719 && memory_operand (equiv, GET_MODE (equiv))
5739 GET_MODE (x), GET_MODE (x), 0, 0,
5747 GET_MODE (x), GET_MODE (x), 0, 0,
5781 find_reloads_address (GET_MODE (x), &XEXP (x, 0),
5787 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5809 find_reloads_address_1 (GET_MODE (XEXP (x, 0)), XEXP (x, 0),
5814 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5830 find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
5834 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5845 GET_MODE (x), opnum, type, ind_levels);
5855 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5868 find_reloads_address (GET_MODE (x), &x, XEXP (x, 0),
5885 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5893 if (regno_clobbered_p (regno, this_insn, GET_MODE (x), 0))
5897 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5918 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
5927 if ((unsigned) CLASS_MAX_NREGS (class, GET_MODE (SUBREG_REG (x)))
5934 GET_MODE (x), VOIDmode, 0, 0, opnum, type);
6002 tem = force_const_mem (GET_MODE (x), XEXP (x, 1));
6003 x = gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0), tem);
6059 unsigned outer_size = GET_MODE_SIZE (GET_MODE (x));
6060 unsigned inner_size = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
6063 enum machine_mode orig_mode = GET_MODE (orig);
6074 PUT_MODE (tem, GET_MODE (x));
6097 reloaded = find_reloads_address (GET_MODE (tem), &tem,
6116 && !strict_memory_address_p (GET_MODE (tem),
6119 base_reg_class (GET_MODE (tem), MEM, SCRATCH),
6120 GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0,
6200 if (GET_MODE (reloadreg) != r->mode && r->mode != VOIDmode)
6209 if (GET_MODE (*r->subreg_loc)
6210 == GET_MODE (SUBREG_REG (reloadreg)))
6220 GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
6222 GET_MODE_SIZE (GET_MODE (*r->subreg_loc)));
6328 if (r->mode != VOIDmode && GET_MODE (reloadreg) != r->mode)
6340 return gen_rtx_REG (GET_MODE (*loc),
6343 GET_MODE (SUBREG_REG (*loc)),
6345 GET_MODE (*loc))));
6346 else if (GET_MODE (reloadreg) == GET_MODE (*loc))
6354 final_offset = (final_offset / GET_MODE_SIZE (GET_MODE (*loc)));
6355 final_offset = (final_offset * GET_MODE_SIZE (GET_MODE (*loc)));
6356 return gen_rtx_SUBREG (GET_MODE (*loc), SUBREG_REG (reloadreg),
6371 return gen_rtx_fmt_ee (GET_CODE (*loc), GET_MODE (*loc), x, y);
6423 ? hard_regno_nregs[r][GET_MODE (x)]
6435 ? hard_regno_nregs[inner_regno][GET_MODE (x)] : 1);
6530 GET_MODE (SUBREG_REG (x)),
6532 GET_MODE (x));
6576 ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
6661 if (flag_float_store && SCALAR_FLOAT_MODE_P (GET_MODE (goal)))
6752 && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
6766 && SCALAR_FLOAT_MODE_P (GET_MODE (XEXP (tem, 0)))
6819 if (GET_MODE (value) != mode)
6869 [GET_MODE (rld[i].reg_rtx)];
6940 xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
6955 && ! push_operand (dest, GET_MODE (dest)))
6960 else if (need_stable_sp && push_operand (dest, GET_MODE (dest)))
6983 xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
7000 && ! push_operand (dest, GET_MODE (dest)))
7006 && push_operand (dest, GET_MODE (dest)))
7028 = hard_regno_nregs[xregno][GET_MODE (dest)];
7043 && ! push_operand (dest, GET_MODE (dest)))
7046 && push_operand (dest, GET_MODE (dest)))
7100 return GET_MODE_SIZE (GET_MODE (x));
7227 if (GET_MODE (reloadreg) == mode)
7233 regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]