Lines Matching defs:mode
667 'T' print the next word of a dp value - same as 'R' in big endian mode.
681 enum machine_mode mode;
754 mode = GET_MODE (x);
755 if (mode == VOIDmode)
756 mode = DImode;
757 if (GET_MODE_SIZE (mode) >= 8)
758 sub = simplify_subreg (SImode, x, mode, 4 * LSW);
781 mode = GET_MODE (x);
782 if (mode == VOIDmode)
783 mode = DImode;
784 if (GET_MODE_SIZE (mode) >= 8)
785 sub = simplify_subreg (SImode, x, mode, 4 * MSW);
900 mode = GET_MODE (x);
910 /* We might see SUBREGs with vector mode registers inside. */
939 - HARD_REGNO_NREGS (regno, mode))
967 && mode == V16SFmode)
970 && mode == V4SFmode)
973 && mode == V2SFmode)
976 && GET_MODE_SIZE (mode) > 4)
1190 prepare_move_operands (rtx operands[], enum machine_mode mode)
1192 if ((mode == SImode || mode == DImode)
1194 && ! ((mode == Pmode || mode == ptr_mode)
1204 && target_reg_operand (operands[0], mode))
1209 operands[1] = legitimize_pic_address (operands[1], mode, temp);
1218 mode, temp);
1219 operands[1] = expand_binop (mode, add_optab, temp,
1230 if (! register_operand (operands[0], mode)
1231 && ! sh_register_operand (operands[1], mode))
1232 operands[1] = copy_to_mode_reg (mode, operands[1]);
1234 if (GET_CODE (operands[0]) == MEM && ! memory_operand (operands[0], mode))
1236 /* This is like change_address_1 (operands[0], mode, 0, 1) ,
1238 rtx new = change_address (operands[0], mode, 0);
1252 operands[1] = copy_to_mode_reg (mode, operands[1]);
1255 if (mode == Pmode || mode == ptr_mode)
1353 enum machine_mode mode;
1383 mode = GET_MODE (sh_compare_op0);
1384 if (mode == VOIDmode)
1385 mode = GET_MODE (sh_compare_op1);
1387 sh_compare_op0 = force_reg (mode, sh_compare_op0);
1391 || (mode == DImode && sh_compare_op1 != const0_rtx)
1392 || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1393 sh_compare_op1 = force_reg (mode, sh_compare_op1);
1395 if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1396 (mode == SFmode ? emit_sf_insn : emit_df_insn)
1415 enum machine_mode mode = GET_MODE (sh_compare_op0);
1417 if (mode == VOIDmode)
1418 mode = GET_MODE (sh_compare_op1);
1420 || mode == DImode
1421 || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1424 sh_compare_op0 = force_reg (mode, sh_compare_op0);
1427 || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1428 sh_compare_op1 = force_reg (mode, sh_compare_op1);
1430 if (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT && code == GE)
1440 if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1445 (mode == SFmode ? emit_sf_insn : emit_df_insn) (insn);
1461 enum machine_mode mode)
1470 if (register_operand (dst, mode)
1471 && register_operand (src, mode))
1811 fputs ("\t.mode\tSHcompact\n", asm_out_file);
1813 fprintf (asm_out_file, "\t.mode\tSHmedia\n\t.abi\t%i\n",
3070 enum machine_mode mode; /* Mode of value. */
3102 add_constant (rtx x, enum machine_mode mode, rtx last_value)
3112 && mode == pool_vector[i].mode)
3155 pool_vector[pool_size].mode = mode;
3196 if (p->mode == HImode)
3213 else if (p->mode == DFmode)
3245 switch (p->mode)
3293 if (p->mode != HImode)
3311 switch (p->mode)
3345 if (p->mode != HImode)
3620 enum machine_mode mode;
3627 mode = GET_MODE (dst);
3629 /* We must explicitly check the mode, because sometimes the
3632 if (mode == HImode
3633 || (mode == SImode && hi_const (src) && REGNO (dst) != FPUL_REG))
3651 && (mode == DFmode || mode == DImode))
3660 found_si += GET_MODE_SIZE (mode);
3662 si_limit -= GET_MODE_SIZE (mode);
3857 /* We don't use rtx_equal_p because we don't care if the mode is
3899 mode is different. */
4749 enum machine_mode mode;
4755 mode = GET_MODE (dst);
4757 if (mode == SImode && hi_const (src)
4762 mode = HImode;
4789 && GET_MODE_SIZE (mode) != 4
4792 lab = add_constant (src, mode, last_float);
4814 newsrc = gen_const_mem (mode,
4830 lab = add_constant (XVECEXP (src, 0, 0), mode, 0);
4838 lab = add_constant (src, mode, 0);
4840 newsrc = gen_const_mem (mode, newsrc);
5286 enum machine_mode mode;
5287 mode = GET_MODE (current_function_return_rtx);
5288 if (BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG)
5289 nreg = HARD_REGNO_NREGS (FIRST_RET_REG, mode);
5574 /* If we can save a lot of saves by switching to double mode, do that. */
5666 /* Must switch to double mode to access these registers. */
5755 unsigned char mode;
5796 entry->mode = VOIDmode;
5813 enum machine_mode mode = REGISTER_NATURAL_MODE (i);
5821 mode = DImode;
5823 if (mode == SFmode && (i % 2) == 1
5827 mode = DFmode;
5835 if ((GET_MODE_SIZE (mode) % (STACK_BOUNDARY / BITS_PER_UNIT) == 0)
5844 offset -= GET_MODE_SIZE (mode);
5846 entry->mode = mode;
5856 entry->mode = DImode;
5862 entry->mode = VOIDmode;
5979 /* ??? Maybe we could save some switching if we can move a mode switch
6031 for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
6033 enum machine_mode mode = entry->mode;
6040 reg_rtx = gen_rtx_REG (mode, reg);
6042 mem_rtx = gen_frame_mem (mode,
6047 GO_IF_LEGITIMATE_ADDRESS (mode, XEXP (mem_rtx, 0), try_pre_dec);
6055 && (offset_in_r0 - offset == GET_MODE_SIZE (mode)
6059 pre_dec = gen_frame_mem (mode, gen_rtx_PRE_DEC (Pmode, r0));
6061 GO_IF_LEGITIMATE_ADDRESS (mode, XEXP (pre_dec, 0),
6070 offset += GET_MODE_SIZE (mode);
6101 offset -= GET_MODE_SIZE (mode);
6102 offset_in_r0 -= GET_MODE_SIZE (mode);
6107 mem_rtx = gen_frame_mem (mode, r0);
6109 mem_rtx = gen_frame_mem (mode,
6170 rtx reg_rtx = gen_rtx_REG (mode, reg);
6172 rtx mem_rtx = gen_frame_mem (mode,
6225 /* If we're lucky, a mode switch in the function body will
6350 for (; entry->mode != VOIDmode; entry--)
6352 enum machine_mode mode = entry->mode;
6357 reg_rtx = gen_rtx_REG (mode, reg);
6359 mem_rtx = gen_frame_mem (mode,
6364 GO_IF_LEGITIMATE_ADDRESS (mode, XEXP (mem_rtx, 0), try_post_inc);
6372 || (offset + GET_MODE_SIZE (mode) != d + d_rounding
6376 post_inc = gen_frame_mem (mode, gen_rtx_POST_INC (Pmode, r0));
6378 GO_IF_LEGITIMATE_ADDRESS (mode, XEXP (post_inc, 0),
6419 offset_in_r0 += GET_MODE_SIZE (mode);
6422 mem_rtx = gen_frame_mem (mode, r0);
6424 mem_rtx = gen_frame_mem (mode,
6441 rtx tmp_reg = gen_rtx_REG (mode, *tmp_pnt);
6499 /* PR_REG will never be live in SHmedia mode, and we don't need to
6569 for (; entry->mode != VOIDmode; entry--)
6936 /* Structures with a single member with a distinct mode are passed
7124 shcompact_byref (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7132 size = GET_MODE_SIZE (mode);
7136 || GET_SH_ARG_CLASS (mode) == SH_ARG_INT
7137 || (GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT
7140 && !SHCOMPACT_FORCE_ON_STACK (mode, type)
7141 && !SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
7148 sh_pass_by_reference (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7151 if (targetm.calls.must_pass_in_stack (mode, type))
7162 cum->byref = shcompact_byref (cum, mode, type, named);
7170 sh_callee_copies (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7177 && ((mode == BLKmode ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode))
7182 sh_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7188 && PASS_IN_REG_P (*cum, mode, type)
7190 && (ROUND_REG (*cum, mode)
7191 + (mode != BLKmode
7192 ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
7194 > NPARM_REGS (mode)))
7195 words = NPARM_REGS (mode) - ROUND_REG (*cum, mode);
7198 && SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
7209 MODE is the argument's machine mode.
7225 sh_function_arg (CUMULATIVE_ARGS *ca, enum machine_mode mode,
7228 if (! TARGET_SH5 && mode == VOIDmode)
7232 && PASS_IN_REG_P (*ca, mode, type)
7237 if (mode == SCmode && TARGET_SH4 && TARGET_LITTLE_ENDIAN
7238 && (! FUNCTION_ARG_SCmode_WART || (ROUND_REG (*ca, mode) & 1)))
7242 BASE_ARG_REG (mode)
7243 + (ROUND_REG (*ca, mode) ^ 1)),
7247 BASE_ARG_REG (mode)
7248 + ((ROUND_REG (*ca, mode) + 1) ^ 1)),
7258 && mode == SFmode)
7259 return gen_rtx_REG (mode, ca->free_single_fp_reg);
7261 regno = (BASE_ARG_REG (mode) + ROUND_REG (*ca, mode))
7262 ^ (mode == SFmode && TARGET_SH4
7265 return gen_rtx_REG (mode, regno);
7271 if (mode == VOIDmode && TARGET_SHCOMPACT)
7276 if (mode == SFmode && ca->free_single_fp_reg)
7277 return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode, ca->free_single_fp_reg);
7279 if ((GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT)
7284 return SH5_PROTOTYPELESS_FLOAT_ARG (*ca, mode);
7286 return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode,
7293 || (! SHCOMPACT_FORCE_ON_STACK (mode, type)
7294 && ! SH5_WOULD_BE_PARTIAL_NREGS (*ca, mode,
7297 return gen_rtx_REG (mode, (FIRST_PARM_REG
7308 of mode MODE and data type TYPE.
7313 sh_function_arg_advance (CUMULATIVE_ARGS *ca, enum machine_mode mode,
7325 : mode);
7430 if (mode == SFmode && ca->free_single_fp_reg)
7439 if (mode == DFmode
7443 + BASE_ARG_REG (mode));
7448 || PASS_IN_REG_P (*ca, mode, type))
7449 (ca->arg_count[(int) GET_SH_ARG_CLASS (mode)]
7450 = (ROUND_REG (*ca, mode)
7451 + (mode == BLKmode
7453 : ROUND_ADVANCE (GET_MODE_SIZE (mode)))));
7494 enum machine_mode mode,
7504 named_parm_regs = (ROUND_REG (*ca, mode)
7505 + (mode == BLKmode
7507 : ROUND_ADVANCE (GET_MODE_SIZE (mode))));
7598 for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
7861 system_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
7901 /* For -m4 and -m4-single-only, mode switching is used. If we are
7903 mode switching. We could check in machine_dependent_reorg for
7904 cases where we know we are in single precision mode, but there is
7915 tertiary_reload_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
7923 tls_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8247 MODE is the mode we are setting it to. */
8249 fpscr_set_from_mem (int mode, HARD_REG_SET regs_live)
8251 enum attr_fp_mode fp_mode = mode;
8393 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
8763 /* Get weight for mode for a set x. */
8765 find_set_regmode_weight (rtx x, enum machine_mode mode)
8767 if (GET_CODE (x) == CLOBBER && register_operand (SET_DEST (x), mode))
8769 if (GET_CODE (x) == SET && register_operand (SET_DEST (x), mode))
8785 find_insn_regmode_weight (rtx insn, enum machine_mode mode)
8792 reg_weight += find_set_regmode_weight (x, mode);
8799 reg_weight += find_set_regmode_weight (x, mode);
8808 if (GET_CODE (note) == REG && GET_MODE (note) == mode)
8817 find_regmode_weight (basic_block b, enum machine_mode mode)
8830 if (mode == SFmode)
8831 INSN_REGMODE_WEIGHT (insn, mode) =
8832 find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DFmode);
8833 else if (mode == SImode)
8834 INSN_REGMODE_WEIGHT (insn, mode) =
8835 find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DImode);
8971 high_pressure (enum machine_mode mode)
8979 if (mode == SFmode)
9487 && FLOAT_MODE_P (insn_data[d->icode].operand[0].mode))
9499 (insn_data[d->icode].operand[opno].mode,
9520 sh_vector_mode_supported_p (enum machine_mode mode)
9523 && ((mode == V2SFmode)
9524 || (mode == V4SFmode)
9525 || (mode == V16SFmode)))
9529 && ((mode == V8QImode)
9530 || (mode == V2HImode)
9531 || (mode == V4HImode)
9532 || (mode == V2SImode)))
9558 (and in mode MODE if that's convenient).
9564 enum machine_mode mode ATTRIBUTE_UNUSED, int ignore)
9582 tmode = insn_data[icode].operand[0].mode;
9611 opmode = insn_data[icode].operand[nop].mode;
9670 /* Return the class of registers for which a mode change from FROM to TO
9725 sh_register_move_cost (enum machine_mode mode,
9734 if (mode == SImode && ! TARGET_SHMEDIA && TARGET_FMOVD
9751 * ((GET_MODE_SIZE (mode) + 7) / 8U));
9787 return 2 * ((GET_MODE_SIZE (mode) + 7) / 8U);
9789 return 2 * ((GET_MODE_SIZE (mode) + 3) / 4U);
10270 enum machine_mode mode)
10303 if (mode != VOIDmode)
10307 && GET_MODE_SIZE (mode) > 4
10308 && BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG);
10320 && (mode == BLKmode
10321 || (GET_MODE_SIZE (mode) > 4
10322 && !(mode == DFmode
10625 replacements[n*2+1] - and that we take mode changes into account.
10759 sh_gen_truncate (enum machine_mode mode, rtx x, int need_sign_ext)
10768 if (inner_mode == mode)
10770 else if (GET_MODE_SIZE (inner_mode) >= GET_MODE_SIZE (mode))
10772 else if (GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (mode)
10779 return gen_rtx_fmt_e (code, mode, x);
10872 enum machine_mode mode, secondary_reload_info *sri)
10878 && immediate_operand ((x), mode)
10880 && mode == SFmode && fldi_ok ()))
10881 switch (mode)
10890 /* ??? If we knew that we are in the appropriate mode -
10902 if (class == FPUL_REGS && immediate_operand (x, mode))
10915 && immediate_operand (x, mode)
10919 if ((mode == QImode || mode == HImode)
10920 && TARGET_SHMEDIA && inqhi_operand (x, mode))
10922 sri->icode = ((mode == QImode)
10934 || (FP_REGISTER_P (REGNO (x)) && mode == SImode
10940 && (mode == SFmode || mode == SImode))
10944 && ! TARGET_SHMEDIA && mode == SImode))