Lines Matching refs:target
54 #include "target.h"
549 that the source does not overlap the target. */
2744 by the target, which restricts simplify_subreg from invoking
2813 by the target, which restricts simplify_subreg from invoking
2877 probably run into the target not being able to implement it. */
2904 /* The target must support moves in this mode. */
3032 /* See if we can coerce the target into moving both values at once. */
3302 /* If the target's cannot_force_const_mem prevented the spill,
3303 assume that the target's move expanders will also take care
3340 /* If Y is representable exactly in a narrower mode, and the target can
3367 /* Skip if the target can't extend this way. */
3380 /* Skip if the target needs extra instructions to perform
3680 rtx target;
3726 target = gen_rtx_MEM (BLKmode, temp);
3735 set_mem_align (target, align);
3737 emit_block_move (target, xinner, size, BLOCK_OP_CALL_PARM);
4284 store_expr (tree exp, rtx target, int call_param_p)
4305 return store_expr (TREE_OPERAND (exp, 1), target, call_param_p);
4307 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
4309 /* For conditional expression, get safe form of the target. Then
4319 store_expr (TREE_OPERAND (exp, 1), target, call_param_p);
4323 store_expr (TREE_OPERAND (exp, 2), target, call_param_p);
4329 else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
4346 || (GET_MODE_PRECISION (GET_MODE (target))
4350 != SUBREG_PROMOTED_UNSIGNED_P (target))
4353 (SUBREG_PROMOTED_UNSIGNED_P (target), TREE_TYPE (exp)), exp);
4356 (GET_MODE (SUBREG_REG (target)),
4357 SUBREG_PROMOTED_UNSIGNED_P (target)),
4360 inner_target = SUBREG_REG (target);
4370 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4371 temp, SUBREG_PROMOTED_UNSIGNED_P (target));
4372 temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4373 GET_MODE (target), temp,
4374 SUBREG_PROMOTED_UNSIGNED_P (target));
4377 convert_move (SUBREG_REG (target), temp,
4378 SUBREG_PROMOTED_UNSIGNED_P (target));
4384 temp = expand_expr_real (exp, target, GET_MODE (target),
4395 if (!(target && REG_P (target)
4396 && REGNO (target) < FIRST_PSEUDO_REGISTER)
4397 && !(MEM_P (target) && MEM_VOLATILE_P (target))
4398 && ! rtx_equal_p (temp, target)
4409 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4410 temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4413 /* If value was not generated in the target, store it there.
4431 if ((! rtx_equal_p (temp, target)
4432 || (temp != target && (side_effects_p (temp)
4433 || side_effects_p (target))))
4438 && !(alt_rtl && rtx_equal_p (alt_rtl, target))
4445 if (GET_MODE (temp) != GET_MODE (target)
4454 temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4455 emit_move_insn (target, temp);
4457 else if (GET_MODE (target) == BLKmode)
4458 emit_block_move (target, temp, expr_size (exp),
4463 convert_move (target, temp, unsignedp);
4471 type of the string, which is actually the size of the target. */
4476 emit_block_move (target, temp, size,
4495 emit_block_move (target, temp, copy_size_rtx,
4504 target = adjust_address (target, BLKmode,
4519 target = offset_address (target, copy_size_rtx,
4527 clear_storage (target, size, BLOCK_OP_NORMAL);
4535 else if (GET_CODE (target) == PARALLEL)
4536 emit_group_load (target, temp, TREE_TYPE (exp),
4539 emit_block_move (target, temp, expr_size (exp),
4544 temp = force_operand (temp, target);
4545 if (temp != target)
4546 emit_move_insn (target, temp);
4855 store_constructor_field (rtx target, unsigned HOST_WIDE_INT bitsize,
4864 /* If we have a nonzero bitpos for a register target, then we just
4867 && (bitpos == 0 || MEM_P (target)))
4869 if (MEM_P (target))
4870 target
4871 = adjust_address (target,
4872 GET_MODE (target) == BLKmode
4874 % GET_MODE_ALIGNMENT (GET_MODE (target)))
4879 if (MEM_P (target) && ! MEM_KEEP_ALIAS_SET_P (target)
4880 && MEM_ALIAS_SET (target) != 0)
4882 target = copy_rtx (target);
4883 set_mem_alias_set (target, alias_set);
4886 store_constructor (exp, target, cleared, bitsize / BITS_PER_UNIT);
4889 store_field (target, bitsize, bitpos, mode, exp, type, alias_set);
4901 store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
4917 /* If size is zero or the target is already cleared, do nothing. */
4926 clear_storage (target, expr_size (exp), BLOCK_OP_NORMAL);
4934 else if (REG_P (target) && TREE_STATIC (exp)
4935 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4937 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4950 && (!REG_P (target)
4951 || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
4954 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
4959 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4969 rtx to_rtx = target;
5005 target));
5028 if (REG_P (target)
5097 else if (REG_P (target) && TREE_STATIC (exp))
5150 if (REG_P (target))
5151 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5153 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
5157 if (!cleared && REG_P (target))
5159 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
5170 rtx xtarget = target;
5199 (!MEM_P (target)
5210 if (MEM_P (target)
5211 && !MEM_KEEP_ALIAS_SET_P (target)
5215 target = copy_rtx (target);
5216 MEM_KEEP_ALIAS_SET_P (target) = 1;
5220 (target, bitsize, bitpos, mode, value, type, cleared,
5259 xtarget = offset_address (target, pos_rtx,
5304 xtarget = offset_address (target,
5318 if (MEM_P (target) && !MEM_KEEP_ALIAS_SET_P (target)
5322 target = copy_rtx (target);
5323 MEM_KEEP_ALIAS_SET_P (target) = 1;
5325 store_constructor_field (target, bitsize, bitpos, mode, value,
5350 if (REG_P (target) && VECTOR_MODE_P (GET_MODE (target)))
5352 enum machine_mode mode = GET_MODE (target);
5370 else if (REG_P (target) && TREE_STATIC (exp))
5396 if (REG_P (target))
5397 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5399 clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
5404 if (!cleared && !vector && REG_P (target))
5405 emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
5440 store_constructor_field (target, bitsize, bitpos,
5448 (target,
5449 gen_rtx_PARALLEL (GET_MODE (target), vector)));
5473 store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
5501 && (REG_P (target) || GET_CODE (target) == SUBREG))
5506 if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5507 emit_move_insn (object, target);
5511 emit_move_insn (target, object);
5517 if (GET_CODE (target) == CONCAT)
5522 return store_expr (exp, target, 0);
5533 || REG_P (target)
5534 || GET_CODE (target) == SUBREG
5538 && ((((MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode))
5540 && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target)))
5592 if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5594 gcc_assert (MEM_P (target) && MEM_P (temp)
5597 target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5598 emit_block_move (target, temp,
5607 store_bit_field (target, bitsize, bitpos, mode, temp);
5614 rtx to_rtx = adjust_address (target, mode, bitpos / BITS_PER_UNIT);
5616 if (to_rtx == target)
5650 If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't
5981 force_operand (rtx value, rtx target)
5984 /* Use subtarget as the target for operand 0 of a binary operation. */
5985 rtx subtarget = get_subtarget (target);
6044 target, 0, OPTAB_LIB_WIDEN);
6052 return expand_mult (GET_MODE (value), op1, op2, target, 1);
6056 target, 1, OPTAB_LIB_WIDEN);
6061 GET_MODE (value), op1, op2, target, 0);
6065 target, 0);
6069 target, 1);
6073 target, 1);
6077 target, 0, OPTAB_LIB_WIDEN);
6081 target, 1, OPTAB_LIB_WIDEN);
6086 if (!target)
6087 target = gen_reg_rtx (GET_MODE (value));
6096 convert_move (target, op1, code == ZERO_EXTEND);
6097 return target;
6101 expand_fix (target, op1, code == UNSIGNED_FIX);
6102 return target;
6106 expand_float (target, op1, code == UNSIGNED_FLOAT);
6107 return target;
6110 return expand_simple_unop (GET_MODE (value), code, op1, target, 0);
6148 /* If EXP has varying size, we MUST use a target since we currently
6420 highest_pow2_factor_for_target (tree target, tree exp)
6425 if (TREE_CODE (target) == COMPONENT_REF)
6426 target_align = DECL_ALIGN_UNIT (TREE_OPERAND (target, 1));
6428 target_align = TYPE_ALIGN_UNIT (TREE_TYPE (target));
6473 expand_operands (tree exp0, tree exp1, rtx target, rtx *op0, rtx *op1,
6476 if (! safe_from_p (target, exp1, 1))
6477 target = 0;
6480 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6489 *op0 = expand_expr (exp0, target, VOIDmode, modifier);
6514 expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode,
6538 return expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6542 return expand_expr_addr_expr_1 (DECL_INITIAL (exp), target,
6570 result = expand_expr (exp, target, tmode,
6589 result = force_operand (result, target);
6606 subtarget = offset || bitpos ? NULL_RTX : target;
6624 subtarget = bitpos ? NULL_RTX : target;
6638 result = force_operand (result, target);
6648 expand_expr_addr_expr (tree exp, rtx target, enum machine_mode tmode,
6660 the right thing, so ignore the given target mode. */
6664 result = expand_expr_addr_expr_1 (TREE_OPERAND (exp, 0), target,
6732 expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
6771 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
6777 ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);
6806 expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
6821 target, \
6836 target = 0;
6839 /* Use subtarget as the target for operand 0 of a binary operation. */
6840 subtarget = get_subtarget (target);
6841 original_target = target;
6842 ignore = (target == const0_rtx
6893 target = 0;
6915 return expand_expr_real_1 (SSA_NAME_VAR (exp), target, tmode, modifier,
7043 return expand_expr (tmp, ignore ? const0_rtx : target,
7048 return expand_expr (DECL_INITIAL (exp), target, VOIDmode, modifier);
7065 /* Handle evaluating a complex constant in a CONCAT target. */
7106 rtx ret = expand_expr_real_1 (val, target, tmode, modifier, alt_rtl);
7157 && target != 0 && mode == BLKmode
7160 clear_storage (target, expr_size (exp), BLOCK_OP_NORMAL);
7161 return target;
7167 fold. Likewise, if we have a target we can use, it is best to
7168 store directly into the target unless the type is large enough
7179 && ! (target != 0 && safe_from_p (target, exp, 1)))
7203 if (target == 0 || ! safe_from_p (target, exp, 1)
7204 || GET_CODE (target) == PARALLEL
7206 target
7213 store_constructor (exp, target, 0, int_expr_size (exp));
7214 return target;
7229 return expand_expr (t, target, tmode, modifier);
7307 return expand_expr (t, target, tmode, modifier);
7330 return expand_expr (fold (value), target, tmode, modifier);
7358 return expand_expr (fold (value), target, tmode,
7424 target = 0;
7425 op0 = expand_expr (value, target, tmode, modifier);
7434 op0 = expand_and (imode, op0, op1, target);
7443 target, 0);
7445 target, 0);
7481 ? target : NULL_RTX),
7618 && ! (target != 0 && MEM_P (op0)
7619 && MEM_P (target)
7625 if (target == 0)
7626 target = assign_temp (type, 0, 1, 1);
7629 return target;
7634 && (!target || MEM_P (target))
7637 emit_block_move (target,
7645 return target;
7655 ? NULL_RTX : target),
7716 else if (target == 0)
7717 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7719 convert_move (target, op0, unsignedp);
7720 return target;
7724 return expand_expr (OBJ_TYPE_REF_EXPR (exp), target, tmode, modifier);
7739 return expand_builtin (exp, target, subtarget, tmode, ignore);
7742 return expand_call (exp, target, ignore);
7758 rtx result = expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7766 if (target == 0)
7769 target = gen_reg_rtx (TYPE_MODE (type));
7771 target = assign_temp (type, 0, 1, 1);
7774 if (MEM_P (target))
7775 /* Store data into beginning of memory target. */
7777 adjust_address (target, TYPE_MODE (valtype), 0),
7782 gcc_assert (REG_P (target));
7785 store_field (target,
7795 return target;
7800 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7836 else if (target == 0)
7842 convert_move (target, op0,
7844 op0 = target;
7883 if (target == 0 || GET_MODE (target) != TYPE_MODE (inner_type))
7884 target
7889 emit_move_insn (target, op0);
7890 op0 = target;
7969 target = 0;
7988 op1 = force_operand (op1, target);
8021 op0 = force_operand (op0, target);
8120 target = 0;
8219 temp = expand_binop (mode, other_optab, op0, op1, target,
8233 return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp));
8241 target = 0;
8247 return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
8257 target = 0;
8260 return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
8269 if (target == 0 || modifier == EXPAND_STACK_PARM)
8270 target = gen_reg_rtx (mode);
8271 expand_fix (target, op0, unsignedp);
8272 return target;
8276 if (target == 0 || modifier == EXPAND_STACK_PARM)
8277 target = gen_reg_rtx (mode);
8283 expand_float (target, op0,
8285 return target;
8290 target = 0;
8293 op0, target, 0);
8300 target = 0;
8311 return expand_abs (mode, op0, target, unsignedp,
8312 safe_from_p (target, TREE_OPERAND (exp, 0), 1));
8316 target = original_target;
8317 if (target == 0
8319 || (MEM_P (target) && MEM_VOLATILE_P (target))
8320 || GET_MODE (target) != mode
8321 || (REG_P (target)
8322 && REGNO (target) < FIRST_PSEUDO_REGISTER))
8323 target = gen_reg_rtx (mode);
8325 target, &op0, &op1, 0);
8331 temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
8336 /* At this point, a MEM target is no longer useful; we will get better
8339 if (! REG_P (target))
8340 target = gen_reg_rtx (mode);
8342 /* If op1 was placed in target, swap op0 and op1. */
8343 if (target != op0 && target == op1)
8351 target by forcing op1 into a pseudo if it isn't a constant. */
8398 insn = emit_conditional_move (target, comparison_code,
8410 return target;
8418 if (target != op0)
8419 emit_move_insn (target, op0);
8422 do_compare_rtx_and_jump (target, cmpop1, comparison_code,
8425 emit_move_insn (target, op1);
8427 return target;
8432 target = 0;
8433 temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
8472 target = 0;
8474 return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
8494 modifier != EXPAND_STACK_PARM ? target : NULL_RTX,
8513 emit_move_insn (target, const1_rtx);
8515 emit_move_insn (target, const0_rtx);
8517 return target;
8542 && (target == 0
8544 || ! safe_from_p (target, exp, 1)
8547 || (!optimize && REG_P (target)
8548 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
8549 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
8551 if (target)
8552 emit_move_insn (target, const0_rtx);
8557 if (target)
8558 emit_move_insn (target, const1_rtx);
8561 return ignore ? const0_rtx : target;
8565 target = 0;
8566 op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
8570 target, 1, OPTAB_LIB_WIDEN);
8601 /* If we are not to produce a result, we have no target. Otherwise,
8602 if a target was specified use it; it will not be used as an
8603 intermediate target unless it is safe. If no target, use a
8638 target = expand_vec_cond_expr (exp, target);
8639 return target;
8688 return expand_expr_addr_expr (exp, target, tmode, modifier);
8695 if (!target)
8696 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8699 write_complex_part (target, op0, false);
8700 write_complex_part (target, op1, true);
8702 return target;
8783 target, unsignedp);
8797 target = expand_widen_pattern_expr (exp, op0, op1, op2,
8798 target, unsignedp);
8799 return target;
8808 target = expand_widen_pattern_expr (exp, op0, NULL_RTX, op1,
8809 target, unsignedp);
8810 return target;
8819 temp = expand_unop (mode, this_optab, op0, target, unsignedp);
8827 target = expand_vec_shift_expr (exp, target);
8828 return target;
8844 target = 0;
8845 temp = expand_binop (mode, this_optab, op0, op1, target,
8856 reduce_to_bit_field_precision (rtx exp, rtx target, tree type)
8859 if (target && GET_MODE (target) != GET_MODE (exp))
8860 target = 0;
8866 return expand_expr (t, target, VOIDmode, EXPAND_NORMAL);
8879 return expand_and (GET_MODE (exp), exp, mask, target);
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);
9061 do_store_flag (tree exp, rtx target, enum machine_mode mode, int only_cheap)
9071 rtx subtarget = target;
9206 target, VOIDmode, EXPAND_NORMAL);
9233 if (! get_subtarget (target)
9239 if (target == 0)
9240 target = gen_reg_rtx (mode);
9242 result = emit_store_flag (target, code, op0, op1,
9254 if (!REG_P (target)
9255 || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
9256 target = gen_reg_rtx (GET_MODE (target));
9258 emit_move_insn (target, invert ? const0_rtx : const1_rtx);
9278 emit_move_insn (target, invert ? const1_rtx : const0_rtx);
9281 return target;