gimple subexp0_def, subexp1_def;
tree top0, top1;
location_t loc = EXPR_LOCATION (exp);
+ tree treeop0, treeop1, treeop2;
#define REDUCE_BIT_FIELD(expr) (reduce_bit_field \
? reduce_to_bit_field_precision ((expr), \
target, \
mode = TYPE_MODE (type);
unsignedp = TYPE_UNSIGNED (type);
+ treeop0 = treeop1 = treeop2 = NULL_TREE;
+ if (!VL_EXP_CLASS_P (exp))
+ switch (TREE_CODE_LENGTH (code))
+ {
+ default:
+ case 3: treeop2 = TREE_OPERAND (exp, 2);
+ case 2: treeop1 = TREE_OPERAND (exp, 1);
+ case 1: treeop0 = TREE_OPERAND (exp, 0);
+ case 0: break;
+ }
+
ignore = (target == const0_rtx
|| ((CONVERT_EXPR_CODE_P (code)
|| code == COND_EXPR || code == VIEW_CONVERT_EXPR)
if (TREE_CODE_CLASS (code) == tcc_unary
|| code == COMPONENT_REF || code == INDIRECT_REF)
- return expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
+ return expand_expr (treeop0, const0_rtx, VOIDmode,
modifier);
else if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison
|| code == ARRAY_REF || code == ARRAY_RANGE_REF)
{
- expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
- expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
+ expand_expr (treeop0, const0_rtx, VOIDmode, modifier);
+ expand_expr (treeop1, const0_rtx, VOIDmode, modifier);
return const0_rtx;
}
else if (code == BIT_FIELD_REF)
{
- expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
- expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
- expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode, modifier);
+ expand_expr (treeop0, const0_rtx, VOIDmode, modifier);
+ expand_expr (treeop1, const0_rtx, VOIDmode, modifier);
+ expand_expr (treeop2, const0_rtx, VOIDmode, modifier);
return const0_rtx;
}
case SAVE_EXPR:
{
- tree val = TREE_OPERAND (exp, 0);
+ tree val = treeop0;
rtx ret = expand_expr_real_1 (val, target, tmode, modifier, alt_rtl);
if (!SAVE_EXPR_RESOLVED_P (exp))
VAR_DECL, NULL, TREE_TYPE (exp));
DECL_ARTIFICIAL (val) = 1;
DECL_IGNORED_P (val) = 1;
- TREE_OPERAND (exp, 0) = val;
+ treeop0 = val;
+ TREE_OPERAND (exp, 0) = treeop0;
SAVE_EXPR_RESOLVED_P (exp) = 1;
if (!CONSTANT_P (ret))
}
case GOTO_EXPR:
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
- expand_goto (TREE_OPERAND (exp, 0));
+ if (TREE_CODE (treeop0) == LABEL_DECL)
+ expand_goto (treeop0);
else
- expand_computed_goto (TREE_OPERAND (exp, 0));
+ expand_computed_goto (treeop0);
return const0_rtx;
case CONSTRUCTOR:
case ALIGN_INDIRECT_REF:
case INDIRECT_REF:
{
- tree exp1 = TREE_OPERAND (exp, 0);
+ tree exp1 = treeop0;
if (modifier != EXPAND_WRITE)
{
case ARRAY_REF:
{
- tree array = TREE_OPERAND (exp, 0);
- tree index = TREE_OPERAND (exp, 1);
+ tree array = treeop0;
+ tree index = treeop1;
/* Fold an expression like: "foo"[2].
This is not done in fold so it won't happen inside &.
tree index1 = index;
tree low_bound = array_ref_low_bound (exp);
index1 = fold_convert_loc (loc, sizetype,
- TREE_OPERAND (exp, 1));
+ treeop1);
/* Optimize the special-case of a zero lower bound.
case COMPONENT_REF:
/* If the operand is a CONSTRUCTOR, we can just extract the
appropriate field if it is present. */
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR)
+ if (TREE_CODE (treeop0) == CONSTRUCTOR)
{
unsigned HOST_WIDE_INT idx;
tree field, value;
- FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (treeop0),
idx, field, value)
- if (field == TREE_OPERAND (exp, 1)
+ if (field == treeop1
/* We can normally use the value of the field in the
CONSTRUCTOR. However, if this is a bitfield in
an integral mode that we can fit in a HOST_WIDE_INT,
case PAREN_EXPR:
CASE_CONVERT:
- if (TREE_OPERAND (exp, 0) == error_mark_node)
+ if (treeop0 == error_mark_node)
return const0_rtx;
if (TREE_CODE (type) == UNION_TYPE)
{
- tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
+ tree valtype = TREE_TYPE (treeop0);
/* If both input and output are BLKmode, this conversion isn't doing
anything except possibly changing memory attribute. */
if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode)
{
- rtx result = expand_expr (TREE_OPERAND (exp, 0), target, tmode,
+ rtx result = expand_expr (treeop0, target, tmode,
modifier);
result = copy_rtx (result);
if (MEM_P (target))
/* Store data into beginning of memory target. */
- store_expr (TREE_OPERAND (exp, 0),
+ store_expr (treeop0,
adjust_address (target, TYPE_MODE (valtype), 0),
modifier == EXPAND_STACK_PARM,
false);
/* Store this field into a union of the proper type. */
store_field (target,
MIN ((int_size_in_bytes (TREE_TYPE
- (TREE_OPERAND (exp, 0)))
+ (treeop0))
* BITS_PER_UNIT),
(HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
- 0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
+ 0, TYPE_MODE (valtype), treeop0,
type, 0, false);
}
return target;
}
- if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
+ if (mode == TYPE_MODE (TREE_TYPE (treeop0)))
{
- op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
+ op0 = expand_expr (treeop0, target, VOIDmode,
modifier);
/* If the signedness of the conversion differs and OP0 is
a promoted SUBREG, clear that indication since we now
have to do the proper extension. */
- if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
+ if (TYPE_UNSIGNED (TREE_TYPE (treeop0)) != unsignedp
&& GET_CODE (op0) == SUBREG)
SUBREG_PROMOTED_VAR_P (op0) = 0;
return REDUCE_BIT_FIELD (op0);
}
- op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode,
+ op0 = expand_expr (treeop0, NULL_RTX, mode,
modifier == EXPAND_SUM ? EXPAND_NORMAL : modifier);
if (GET_MODE (op0) == mode)
;
/* If OP0 is a constant, just convert it into the proper mode. */
else if (CONSTANT_P (op0))
{
- tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
+ tree inner_type = TREE_TYPE (treeop0);
enum machine_mode inner_mode = TYPE_MODE (inner_type);
if (modifier == EXPAND_INITIALIZER)
else if (target == 0)
op0 = convert_to_mode (mode, op0,
TYPE_UNSIGNED (TREE_TYPE
- (TREE_OPERAND (exp, 0))));
+ (treeop0)));
else
{
convert_move (target, op0,
- TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
+ TYPE_UNSIGNED (TREE_TYPE (treeop0)));
op0 = target;
}
temporary by fetching an inner memory reference. */
if (mode == BLKmode
&& TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
- && TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != BLKmode
- && handled_component_p (TREE_OPERAND (exp, 0)))
+ && TYPE_MODE (TREE_TYPE (treeop0)) != BLKmode
+ && handled_component_p (treeop0))
{
enum machine_mode mode1;
HOST_WIDE_INT bitsize, bitpos;
int unsignedp;
int volatilep = 0;
tree tem
- = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, &bitpos,
+ = get_inner_reference (treeop0, &bitsize, &bitpos,
&offset, &mode1, &unsignedp, &volatilep,
true);
rtx orig_op0;
if (op0 == orig_op0)
op0 = copy_rtx (op0);
- set_mem_attributes (op0, TREE_OPERAND (exp, 0), 0);
+ set_mem_attributes (op0, treeop0, 0);
if (REG_P (XEXP (op0, 0)))
mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
}
if (!op0)
- op0 = expand_expr (TREE_OPERAND (exp, 0),
+ op0 = expand_expr (treeop0,
NULL_RTX, VOIDmode, modifier);
/* If the input and output modes are both the same, we are done. */
other. */
else if (SCALAR_INT_MODE_P (GET_MODE (op0)) && SCALAR_INT_MODE_P (mode))
op0 = convert_modes (mode, GET_MODE (op0), op0,
- TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
+ TYPE_UNSIGNED (TREE_TYPE (treeop0)));
/* As a last resort, spill op0 to memory, and reload it in a
different mode. */
else if (!MEM_P (op0))
are going to be changing the mode of the MEM, don't call
force_const_mem for constants because we don't allow pool
constants to change mode. */
- tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
+ tree inner_type = TREE_TYPE (treeop0);
gcc_assert (!TREE_ADDRESSABLE (exp));
&& mode != BLKmode
&& MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode))
{
- tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
+ tree inner_type = TREE_TYPE (treeop0);
HOST_WIDE_INT temp_size
= MAX (int_size_in_bytes (inner_type),
(HOST_WIDE_INT) GET_MODE_SIZE (mode));
/* Make sure to sign-extend the sizetype offset in a POINTER_PLUS_EXPR
if sizetype precision is smaller than pointer precision. */
if (TYPE_PRECISION (sizetype) < TYPE_PRECISION (type))
- exp
- = build2 (PLUS_EXPR, type,
- TREE_OPERAND (exp, 0),
- fold_convert_loc (loc, type,
- fold_convert_loc (loc, ssizetype,
- TREE_OPERAND (exp, 1))));
+ treeop1 = fold_convert_loc (loc, type,
+ fold_convert_loc (loc, ssizetype,
+ treeop1));
case PLUS_EXPR:
/* Check if this is a case for multiplication and addition. */
if ((TREE_CODE (type) == INTEGER_TYPE
|| TREE_CODE (type) == FIXED_POINT_TYPE)
- && (subexp0_def = get_def_for_expr (TREE_OPERAND (exp, 0),
+ && (subexp0_def = get_def_for_expr (treeop0,
MULT_EXPR)))
{
tree subsubexp0, subsubexp1;
{
expand_operands (top0, top1, NULL_RTX, &op0, &op1,
EXPAND_NORMAL);
- op2 = expand_expr (TREE_OPERAND (exp, 1), subtarget,
+ op2 = expand_expr (treeop1, subtarget,
VOIDmode, EXPAND_NORMAL);
temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
target, unsignedp);
sp, ap, or fp is our second argument, in which case we must swap
the innermost first argument and our second argument. */
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
- && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
- && TREE_CODE (TREE_OPERAND (exp, 1)) == VAR_DECL
- && (DECL_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
- || DECL_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
- || DECL_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
+ if (TREE_CODE (treeop0) == PLUS_EXPR
+ && TREE_CODE (TREE_OPERAND (treeop0, 1)) == INTEGER_CST
+ && TREE_CODE (treeop1) == VAR_DECL
+ && (DECL_RTL (treeop1) == frame_pointer_rtx
+ || DECL_RTL (treeop1) == stack_pointer_rtx
+ || DECL_RTL (treeop1) == arg_pointer_rtx))
{
- tree t = TREE_OPERAND (exp, 1);
+ tree t = treeop1;
- TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
- TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
+ treeop1 = TREE_OPERAND (treeop0, 0);
+ TREE_OPERAND (treeop0, 0) = t;
}
/* If the result is to be ptr_mode and we are adding an integer to
{
if (modifier == EXPAND_STACK_PARM)
target = 0;
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
+ if (TREE_CODE (treeop0) == INTEGER_CST
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
- && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
+ && TREE_CONSTANT (treeop1))
{
rtx constant_part;
- op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
+ op1 = expand_expr (treeop1, subtarget, VOIDmode,
EXPAND_SUM);
/* Use immed_double_const to ensure that the constant is
truncated according to the mode of OP1, then sign extended
to a HOST_WIDE_INT. Using the constant directly can result
in non-canonical RTL in a 64x32 cross compile. */
constant_part
- = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
+ = immed_double_const (TREE_INT_CST_LOW (treeop0),
(HOST_WIDE_INT) 0,
- TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
+ TYPE_MODE (TREE_TYPE (treeop1)));
op1 = plus_constant (op1, INTVAL (constant_part));
if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
op1 = force_operand (op1, target);
return REDUCE_BIT_FIELD (op1);
}
- else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
+ else if (TREE_CODE (treeop1) == INTEGER_CST
&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
- && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
+ && TREE_CONSTANT (treeop0))
{
rtx constant_part;
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
+ op0 = expand_expr (treeop0, subtarget, VOIDmode,
(modifier == EXPAND_INITIALIZER
? EXPAND_INITIALIZER : EXPAND_SUM));
if (! CONSTANT_P (op0))
{
- op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
+ op1 = expand_expr (treeop1, NULL_RTX,
VOIDmode, modifier);
/* Return a PLUS if modifier says it's OK. */
if (modifier == EXPAND_SUM
to a HOST_WIDE_INT. Using the constant directly can result
in non-canonical RTL in a 64x32 cross compile. */
constant_part
- = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
+ = immed_double_const (TREE_INT_CST_LOW (treeop1),
(HOST_WIDE_INT) 0,
- TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
+ TYPE_MODE (TREE_TYPE (treeop0)));
op0 = plus_constant (op0, INTVAL (constant_part));
if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
op0 = force_operand (op0, target);
if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
|| mode != ptr_mode)
{
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, EXPAND_NORMAL);
if (op0 == const0_rtx)
return op1;
goto binop2;
}
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, modifier);
return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
/* Check if this is a case for multiplication and subtraction. */
if ((TREE_CODE (type) == INTEGER_TYPE
|| TREE_CODE (type) == FIXED_POINT_TYPE)
- && (subexp1_def = get_def_for_expr (TREE_OPERAND (exp, 1),
+ && (subexp1_def = get_def_for_expr (treeop1,
MULT_EXPR)))
{
tree subsubexp0, subsubexp1;
{
expand_operands (top0, top1, NULL_RTX, &op0, &op1,
EXPAND_NORMAL);
- op2 = expand_expr (TREE_OPERAND (exp, 0), subtarget,
+ op2 = expand_expr (treeop0, subtarget,
VOIDmode, EXPAND_NORMAL);
temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
target, unsignedp);
/* Handle difference of two symbolic constants,
for the sake of an initializer. */
if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
- && really_constant_p (TREE_OPERAND (exp, 0))
- && really_constant_p (TREE_OPERAND (exp, 1)))
+ && really_constant_p (treeop0)
+ && really_constant_p (treeop1))
{
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
NULL_RTX, &op0, &op1, modifier);
/* If the last operand is a CONST_INT, use plus_constant of
|| mode != ptr_mode)
goto binop;
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, modifier);
/* Convert A - const to A + (-const). */
/* If first operand is constant, swap them.
Thus the following special case checks need only
check the second operand. */
- if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
+ if (TREE_CODE (treeop0) == INTEGER_CST)
{
- tree t1 = TREE_OPERAND (exp, 0);
- TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
- TREE_OPERAND (exp, 1) = t1;
+ tree t1 = treeop0;
+ treeop0 = treeop1;
+ treeop1 = t1;
}
/* Attempt to return something suitable for generating an
indexed address, for machines that support that. */
if (modifier == EXPAND_SUM && mode == ptr_mode
- && host_integerp (TREE_OPERAND (exp, 1), 0))
+ && host_integerp (treeop1, 0))
{
- tree exp1 = TREE_OPERAND (exp, 1);
+ tree exp1 = treeop1;
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
+ op0 = expand_expr (treeop0, subtarget, VOIDmode,
EXPAND_SUM);
if (!REG_P (op0))
in that narrower type with a result in the desired type,
do it that way, and avoid the explicit type-conversion. */
- subexp0 = TREE_OPERAND (exp, 0);
- subexp1 = TREE_OPERAND (exp, 1);
+ subexp0 = treeop0;
+ subexp1 = treeop1;
subexp0_def = get_def_for_expr (subexp0, NOP_EXPR);
subexp1_def = get_def_for_expr (subexp1, NOP_EXPR);
top0 = top1 = NULL_TREE;
/* Possible optimization: compute the dividend with EXPAND_SUM
then if the divisor is constant can optimize the case
where some terms of the dividend have coeffs divisible by it. */
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, EXPAND_NORMAL);
return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
case ROUND_MOD_EXPR:
if (modifier == EXPAND_STACK_PARM)
target = 0;
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, EXPAND_NORMAL);
return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
case FIXED_CONVERT_EXPR:
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
if (target == 0 || modifier == EXPAND_STACK_PARM)
target = gen_reg_rtx (mode);
- if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == INTEGER_TYPE
- && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))))
+ if ((TREE_CODE (TREE_TYPE (treeop0)) == INTEGER_TYPE
+ && TYPE_UNSIGNED (TREE_TYPE (treeop0)))
|| (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type)))
expand_fixed_convert (target, op0, 1, TYPE_SATURATING (type));
else
return target;
case FIX_TRUNC_EXPR:
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
if (target == 0 || modifier == EXPAND_STACK_PARM)
target = gen_reg_rtx (mode);
expand_fix (target, op0, unsignedp);
return target;
case FLOAT_EXPR:
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
if (target == 0 || modifier == EXPAND_STACK_PARM)
target = gen_reg_rtx (mode);
/* expand_float can't figure out what to do if FROM has VOIDmode.
So give it the correct mode. With -O, cse will optimize this. */
if (GET_MODE (op0) == VOIDmode)
- op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
+ op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (treeop0)),
op0);
expand_float (target, op0,
- TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
+ TYPE_UNSIGNED (TREE_TYPE (treeop0)));
return target;
case NEGATE_EXPR:
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget,
+ op0 = expand_expr (treeop0, subtarget,
VOIDmode, EXPAND_NORMAL);
if (modifier == EXPAND_STACK_PARM)
target = 0;
return REDUCE_BIT_FIELD (temp);
case ABS_EXPR:
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget,
+ op0 = expand_expr (treeop0, subtarget,
VOIDmode, EXPAND_NORMAL);
if (modifier == EXPAND_STACK_PARM)
target = 0;
return op0;
return expand_abs (mode, op0, target, unsignedp,
- safe_from_p (target, TREE_OPERAND (exp, 0), 1));
+ safe_from_p (target, treeop0, 1));
case MAX_EXPR:
case MIN_EXPR:
|| (REG_P (target)
&& REGNO (target) < FIRST_PSEUDO_REGISTER))
target = gen_reg_rtx (mode);
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
target, &op0, &op1, EXPAND_NORMAL);
/* First try to do it with a special MIN or MAX instruction.
return target;
case BIT_NOT_EXPR:
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget,
+ op0 = expand_expr (treeop0, subtarget,
VOIDmode, EXPAND_NORMAL);
if (modifier == EXPAND_STACK_PARM)
target = 0;
if (ALL_FIXED_POINT_MODE_P (mode))
goto binop;
- if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
+ if (! safe_from_p (subtarget, treeop1, 1))
subtarget = 0;
if (modifier == EXPAND_STACK_PARM)
target = 0;
- op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget,
+ op0 = expand_expr (treeop0, subtarget,
VOIDmode, EXPAND_NORMAL);
- temp = expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
+ temp = expand_shift (code, mode, op0, treeop1, target,
unsignedp);
if (code == LSHIFT_EXPR)
temp = REDUCE_BIT_FIELD (temp);
if (! ignore
&& (target == 0
|| modifier == EXPAND_STACK_PARM
- || ! safe_from_p (target, exp, 1)
+ || ! safe_from_p (target, treeop0, 1)
+ || ! safe_from_p (target, treeop1, 1)
/* Make sure we don't have a hard reg (such as function's return
value) live across basic blocks, if not optimizing. */
|| (!optimize && REG_P (target)
case TRUTH_NOT_EXPR:
if (modifier == EXPAND_STACK_PARM)
target = 0;
- op0 = expand_expr (TREE_OPERAND (exp, 0), target,
+ op0 = expand_expr (treeop0, target,
VOIDmode, EXPAND_NORMAL);
/* The parser is careful to generate TRUTH_NOT_EXPR
only with operands that are always zero or one. */
/* A COND_EXPR with its type being VOID_TYPE represents a
conditional jump and is handled in
expand_gimple_cond_expr. */
- gcc_assert (!VOID_TYPE_P (TREE_TYPE (exp)));
+ gcc_assert (!VOID_TYPE_P (type));
/* Note that COND_EXPRs whose type is a structure or union
are required to be constructed to contain assignments of
gcc_assert (!TREE_ADDRESSABLE (type)
&& !ignore
- && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node
- && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node);
+ && TREE_TYPE (treeop1) != void_type_node
+ && TREE_TYPE (treeop2) != void_type_node);
/* If we are not to produce a result, we have no target. Otherwise,
if a target was specified use it; it will not be used as an
if (modifier != EXPAND_STACK_PARM
&& original_target
- && safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
+ && safe_from_p (original_target, treeop0, 1)
&& GET_MODE (original_target) == mode
#ifdef HAVE_conditional_move
&& (! can_conditionally_move_p (mode)
NO_DEFER_POP;
op0 = gen_label_rtx ();
op1 = gen_label_rtx ();
- jumpifnot (TREE_OPERAND (exp, 0), op0);
- store_expr (TREE_OPERAND (exp, 1), temp,
+ jumpifnot (treeop0, op0);
+ store_expr (treeop1, temp,
modifier == EXPAND_STACK_PARM,
false);
emit_jump_insn (gen_jump (op1));
emit_barrier ();
emit_label (op0);
- store_expr (TREE_OPERAND (exp, 2), temp,
+ store_expr (treeop2, temp,
modifier == EXPAND_STACK_PARM,
false);
case MODIFY_EXPR:
{
- tree lhs = TREE_OPERAND (exp, 0);
- tree rhs = TREE_OPERAND (exp, 1);
+ tree lhs = treeop0;
+ tree rhs = treeop1;
gcc_assert (ignore);
/* Check for |= or &= of a bitfield of size one into another bitfield
}
case RETURN_EXPR:
- if (!TREE_OPERAND (exp, 0))
+ if (!treeop0)
expand_null_return ();
else
- expand_return (TREE_OPERAND (exp, 0));
+ expand_return (treeop0);
return const0_rtx;
case ADDR_EXPR:
case COMPLEX_EXPR:
/* Get the rtx code of the operands. */
- op0 = expand_normal (TREE_OPERAND (exp, 0));
- op1 = expand_normal (TREE_OPERAND (exp, 1));
+ op0 = expand_normal (treeop0);
+ op1 = expand_normal (treeop1);
if (!target)
- target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
+ target = gen_reg_rtx (TYPE_MODE (type));
/* Move the real (op0) and imaginary (op1) parts to their location. */
write_complex_part (target, op0, false);
return target;
case REALPART_EXPR:
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
return read_complex_part (op0, false);
case IMAGPART_EXPR:
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
return read_complex_part (op0, true);
case RESX_EXPR:
return const0_rtx;
case LABEL_EXPR:
- expand_label (TREE_OPERAND (exp, 0));
+ expand_label (treeop0);
return const0_rtx;
case ASM_EXPR:
case WITH_SIZE_EXPR:
/* WITH_SIZE_EXPR expands to its first argument. The caller should
have pulled out the size to use in whatever context it needed. */
- return expand_expr_real (TREE_OPERAND (exp, 0), original_target, tmode,
+ return expand_expr_real (treeop0, original_target, tmode,
modifier, alt_rtl);
case REALIGN_LOAD_EXPR:
{
- tree oprnd0 = TREE_OPERAND (exp, 0);
- tree oprnd1 = TREE_OPERAND (exp, 1);
- tree oprnd2 = TREE_OPERAND (exp, 2);
+ tree oprnd0 = treeop0;
+ tree oprnd1 = treeop1;
+ tree oprnd2 = treeop2;
rtx op2;
this_optab = optab_for_tree_code (code, type, optab_default);
case DOT_PROD_EXPR:
{
- tree oprnd0 = TREE_OPERAND (exp, 0);
- tree oprnd1 = TREE_OPERAND (exp, 1);
- tree oprnd2 = TREE_OPERAND (exp, 2);
+ tree oprnd0 = treeop0;
+ tree oprnd1 = treeop1;
+ tree oprnd2 = treeop2;
rtx op2;
expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
case WIDEN_SUM_EXPR:
{
- tree oprnd0 = TREE_OPERAND (exp, 0);
- tree oprnd1 = TREE_OPERAND (exp, 1);
+ tree oprnd0 = treeop0;
+ tree oprnd1 = treeop1;
expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
target = expand_widen_pattern_expr (exp, op0, NULL_RTX, op1,
case REDUC_MIN_EXPR:
case REDUC_PLUS_EXPR:
{
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
this_optab = optab_for_tree_code (code, type, optab_default);
temp = expand_unop (mode, this_optab, op0, target, unsignedp);
gcc_assert (temp);
case VEC_EXTRACT_EVEN_EXPR:
case VEC_EXTRACT_ODD_EXPR:
{
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
NULL_RTX, &op0, &op1, EXPAND_NORMAL);
this_optab = optab_for_tree_code (code, type, optab_default);
temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
case VEC_INTERLEAVE_HIGH_EXPR:
case VEC_INTERLEAVE_LOW_EXPR:
{
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
NULL_RTX, &op0, &op1, EXPAND_NORMAL);
this_optab = optab_for_tree_code (code, type, optab_default);
temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
case VEC_UNPACK_HI_EXPR:
case VEC_UNPACK_LO_EXPR:
{
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
this_optab = optab_for_tree_code (code, type, optab_default);
temp = expand_widen_pattern_expr (exp, op0, NULL_RTX, NULL_RTX,
target, unsignedp);
case VEC_UNPACK_FLOAT_HI_EXPR:
case VEC_UNPACK_FLOAT_LO_EXPR:
{
- op0 = expand_normal (TREE_OPERAND (exp, 0));
+ op0 = expand_normal (treeop0);
/* The signedness is determined from input operand. */
this_optab = optab_for_tree_code (code,
- TREE_TYPE (TREE_OPERAND (exp, 0)),
+ TREE_TYPE (treeop0),
optab_default);
temp = expand_widen_pattern_expr
(exp, op0, NULL_RTX, NULL_RTX,
- target, TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
+ target, TYPE_UNSIGNED (TREE_TYPE (treeop0)));
gcc_assert (temp);
return temp;
case VEC_WIDEN_MULT_HI_EXPR:
case VEC_WIDEN_MULT_LO_EXPR:
{
- tree oprnd0 = TREE_OPERAND (exp, 0);
- tree oprnd1 = TREE_OPERAND (exp, 1);
+ tree oprnd0 = treeop0;
+ tree oprnd1 = treeop1;
expand_operands (oprnd0, oprnd1, NULL_RTX, &op0, &op1, EXPAND_NORMAL);
target = expand_widen_pattern_expr (exp, op0, op1, NULL_RTX,
case VEC_PACK_TRUNC_EXPR:
case VEC_PACK_SAT_EXPR:
case VEC_PACK_FIX_TRUNC_EXPR:
- mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
+ mode = TYPE_MODE (TREE_TYPE (treeop0));
goto binop;
case COMPOUND_LITERAL_EXPR:
/* Here to do an ordinary binary operator. */
binop:
- expand_operands (TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
+ expand_operands (treeop0, treeop1,
subtarget, &op0, &op1, EXPAND_NORMAL);
binop2:
this_optab = optab_for_tree_code (code, type, optab_default);
OSDN Git Service
