Lines Matching refs:GET_MODE
353 enum machine_mode to_mode = GET_MODE (to);
354 enum machine_mode from_mode = GET_MODE (from);
379 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
398 from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
400 to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
754 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
758 if (GET_MODE (x) != VOIDmode)
759 oldmode = GET_MODE (x);
805 GET_MODE_BITSIZE (GET_MODE (x)))))))))
831 if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)
1457 iter_mode = GET_MODE (size);
1597 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (orig, 0, i), 0));
1603 return gen_rtx_PARALLEL (GET_MODE (orig), gen_rtvec_v (length, tmps));
1615 enum machine_mode m = GET_MODE (orig_src);
1624 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_src));
1626 src = assign_stack_temp (GET_MODE (orig_src), ssize, 0);
1630 src = gen_lowpart (GET_MODE (orig_src), src);
1649 enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1661 BLOCK_REG_PADDING (GET_MODE (orig_src), type, i == start)
1678 || (GET_MODE (orig_src) != mode
1679 && GET_MODE (orig_src) != VOIDmode)))
1681 if (GET_MODE (orig_src) == VOIDmode)
1684 src = gen_reg_rtx (GET_MODE (orig_src));
1700 && GET_MODE (src) == mode
1706 unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
1707 unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
1718 && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode))
1728 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1737 else if (VECTOR_MODE_P (GET_MODE (dst))
1740 int slen = GET_MODE_SIZE (GET_MODE (src));
1743 mem = assign_stack_temp (GET_MODE (src), slen, 0);
1747 else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
1749 tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
1751 || (REG_P (src) && GET_MODE (src) == mode))
1810 d = force_reg (GET_MODE (d), RTVEC_ELT (vec, i));
1816 return gen_rtx_PARALLEL (GET_MODE (parallel), vec);
1855 return gen_rtx_PARALLEL (GET_MODE (src), vec);
1868 enum machine_mode m = GET_MODE (orig_dst);
1875 enum machine_mode imode = int_mode_for_mode (GET_MODE (orig_dst));
1877 dst = assign_stack_temp (GET_MODE (orig_dst), ssize, 0);
1882 dst = gen_lowpart (GET_MODE (orig_dst), dst);
1903 tmps[i] = gen_reg_rtx (GET_MODE (reg));
1927 temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
1934 enum machine_mode outer = GET_MODE (dst);
1949 inner = GET_MODE (tmps[start]);
1968 inner = GET_MODE (tmps[finish - 1]);
1992 enum machine_mode mode = GET_MODE (tmps[i]);
2003 BLOCK_REG_PADDING (GET_MODE (orig_dst), type, i == start)
2020 if (bytepos + bytelen <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2022 else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
2024 bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
2030 dest = assign_stack_temp (GET_MODE (dest),
2031 GET_MODE_SIZE (GET_MODE (dest)), 0);
2032 emit_move_insn (adjust_address (dest, GET_MODE (tmps[i]), bytepos),
2085 if (GET_MODE (srcreg) != BLKmode
2086 && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2120 GET_MODE (srcreg));
2511 enum machine_mode mode = GET_MODE (object);
2738 cmode = GET_MODE (cplx);
2795 cmode = GET_MODE (cplx);
3121 innermode = GET_MODE (op);
3122 innermostmode = GET_MODE (SUBREG_REG (op));
3231 enum machine_mode mode = GET_MODE (x);
3282 enum machine_mode mode = GET_MODE (x);
3287 && (GET_MODE (y) == mode || GET_MODE (y) == VOIDmode));
3292 && SCALAR_FLOAT_MODE_P (GET_MODE (x))
3315 && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
3316 && ! push_operand (x, GET_MODE (x)))
3322 && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
3347 enum machine_mode dstmode = GET_MODE (x);
3348 enum machine_mode orig_srcmode = GET_MODE (y);
3691 size = expand_binop (GET_MODE (size), sub_optab, size,
3783 && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3892 enum machine_mode str_mode = GET_MODE (str_rtx);
3996 value = expand_expr (op1, NULL_RTX, GET_MODE (str_rtx), 0);
3997 value = convert_modes (GET_MODE (str_rtx),
4011 if (bitpos + bitsize != GET_MODE_BITSIZE (GET_MODE (str_rtx)))
4015 value = expand_and (GET_MODE (str_rtx), value, mask,
4018 value = expand_shift (LSHIFT_EXPR, GET_MODE (str_rtx), value,
4021 result = expand_binop (GET_MODE (str_rtx), binop, str_rtx,
4093 if (GET_MODE (offset_rtx) != Pmode)
4096 if (GET_MODE (offset_rtx) != ptr_mode)
4103 && GET_MODE (to_rtx) == BLKmode
4104 && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
4193 else if (GET_MODE (to_rtx) == BLKmode)
4198 value = convert_memory_address (GET_MODE (to_rtx), value);
4220 temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
4307 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4346 || (GET_MODE_PRECISION (GET_MODE (target))
4356 (GET_MODE (SUBREG_REG (target)),
4368 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4370 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4372 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4373 GET_MODE (target), temp,
4384 temp = expand_expr_real (exp, target, GET_MODE (target),
4407 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4409 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4410 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4445 if (GET_MODE (temp) != GET_MODE (target)
4446 && GET_MODE (temp) != VOIDmode)
4454 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4457 else if (GET_MODE (target) == BLKmode)
4466 else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4514 if (GET_MODE (copy_size_rtx) != Pmode)
4523 GET_MODE (size), 0, label);
4538 else if (GET_MODE (temp) == BLKmode)
4872 GET_MODE (target) == BLKmode
4874 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4935 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4937 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4951 || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
5011 if (GET_MODE (offset_rtx) != Pmode)
5014 if (GET_MODE (offset_rtx) != ptr_mode)
5151 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5350 if (REG_P (target) && VECTOR_MODE_P (GET_MODE (target)))
5352 enum machine_mode mode = GET_MODE (target);
5397 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5405 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5449 gen_rtx_PARALLEL (GET_MODE (target), vector)));
5506 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5575 if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5576 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (temp))
5578 temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5579 size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5592 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5993 value = simplify_gen_subreg (GET_MODE (value),
5994 force_reg (GET_MODE (SUBREG_REG (value)),
5997 GET_MODE (SUBREG_REG (value)),
6010 subtarget = gen_reg_rtx (GET_MODE (value));
6023 op2 = negate_rtx (GET_MODE (value), op2);
6038 rtx temp = expand_simple_binop (GET_MODE (value), code,
6041 return expand_simple_binop (GET_MODE (value), code, temp,
6052 return expand_mult (GET_MODE (value), op1, op2, target, 1);
6054 if (!INTEGRAL_MODE_P (GET_MODE (value)))
6055 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6059 FLOAT_MODE_P (GET_MODE (value))
6061 GET_MODE (value), op1, op2, target, 0);
6064 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
6068 return expand_divmod (0, TRUNC_DIV_EXPR, GET_MODE (value), op1, op2,
6072 return expand_divmod (1, TRUNC_MOD_EXPR, GET_MODE (value), op1, op2,
6076 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6080 return expand_simple_binop (GET_MODE (value), code, op1, op2,
6087 target = gen_reg_rtx (GET_MODE (value));
6110 return expand_simple_unop (GET_MODE (value), code, op1, target, 0);
6118 && (GET_MODE_SIZE (GET_MODE (value))
6119 > GET_MODE_SIZE (GET_MODE (SUBREG_REG (value)))))
6121 = simplify_gen_subreg (GET_MODE (value),
6122 force_reg (GET_MODE (SUBREG_REG (value)),
6125 GET_MODE (SUBREG_REG (value)),
6160 && GET_MODE (x) == BLKmode)
6670 rmode = GET_MODE (result);
6994 && GET_MODE (decl_rtl) != DECL_MODE (exp))
7003 gcc_assert (GET_MODE (decl_rtl) == pmode);
7114 gcc_assert (GET_MODE (ret) != BLKmode);
7511 || (bitpos + bitsize > GET_MODE_BITSIZE (GET_MODE (op0)))
7531 if (GET_MODE (offset_rtx) != Pmode)
7534 if (GET_MODE (offset_rtx) != ptr_mode)
7538 if (GET_MODE (op0) == BLKmode
7541 && GET_MODE (XEXP (op0, 0)) != VOIDmode
7576 && bitsize == GET_MODE_BITSIZE (GET_MODE (op0)));
7662 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
7663 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (op0)))
7664 op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
7665 size_int (GET_MODE_BITSIZE (GET_MODE (op0))
7815 if (GET_MODE (op0) == mode)
7853 if (TYPE_MODE (type) == GET_MODE (op0))
7857 else if (TYPE_MODE (type) != BLKmode && GET_MODE (op0) != BLKmode
7859 == GET_MODE_SIZE (GET_MODE (op0)))
7862 op0 = force_reg (GET_MODE (op0), op0);
7867 else if (SCALAR_INT_MODE_P (GET_MODE (op0))
7869 op0 = convert_modes (TYPE_MODE (type), GET_MODE (op0), op0,
7883 if (target == 0 || GET_MODE (target) != TYPE_MODE (inner_type))
7912 rtx new_with_op0_mode = adjust_address (new, GET_MODE (op0), 0);
7916 if (GET_MODE (op0) == BLKmode)
8280 if (GET_MODE (op0) == VOIDmode)
8320 || GET_MODE (target) != mode
8503 && (GET_MODE (original_target)
8522 enum machine_mode mode1 = GET_MODE (temp);
8531 GET_MODE (temp), unsignedp, op1);
8609 && GET_MODE (original_target) == mode
8859 if (target && GET_MODE (target) != GET_MODE (exp))
8873 GET_MODE (exp));
8878 GET_MODE (exp));
8879 return expand_and (GET_MODE (exp), exp, mask, target);
8884 GET_MODE_BITSIZE (GET_MODE (exp)) - prec);
8885 exp = expand_shift (LSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
8886 return expand_shift (RSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
9234 || GET_MODE (subtarget) != operand_mode)
9256 target = gen_reg_rtx (GET_MODE (target));