/* Fold a constant sub-tree into a single node for C-compiler
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+static bool negate_mathfn_p (enum built_in_function);
static bool negate_expr_p (tree);
static tree negate_expr (tree);
static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
static tree const_binop (enum tree_code, tree, tree, int);
static hashval_t size_htab_hash (const void *);
static int size_htab_eq (const void *, const void *);
+static tree fold_convert_const (enum tree_code, tree, tree);
static tree fold_convert (tree, tree);
static enum tree_code invert_tree_comparison (enum tree_code);
static enum tree_code swap_tree_comparison (enum tree_code);
static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
tree, tree, tree);
static tree fold_inf_compare (enum tree_code, tree, tree, tree);
-static bool tree_swap_operands_p (tree, tree);
+static bool reorder_operands_p (tree, tree);
+static bool tree_swap_operands_p (tree, tree, bool);
/* The following constants represent a bit based encoding of GCC's
comparison operators. This encoding simplifies transformations
abort ();
}
- /* compute true remainder: rem = num - (quo * den) */
+ /* Compute true remainder: rem = num - (quo * den) */
mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
neg_double (*lrem, *hrem, lrem, hrem);
add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
return overflow;
}
\f
+/* Return true if built-in mathematical function specified by CODE
+ preserves the sign of it argument, i.e. -f(x) == f(-x). */
+
+static bool
+negate_mathfn_p (enum built_in_function code)
+{
+ switch (code)
+ {
+ case BUILT_IN_ASIN:
+ case BUILT_IN_ASINF:
+ case BUILT_IN_ASINL:
+ case BUILT_IN_ATAN:
+ case BUILT_IN_ATANF:
+ case BUILT_IN_ATANL:
+ case BUILT_IN_SIN:
+ case BUILT_IN_SINF:
+ case BUILT_IN_SINL:
+ case BUILT_IN_TAN:
+ case BUILT_IN_TANF:
+ case BUILT_IN_TANL:
+ return true;
+
+ default:
+ break;
+ }
+ return false;
+}
+
/* Determine whether an expression T can be cheaply negated using
the function negate_expr. */
switch (TREE_CODE (t))
{
case INTEGER_CST:
- if (TREE_UNSIGNED (type))
- return false;
+ if (TREE_UNSIGNED (type) || ! flag_trapv)
+ return true;
/* Check that -CST will not overflow type. */
prec = TYPE_PRECISION (type);
case NEGATE_EXPR:
return true;
+ case COMPLEX_CST:
+ return negate_expr_p (TREE_REALPART (t))
+ && negate_expr_p (TREE_IMAGPART (t));
+
+ case PLUS_EXPR:
+ if (FLOAT_TYPE_P (type) && !flag_unsafe_math_optimizations)
+ return false;
+ /* -(A + B) -> (-B) - A. */
+ if (negate_expr_p (TREE_OPERAND (t, 1))
+ && reorder_operands_p (TREE_OPERAND (t, 0),
+ TREE_OPERAND (t, 1)))
+ return true;
+ /* -(A + B) -> (-A) - B. */
+ return negate_expr_p (TREE_OPERAND (t, 0));
+
case MINUS_EXPR:
/* We can't turn -(A-B) into B-A when we honor signed zeros. */
- return ! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations;
+ return (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
+ && reorder_operands_p (TREE_OPERAND (t, 0),
+ TREE_OPERAND (t, 1));
case MULT_EXPR:
if (TREE_UNSIGNED (TREE_TYPE (t)))
|| negate_expr_p (TREE_OPERAND (t, 0));
break;
+ case NOP_EXPR:
+ /* Negate -((double)float) as (double)(-float). */
+ if (TREE_CODE (type) == REAL_TYPE)
+ {
+ tree tem = strip_float_extensions (t);
+ if (tem != t)
+ return negate_expr_p (tem);
+ }
+ break;
+
+ case CALL_EXPR:
+ /* Negate -f(x) as f(-x). */
+ if (negate_mathfn_p (builtin_mathfn_code (t)))
+ return negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1)));
+ break;
+
default:
break;
}
switch (TREE_CODE (t))
{
case INTEGER_CST:
- if (! TREE_UNSIGNED (type)
- && 0 != (tem = fold (build1 (NEGATE_EXPR, type, t)))
- && ! TREE_OVERFLOW (tem))
+ {
+ unsigned HOST_WIDE_INT low;
+ HOST_WIDE_INT high;
+ int overflow = neg_double (TREE_INT_CST_LOW (t),
+ TREE_INT_CST_HIGH (t),
+ &low, &high);
+ tem = build_int_2 (low, high);
+ TREE_TYPE (tem) = type;
+ TREE_OVERFLOW (tem)
+ = (TREE_OVERFLOW (t)
+ | force_fit_type (tem, overflow && !TREE_UNSIGNED (type)));
+ TREE_CONSTANT_OVERFLOW (tem)
+ = TREE_OVERFLOW (tem) | TREE_CONSTANT_OVERFLOW (t);
+ }
+ if (! TREE_OVERFLOW (tem)
+ || TREE_UNSIGNED (type)
+ || ! flag_trapv)
return tem;
break;
case REAL_CST:
tem = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (t)));
/* Two's complement FP formats, such as c4x, may overflow. */
- if (! TREE_OVERFLOW (tem))
- return convert (type, tem);
+ if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
+ return fold_convert (type, tem);
+ break;
+
+ case COMPLEX_CST:
+ {
+ tree rpart = negate_expr (TREE_REALPART (t));
+ tree ipart = negate_expr (TREE_IMAGPART (t));
+
+ if ((TREE_CODE (rpart) == REAL_CST
+ && TREE_CODE (ipart) == REAL_CST)
+ || (TREE_CODE (rpart) == INTEGER_CST
+ && TREE_CODE (ipart) == INTEGER_CST))
+ return build_complex (type, rpart, ipart);
+ }
break;
case NEGATE_EXPR:
- return convert (type, TREE_OPERAND (t, 0));
+ return fold_convert (type, TREE_OPERAND (t, 0));
+
+ case PLUS_EXPR:
+ if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
+ {
+ /* -(A + B) -> (-B) - A. */
+ if (negate_expr_p (TREE_OPERAND (t, 1))
+ && reorder_operands_p (TREE_OPERAND (t, 0),
+ TREE_OPERAND (t, 1)))
+ return fold_convert (type,
+ fold (build (MINUS_EXPR, TREE_TYPE (t),
+ negate_expr (TREE_OPERAND (t, 1)),
+ TREE_OPERAND (t, 0))));
+ /* -(A + B) -> (-A) - B. */
+ if (negate_expr_p (TREE_OPERAND (t, 0)))
+ return fold_convert (type,
+ fold (build (MINUS_EXPR, TREE_TYPE (t),
+ negate_expr (TREE_OPERAND (t, 0)),
+ TREE_OPERAND (t, 1))));
+ }
+ break;
case MINUS_EXPR:
/* - (A - B) -> B - A */
- if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
- return convert (type,
- fold (build (MINUS_EXPR, TREE_TYPE (t),
- TREE_OPERAND (t, 1),
- TREE_OPERAND (t, 0))));
+ if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
+ && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
+ return fold_convert (type,
+ fold (build (MINUS_EXPR, TREE_TYPE (t),
+ TREE_OPERAND (t, 1),
+ TREE_OPERAND (t, 0))));
break;
case MULT_EXPR:
{
tem = TREE_OPERAND (t, 1);
if (negate_expr_p (tem))
- return convert (type,
- fold (build (TREE_CODE (t), TREE_TYPE (t),
- TREE_OPERAND (t, 0),
- negate_expr (tem))));
+ return fold_convert (type,
+ fold (build (TREE_CODE (t), TREE_TYPE (t),
+ TREE_OPERAND (t, 0),
+ negate_expr (tem))));
tem = TREE_OPERAND (t, 0);
if (negate_expr_p (tem))
- return convert (type,
- fold (build (TREE_CODE (t), TREE_TYPE (t),
- negate_expr (tem),
- TREE_OPERAND (t, 1))));
+ return fold_convert (type,
+ fold (build (TREE_CODE (t), TREE_TYPE (t),
+ negate_expr (tem),
+ TREE_OPERAND (t, 1))));
+ }
+ break;
+
+ case NOP_EXPR:
+ /* Convert -((double)float) into (double)(-float). */
+ if (TREE_CODE (type) == REAL_TYPE)
+ {
+ tem = strip_float_extensions (t);
+ if (tem != t && negate_expr_p (tem))
+ return fold_convert (type, negate_expr (tem));
+ }
+ break;
+
+ case CALL_EXPR:
+ /* Negate -f(x) as f(-x). */
+ if (negate_mathfn_p (builtin_mathfn_code (t))
+ && negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1))))
+ {
+ tree fndecl, arg, arglist;
+
+ fndecl = get_callee_fndecl (t);
+ arg = negate_expr (TREE_VALUE (TREE_OPERAND (t, 1)));
+ arglist = build_tree_list (NULL_TREE, arg);
+ return build_function_call_expr (fndecl, arglist);
}
break;
break;
}
- return convert (type, fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t)));
+ tem = fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t));
+ return fold_convert (type, tem);
}
\f
/* Split a tree IN into a constant, literal and variable parts that could be
if (code == PLUS_EXPR)
{
if (TREE_CODE (t1) == NEGATE_EXPR)
- return build (MINUS_EXPR, type, convert (type, t2),
- convert (type, TREE_OPERAND (t1, 0)));
+ return build (MINUS_EXPR, type, fold_convert (type, t2),
+ fold_convert (type, TREE_OPERAND (t1, 0)));
else if (TREE_CODE (t2) == NEGATE_EXPR)
- return build (MINUS_EXPR, type, convert (type, t1),
- convert (type, TREE_OPERAND (t2, 0)));
+ return build (MINUS_EXPR, type, fold_convert (type, t1),
+ fold_convert (type, TREE_OPERAND (t2, 0)));
}
- return build (code, type, convert (type, t1), convert (type, t2));
+ return build (code, type, fold_convert (type, t1),
+ fold_convert (type, t2));
}
- return fold (build (code, type, convert (type, t1), convert (type, t2)));
+ return fold (build (code, type, fold_convert (type, t1),
+ fold_convert (type, t2)));
}
\f
/* Combine two integer constants ARG1 and ARG2 under operation CODE
type and subtract. The hardware will do the right thing with any
overflow in the subtraction. */
if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
- return size_binop (MINUS_EXPR, convert (ctype, arg0),
- convert (ctype, arg1));
+ return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
+ fold_convert (ctype, arg1));
/* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
Otherwise, subtract the other way, convert to CTYPE (we know that can't
overflow) and negate (which can't either). Special-case a result
of zero while we're here. */
if (tree_int_cst_equal (arg0, arg1))
- return convert (ctype, integer_zero_node);
+ return fold_convert (ctype, integer_zero_node);
else if (tree_int_cst_lt (arg1, arg0))
- return convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
+ return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
else
- return size_binop (MINUS_EXPR, convert (ctype, integer_zero_node),
- convert (ctype, size_binop (MINUS_EXPR, arg1, arg0)));
+ return size_binop (MINUS_EXPR, fold_convert (ctype, integer_zero_node),
+ fold_convert (ctype, size_binop (MINUS_EXPR,
+ arg1, arg0)));
}
\f
-/* Given T, a tree representing type conversion of ARG1, a constant,
- return a constant tree representing the result of conversion. */
+/* Attempt to fold type conversion operation CODE of expression ARG1 to
+ type TYPE. If no simplification can be done return NULL_TREE. */
static tree
-fold_convert (tree t, tree arg1)
+fold_convert_const (enum tree_code code, tree type, tree arg1)
{
- tree type = TREE_TYPE (t);
int overflow = 0;
+ tree t;
+
+ if (TREE_TYPE (arg1) == type)
+ return arg1;
if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
{
/* If we would build a constant wider than GCC supports,
leave the conversion unfolded. */
if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
- return t;
+ return NULL_TREE;
/* If we are trying to make a sizetype for a small integer, use
size_int to pick up cached types to reduce duplicate nodes. */
|| TREE_OVERFLOW (arg1));
TREE_CONSTANT_OVERFLOW (t)
= TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
+ return t;
}
else if (TREE_CODE (arg1) == REAL_CST)
{
- /* Don't initialize these, use assignments.
- Initialized local aggregates don't work on old compilers. */
- REAL_VALUE_TYPE x;
- REAL_VALUE_TYPE l;
- REAL_VALUE_TYPE u;
- tree type1 = TREE_TYPE (arg1);
- int no_upper_bound;
-
- x = TREE_REAL_CST (arg1);
- l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
-
- no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
- if (!no_upper_bound)
- u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
-
- /* See if X will be in range after truncation towards 0.
- To compensate for truncation, move the bounds away from 0,
- but reject if X exactly equals the adjusted bounds. */
- REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
- if (!no_upper_bound)
- REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
- /* If X is a NaN, use zero instead and show we have an overflow.
- Otherwise, range check. */
- if (REAL_VALUE_ISNAN (x))
- overflow = 1, x = dconst0;
- else if (! (REAL_VALUES_LESS (l, x)
- && !no_upper_bound
- && REAL_VALUES_LESS (x, u)))
- overflow = 1;
+ /* The following code implements the floating point to integer
+ conversion rules required by the Java Language Specification,
+ that IEEE NaNs are mapped to zero and values that overflow
+ the target precision saturate, i.e. values greater than
+ INT_MAX are mapped to INT_MAX, and values less than INT_MIN
+ are mapped to INT_MIN. These semantics are allowed by the
+ C and C++ standards that simply state that the behavior of
+ FP-to-integer conversion is unspecified upon overflow. */
- {
- HOST_WIDE_INT low, high;
- REAL_VALUE_TO_INT (&low, &high, x);
- t = build_int_2 (low, high);
- }
+ HOST_WIDE_INT high, low;
+
+ REAL_VALUE_TYPE r;
+ REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
+
+ switch (code)
+ {
+ case FIX_TRUNC_EXPR:
+ real_trunc (&r, VOIDmode, &x);
+ break;
+
+ case FIX_CEIL_EXPR:
+ real_ceil (&r, VOIDmode, &x);
+ break;
+
+ case FIX_FLOOR_EXPR:
+ real_floor (&r, VOIDmode, &x);
+ break;
+
+ default:
+ abort ();
+ }
+
+ /* If R is NaN, return zero and show we have an overflow. */
+ if (REAL_VALUE_ISNAN (r))
+ {
+ overflow = 1;
+ high = 0;
+ low = 0;
+ }
+
+ /* See if R is less than the lower bound or greater than the
+ upper bound. */
+
+ if (! overflow)
+ {
+ tree lt = TYPE_MIN_VALUE (type);
+ REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
+ if (REAL_VALUES_LESS (r, l))
+ {
+ overflow = 1;
+ high = TREE_INT_CST_HIGH (lt);
+ low = TREE_INT_CST_LOW (lt);
+ }
+ }
+
+ if (! overflow)
+ {
+ tree ut = TYPE_MAX_VALUE (type);
+ if (ut)
+ {
+ REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
+ if (REAL_VALUES_LESS (u, r))
+ {
+ overflow = 1;
+ high = TREE_INT_CST_HIGH (ut);
+ low = TREE_INT_CST_LOW (ut);
+ }
+ }
+ }
+
+ if (! overflow)
+ REAL_VALUE_TO_INT (&low, &high, r);
+
+ t = build_int_2 (low, high);
TREE_TYPE (t) = type;
TREE_OVERFLOW (t)
= TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
TREE_CONSTANT_OVERFLOW (t)
= TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
+ return t;
}
- TREE_TYPE (t) = type;
}
else if (TREE_CODE (type) == REAL_TYPE)
{
return t;
}
}
- TREE_CONSTANT (t) = 1;
- return t;
+ return NULL_TREE;
+}
+
+/* Convert expression ARG to type TYPE. Used by the middle-end for
+ simple conversions in preference to calling the front-end's convert. */
+
+static tree
+fold_convert (tree type, tree arg)
+{
+ tree orig = TREE_TYPE (arg);
+ tree tem;
+
+ if (type == orig)
+ return arg;
+
+ if (TREE_CODE (arg) == ERROR_MARK
+ || TREE_CODE (type) == ERROR_MARK
+ || TREE_CODE (orig) == ERROR_MARK)
+ return error_mark_node;
+
+ if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
+ return fold (build1 (NOP_EXPR, type, arg));
+
+ if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
+ {
+ if (TREE_CODE (arg) == INTEGER_CST)
+ {
+ tem = fold_convert_const (NOP_EXPR, type, arg);
+ if (tem != NULL_TREE)
+ return tem;
+ }
+ if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+ return fold (build1 (NOP_EXPR, type, arg));
+ if (TREE_CODE (orig) == COMPLEX_TYPE)
+ {
+ tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ return fold_convert (type, tem);
+ }
+ if (TREE_CODE (orig) == VECTOR_TYPE
+ && GET_MODE_SIZE (TYPE_MODE (type))
+ == GET_MODE_SIZE (TYPE_MODE (orig)))
+ return fold (build1 (NOP_EXPR, type, arg));
+ }
+ else if (TREE_CODE (type) == REAL_TYPE)
+ {
+ if (TREE_CODE (arg) == INTEGER_CST)
+ {
+ tem = fold_convert_const (FLOAT_EXPR, type, arg);
+ if (tem != NULL_TREE)
+ return tem;
+ }
+ else if (TREE_CODE (arg) == REAL_CST)
+ {
+ tem = fold_convert_const (NOP_EXPR, type, arg);
+ if (tem != NULL_TREE)
+ return tem;
+ }
+
+ if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+ return fold (build1 (FLOAT_EXPR, type, arg));
+ if (TREE_CODE (orig) == REAL_TYPE)
+ return fold (build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
+ type, arg));
+ if (TREE_CODE (orig) == COMPLEX_TYPE)
+ {
+ tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ return fold_convert (type, tem);
+ }
+ }
+ else if (TREE_CODE (type) == COMPLEX_TYPE)
+ {
+ if (INTEGRAL_TYPE_P (orig)
+ || POINTER_TYPE_P (orig)
+ || TREE_CODE (orig) == REAL_TYPE)
+ return build (COMPLEX_EXPR, type,
+ fold_convert (TREE_TYPE (type), arg),
+ fold_convert (TREE_TYPE (type), integer_zero_node));
+ if (TREE_CODE (orig) == COMPLEX_TYPE)
+ {
+ tree rpart, ipart;
+
+ if (TREE_CODE (arg) == COMPLEX_EXPR)
+ {
+ rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
+ ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
+ return fold (build (COMPLEX_EXPR, type, rpart, ipart));
+ }
+
+ arg = save_expr (arg);
+ rpart = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
+ ipart = fold (build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg));
+ rpart = fold_convert (TREE_TYPE (type), rpart);
+ ipart = fold_convert (TREE_TYPE (type), ipart);
+ return fold (build (COMPLEX_EXPR, type, rpart, ipart));
+ }
+ }
+ else if (TREE_CODE (type) == VECTOR_TYPE)
+ {
+ if ((INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
+ && GET_MODE_SIZE (TYPE_MODE (type))
+ == GET_MODE_SIZE (TYPE_MODE (orig)))
+ return fold (build1 (NOP_EXPR, type, arg));
+ if (TREE_CODE (orig) == VECTOR_TYPE
+ && GET_MODE_SIZE (TYPE_MODE (type))
+ == GET_MODE_SIZE (TYPE_MODE (orig)))
+ return fold (build1 (NOP_EXPR, type, arg));
+ }
+ else if (VOID_TYPE_P (type))
+ return fold (build1 (CONVERT_EXPR, type, arg));
+ abort ();
}
\f
/* Return an expr equal to X but certainly not valid as an lvalue. */
return 1;
/* For commutative ops, allow the other order. */
- return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
- || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
- || TREE_CODE (arg0) == BIT_IOR_EXPR
- || TREE_CODE (arg0) == BIT_XOR_EXPR
- || TREE_CODE (arg0) == BIT_AND_EXPR
- || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
+ return (commutative_tree_code (TREE_CODE (arg0))
&& operand_equal_p (TREE_OPERAND (arg0, 0),
TREE_OPERAND (arg1, 1), 0)
&& operand_equal_p (TREE_OPERAND (arg0, 1),
/* Make sure shorter operand is extended the right way
to match the longer operand. */
- primarg1 = convert ((*lang_hooks.types.signed_or_unsigned_type)
- (unsignedp1, TREE_TYPE (primarg1)), primarg1);
+ primarg1 = fold_convert ((*lang_hooks.types.signed_or_unsigned_type)
+ (unsignedp1, TREE_TYPE (primarg1)), primarg1);
- if (operand_equal_p (arg0, convert (type, primarg1), 0))
+ if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
return 1;
}
tree
omit_one_operand (tree type, tree result, tree omitted)
{
- tree t = convert (type, result);
+ tree t = fold_convert (type, result);
if (TREE_SIDE_EFFECTS (omitted))
return build (COMPOUND_EXPR, type, omitted, t);
static tree
pedantic_omit_one_operand (tree type, tree result, tree omitted)
{
- tree t = convert (type, result);
+ tree t = fold_convert (type, result);
if (TREE_SIDE_EFFECTS (omitted))
return build (COMPOUND_EXPR, type, omitted, t);
switch (code)
{
case INTEGER_CST:
- return convert (type, build_int_2 (integer_zerop (arg), 0));
+ return fold_convert (type, build_int_2 (integer_zerop (arg), 0));
case TRUTH_AND_EXPR:
return build (TRUTH_OR_EXPR, type,
case BIT_AND_EXPR:
if (!integer_onep (TREE_OPERAND (arg, 1)))
break;
- return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
+ return build (EQ_EXPR, type, arg,
+ fold_convert (type, integer_zero_node));
case SAVE_EXPR:
return build1 (TRUTH_NOT_EXPR, type, arg);
mask = build_int_2 (~0, ~0);
TREE_TYPE (mask) = unsigned_type;
force_fit_type (mask, 0);
- mask = convert (unsigned_type, mask);
+ mask = fold_convert (unsigned_type, mask);
mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
mask = const_binop (RSHIFT_EXPR, mask,
size_int (nbitsize - lbitsize - lbitpos), 0);
if (lunsignedp)
{
if (! integer_zerop (const_binop (RSHIFT_EXPR,
- convert (unsigned_type, rhs),
+ fold_convert (unsigned_type, rhs),
size_int (lbitsize), 0)))
{
warning ("comparison is always %d due to width of bit-field",
code == NE_EXPR);
- return convert (compare_type,
- (code == NE_EXPR
- ? integer_one_node : integer_zero_node));
+ return fold_convert (compare_type,
+ (code == NE_EXPR
+ ? integer_one_node : integer_zero_node));
}
}
else
{
- tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
+ tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
size_int (lbitsize - 1), 0);
if (! integer_zerop (tem) && ! integer_all_onesp (tem))
{
warning ("comparison is always %d due to width of bit-field",
code == NE_EXPR);
- return convert (compare_type,
- (code == NE_EXPR
- ? integer_one_node : integer_zero_node));
+ return fold_convert (compare_type,
+ (code == NE_EXPR
+ ? integer_one_node : integer_zero_node));
}
}
if (lbitsize == 1 && ! integer_zerop (rhs))
{
code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
- rhs = convert (type, integer_zero_node);
+ rhs = fold_convert (type, integer_zero_node);
}
/* Make a new bitfield reference, shift the constant over the
rhs = fold (const_binop (BIT_AND_EXPR,
const_binop (LSHIFT_EXPR,
- convert (unsigned_type, rhs),
+ fold_convert (unsigned_type, rhs),
size_int (lbitpos), 0),
mask, 0));
/* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
if (and_mask != 0)
mask = fold (build (BIT_AND_EXPR, unsigned_type,
- convert (unsigned_type, and_mask), mask));
+ fold_convert (unsigned_type, and_mask), mask));
*pmask = mask;
*pand_mask = and_mask;
if (arg0 != 0 && arg1 != 0)
{
tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
- arg0, convert (TREE_TYPE (arg0), arg1)));
+ arg0, fold_convert (TREE_TYPE (arg0), arg1)));
STRIP_NOPS (tem);
return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
}
abort ();
}
- return convert (type, result ? integer_one_node : integer_zero_node);
+ return fold_convert (type, result ? integer_one_node : integer_zero_node);
}
\f
/* Given EXP, a logical expression, set the range it is testing into
the outer loop when we've changed something; otherwise we "break"
the switch, which will "break" the while. */
- in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
+ in_p = 0;
+ low = high = fold_convert (TREE_TYPE (exp), integer_zero_node);
while (1)
{
if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
{
if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
- 1, convert (type, integer_zero_node),
+ 1, fold_convert (type, integer_zero_node),
NULL_TREE))
break;
in_p = n_in_p, low = n_low, high = n_high;
- /* If the high bound is missing, but we
- have a low bound, reverse the range so
- it goes from zero to the low bound minus 1. */
- if (high == 0 && low)
+ /* If the high bound is missing, but we have a nonzero low
+ bound, reverse the range so it goes from zero to the low bound
+ minus 1. */
+ if (high == 0 && low && ! integer_zerop (low))
{
in_p = ! in_p;
high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
integer_one_node, 0);
- low = convert (type, integer_zero_node);
+ low = fold_convert (type, integer_zero_node);
}
}
continue;
case NEGATE_EXPR:
/* (-x) IN [a,b] -> x in [-b, -a] */
n_low = range_binop (MINUS_EXPR, type,
- convert (type, integer_zero_node), 0, high, 1);
+ fold_convert (type, integer_zero_node),
+ 0, high, 1);
n_high = range_binop (MINUS_EXPR, type,
- convert (type, integer_zero_node), 0, low, 0);
+ fold_convert (type, integer_zero_node),
+ 0, low, 0);
low = n_low, high = n_high;
exp = arg0;
continue;
case BIT_NOT_EXPR:
/* ~ X -> -X - 1 */
exp = build (MINUS_EXPR, type, negate_expr (arg0),
- convert (type, integer_one_node));
+ fold_convert (type, integer_one_node));
continue;
case PLUS_EXPR: case MINUS_EXPR:
n_low = low, n_high = high;
if (n_low != 0)
- n_low = convert (type, n_low);
+ n_low = fold_convert (type, n_low);
if (n_high != 0)
- n_high = convert (type, n_high);
+ n_high = fold_convert (type, n_high);
/* If we're converting from an unsigned to a signed type,
we will be doing the comparison as unsigned. The tests above
if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
high_positive = fold (build (RSHIFT_EXPR, type,
- convert (type, high_positive),
- convert (type, integer_one_node)));
+ fold_convert (type,
+ high_positive),
+ fold_convert (type,
+ integer_one_node)));
/* If the low bound is specified, "and" the range with the
range for which the original unsigned value will be
if (low != 0)
{
if (! merge_ranges (&n_in_p, &n_low, &n_high,
- 1, n_low, n_high,
- 1, convert (type, integer_zero_node),
+ 1, n_low, n_high, 1,
+ fold_convert (type, integer_zero_node),
high_positive))
break;
/* Otherwise, "or" the range with the range of the input
that will be interpreted as negative. */
if (! merge_ranges (&n_in_p, &n_low, &n_high,
- 0, n_low, n_high,
- 1, convert (type, integer_zero_node),
+ 0, n_low, n_high, 1,
+ fold_convert (type, integer_zero_node),
high_positive))
break;
return invert_truthvalue (value);
if (low == 0 && high == 0)
- return convert (type, integer_one_node);
+ return fold_convert (type, integer_one_node);
if (low == 0)
return fold (build (LE_EXPR, type, exp, high));
if (! TREE_UNSIGNED (etype))
{
etype = (*lang_hooks.types.unsigned_type) (etype);
- high = convert (etype, high);
- exp = convert (etype, exp);
+ high = fold_convert (etype, high);
+ exp = fold_convert (etype, exp);
}
return build_range_check (type, exp, 1, 0, high);
}
if (TREE_UNSIGNED (etype))
{
etype = (*lang_hooks.types.signed_type) (etype);
- exp = convert (etype, exp);
+ exp = fold_convert (etype, exp);
}
return fold (build (GT_EXPR, type, exp,
- convert (etype, integer_zero_node)));
+ fold_convert (etype, integer_zero_node)));
}
}
&& ! TREE_OVERFLOW (value))
return build_range_check (type,
fold (build (MINUS_EXPR, etype, exp, low)),
- 1, convert (etype, integer_zero_node), value);
+ 1, fold_convert (etype, integer_zero_node),
+ value);
return 0;
}
zero or one, and the conversion to a signed type can never overflow.
We could get an overflow if this conversion is done anywhere else. */
if (TREE_UNSIGNED (type))
- temp = convert ((*lang_hooks.types.signed_type) (type), temp);
+ temp = fold_convert ((*lang_hooks.types.signed_type) (type), temp);
temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
if (mask != 0)
- temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
+ temp = const_binop (BIT_AND_EXPR, temp,
+ fold_convert (TREE_TYPE (c), mask), 0);
/* If necessary, convert the type back to match the type of C. */
if (TREE_UNSIGNED (type))
- temp = convert (type, temp);
+ temp = fold_convert (type, temp);
- return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
+ return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
}
\f
/* Find ways of folding logical expressions of LHS and RHS:
compcode = -1;
if (compcode == COMPCODE_TRUE)
- return convert (truth_type, integer_one_node);
+ return fold_convert (truth_type, integer_one_node);
else if (compcode == COMPCODE_FALSE)
- return convert (truth_type, integer_zero_node);
+ return fold_convert (truth_type, integer_zero_node);
else if (compcode != -1)
return build (compcode_to_comparison (compcode),
truth_type, ll_arg, lr_arg);
xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
}
- ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
+ ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
size_int (xll_bitpos), 0);
- rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
+ rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
size_int (xrl_bitpos), 0);
if (l_const)
{
- l_const = convert (lntype, l_const);
+ l_const = fold_convert (lntype, l_const);
l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
{
warning ("comparison is always %d", wanted_code == NE_EXPR);
- return convert (truth_type,
- wanted_code == NE_EXPR
- ? integer_one_node : integer_zero_node);
+ return fold_convert (truth_type,
+ wanted_code == NE_EXPR
+ ? integer_one_node : integer_zero_node);
}
}
if (r_const)
{
- r_const = convert (lntype, r_const);
+ r_const = fold_convert (lntype, r_const);
r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
{
warning ("comparison is always %d", wanted_code == NE_EXPR);
- return convert (truth_type,
- wanted_code == NE_EXPR
- ? integer_one_node : integer_zero_node);
+ return fold_convert (truth_type,
+ wanted_code == NE_EXPR
+ ? integer_one_node : integer_zero_node);
}
}
xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
}
- lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
+ lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
size_int (xlr_bitpos), 0);
- rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
+ rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
size_int (xrr_bitpos), 0);
/* Make a mask that corresponds to both fields being compared.
{
if (lnbitsize > rnbitsize)
{
- lhs = convert (rntype, lhs);
- ll_mask = convert (rntype, ll_mask);
+ lhs = fold_convert (rntype, lhs);
+ ll_mask = fold_convert (rntype, ll_mask);
type = rntype;
}
else if (lnbitsize < rnbitsize)
{
- rhs = convert (lntype, rhs);
- lr_mask = convert (lntype, lr_mask);
+ rhs = fold_convert (lntype, rhs);
+ lr_mask = fold_convert (lntype, lr_mask);
type = lntype;
}
}
if (wanted_code == NE_EXPR)
{
warning ("`or' of unmatched not-equal tests is always 1");
- return convert (truth_type, integer_one_node);
+ return fold_convert (truth_type, integer_one_node);
}
else
{
warning ("`and' of mutually exclusive equal-tests is always 0");
- return convert (truth_type, integer_zero_node);
+ return fold_convert (truth_type, integer_zero_node);
}
}
or (for divide and modulus) if it is a multiple of our constant. */
if (code == MULT_EXPR
|| integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
- return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
+ return const_binop (code, fold_convert (ctype, t),
+ fold_convert (ctype, c), 0);
break;
case CONVERT_EXPR: case NON_LVALUE_EXPR: case NOP_EXPR:
/* Pass the constant down and see if we can make a simplification. If
we can, replace this expression with the inner simplification for
possible later conversion to our or some other type. */
- if ((t2 = convert (TREE_TYPE (op0), c)) != 0
+ if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
&& TREE_CODE (t2) == INTEGER_CST
&& ! TREE_CONSTANT_OVERFLOW (t2)
&& (0 != (t1 = extract_muldiv (op0, t2, code,
case NEGATE_EXPR: case ABS_EXPR:
if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
- return fold (build1 (tcode, ctype, convert (ctype, t1)));
+ return fold (build1 (tcode, ctype, fold_convert (ctype, t1)));
break;
case MIN_EXPR: case MAX_EXPR:
if (tree_int_cst_sgn (c) < 0)
tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
- return fold (build (tcode, ctype, convert (ctype, t1),
- convert (ctype, t2)));
+ return fold (build (tcode, ctype, fold_convert (ctype, t1),
+ fold_convert (ctype, t2)));
}
break;
so check for it explicitly here. */
&& TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
&& TREE_INT_CST_HIGH (op1) == 0
- && 0 != (t1 = convert (ctype,
- const_binop (LSHIFT_EXPR, size_one_node,
- op1, 0)))
+ && 0 != (t1 = fold_convert (ctype,
+ const_binop (LSHIFT_EXPR,
+ size_one_node,
+ op1, 0)))
&& ! TREE_OVERFLOW (t1))
return extract_muldiv (build (tcode == LSHIFT_EXPR
? MULT_EXPR : FLOOR_DIV_EXPR,
- ctype, convert (ctype, op0), t1),
+ ctype, fold_convert (ctype, op0), t1),
c, code, wide_type);
break;
are divisible by c. */
|| (multiple_of_p (ctype, op0, c)
&& multiple_of_p (ctype, op1, c))))
- return fold (build (tcode, ctype, convert (ctype, t1),
- convert (ctype, t2)));
+ return fold (build (tcode, ctype, fold_convert (ctype, t1),
+ fold_convert (ctype, t2)));
/* If this was a subtraction, negate OP1 and set it to be an addition.
This simplifies the logic below. */
if (code == MULT_EXPR
|| integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
{
- op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
- if (op1 == 0 || TREE_OVERFLOW (op1))
+ op1 = const_binop (code, fold_convert (ctype, op1),
+ fold_convert (ctype, c), 0);
+ /* We allow the constant to overflow with wrapping semantics. */
+ if (op1 == 0
+ || (TREE_OVERFLOW (op1) && ! flag_wrapv))
break;
}
else
/* If we were able to eliminate our operation from the first side,
apply our operation to the second side and reform the PLUS. */
if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
- return fold (build (tcode, ctype, convert (ctype, t1), op1));
+ return fold (build (tcode, ctype, fold_convert (ctype, t1), op1));
/* The last case is if we are a multiply. In that case, we can
apply the distributive law to commute the multiply and addition
if the multiplication of the constants doesn't overflow. */
if (code == MULT_EXPR)
- return fold (build (tcode, ctype, fold (build (code, ctype,
- convert (ctype, op0),
- convert (ctype, c))),
+ return fold (build (tcode, ctype,
+ fold (build (code, ctype,
+ fold_convert (ctype, op0),
+ fold_convert (ctype, c))),
op1));
break;
do something only if the second operand is a constant. */
if (same_p
&& (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
- return fold (build (tcode, ctype, convert (ctype, t1),
- convert (ctype, op1)));
+ return fold (build (tcode, ctype, fold_convert (ctype, t1),
+ fold_convert (ctype, op1)));
else if (tcode == MULT_EXPR && code == MULT_EXPR
&& (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
- return fold (build (tcode, ctype, convert (ctype, op0),
- convert (ctype, t1)));
+ return fold (build (tcode, ctype, fold_convert (ctype, op0),
+ fold_convert (ctype, t1)));
else if (TREE_CODE (op1) != INTEGER_CST)
return 0;
/* If these are the same operation types, we can associate them
assuming no overflow. */
if (tcode == code
- && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
- convert (ctype, c), 0))
+ && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
+ fold_convert (ctype, c), 0))
&& ! TREE_OVERFLOW (t1))
- return fold (build (tcode, ctype, convert (ctype, op0), t1));
+ return fold (build (tcode, ctype, fold_convert (ctype, op0), t1));
/* If these operations "cancel" each other, we have the main
optimizations of this pass, which occur when either constant is a
&& code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
{
if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
- return fold (build (tcode, ctype, convert (ctype, op0),
- convert (ctype,
- const_binop (TRUNC_DIV_EXPR,
- op1, c, 0))));
+ return fold (build (tcode, ctype, fold_convert (ctype, op0),
+ fold_convert (ctype,
+ const_binop (TRUNC_DIV_EXPR,
+ op1, c, 0))));
else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
- return fold (build (code, ctype, convert (ctype, op0),
- convert (ctype,
- const_binop (TRUNC_DIV_EXPR,
- c, op1, 0))));
+ return fold (build (code, ctype, fold_convert (ctype, op0),
+ fold_convert (ctype,
+ const_binop (TRUNC_DIV_EXPR,
+ c, op1, 0))));
}
break;
{
tree testtype = TREE_TYPE (cond);
test = cond;
- true_value = convert (testtype, integer_one_node);
- false_value = convert (testtype, integer_zero_node);
+ true_value = fold_convert (testtype, integer_one_node);
+ false_value = fold_convert (testtype, integer_zero_node);
}
/* If ARG is complex we want to make sure we only evaluate it once. Though
{
arg = save_expr (arg);
lhs = rhs = 0;
- save = 1;
+ save = saved_expr_p (arg);
}
}
test = fold (build (COND_EXPR, type, test, lhs, rhs));
+ /* If ARG involves a SAVE_EXPR, we need to ensure it is evaluated
+ ahead of the COND_EXPR we made. Otherwise we would have it only
+ evaluated in one branch, with the other branch using the result
+ but missing the evaluation code. Beware that the save_expr call
+ above might not return a SAVE_EXPR, so testing the TREE_CODE
+ of ARG is not enough to decide here. */
if (save)
return build (COMPOUND_EXPR, type,
- convert (void_type_node, arg),
+ fold_convert (void_type_node, arg),
strip_compound_expr (test, arg));
else
- return convert (type, test);
+ return fold_convert (type, test);
}
\f
/* sqrt(x) < y is always false, if y is negative. */
if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
return omit_one_operand (type,
- convert (type, integer_zero_node),
+ fold_convert (type, integer_zero_node),
arg);
/* sqrt(x) > y is always true, if y is negative and we
don't care about NaNs, i.e. negative values of x. */
if (code == NE_EXPR || !HONOR_NANS (mode))
return omit_one_operand (type,
- convert (type, integer_one_node),
+ fold_convert (type, integer_one_node),
arg);
/* sqrt(x) > y is the same as x >= 0, if y is negative. */
/* sqrt(x) > y is always false, when y is very large
and we don't care about infinities. */
return omit_one_operand (type,
- convert (type, integer_zero_node),
+ fold_convert (type, integer_zero_node),
arg);
}
value and we don't care about NaNs or Infinities. */
if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
return omit_one_operand (type,
- convert (type, integer_one_node),
+ fold_convert (type, integer_one_node),
arg);
/* sqrt(x) < y is x != +Inf when y is very large and we
if (HONOR_SNANS (mode))
return NULL_TREE;
return omit_one_operand (type,
- convert (type, integer_zero_node),
+ fold_convert (type, integer_zero_node),
arg0);
case LE_EXPR:
/* x <= +Inf is always true, if we don't case about NaNs. */
if (! HONOR_NANS (mode))
return omit_one_operand (type,
- convert (type, integer_one_node),
+ fold_convert (type, integer_one_node),
arg0);
/* x <= +Inf is the same as x == x, i.e. isfinite(x). */
int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
enum machine_mode operand_mode = TYPE_MODE (type);
int ops_unsigned;
- tree signed_type, unsigned_type;
+ tree signed_type, unsigned_type, intermediate_type;
tree arg00;
/* If we have (A & C) != 0 where C is the sign bit of A, convert
{
tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
- convert (stype, arg00),
- convert (stype, integer_zero_node)));
+ fold_convert (stype, arg00),
+ fold_convert (stype, integer_zero_node)));
}
/* At this point, we know that arg0 is not testing the sign bit. */
signed_type = (*lang_hooks.types.type_for_mode) (operand_mode, 0);
unsigned_type = (*lang_hooks.types.type_for_mode) (operand_mode, 1);
+ intermediate_type = ops_unsigned ? unsigned_type : signed_type;
+ inner = fold_convert (intermediate_type, inner);
if (bitnum != 0)
- inner = build (RSHIFT_EXPR, ops_unsigned ? unsigned_type : signed_type,
+ inner = build (RSHIFT_EXPR, intermediate_type,
inner, size_int (bitnum));
if (code == EQ_EXPR)
- inner = build (BIT_XOR_EXPR, ops_unsigned ? unsigned_type : signed_type,
+ inner = build (BIT_XOR_EXPR, intermediate_type,
inner, integer_one_node);
/* Put the AND last so it can combine with more things. */
- inner = build (BIT_AND_EXPR, ops_unsigned ? unsigned_type : signed_type,
+ inner = build (BIT_AND_EXPR, intermediate_type,
inner, integer_one_node);
/* Make sure to return the proper type. */
- if (TREE_TYPE (inner) != result_type)
- inner = convert (result_type, inner);
+ inner = fold_convert (result_type, inner);
return inner;
}
return NULL_TREE;
}
+/* Check whether we are allowed to reorder operands arg0 and arg1,
+ such that the evaluation of arg1 occurs before arg0. */
+
+static bool
+reorder_operands_p (tree arg0, tree arg1)
+{
+ if (! flag_evaluation_order)
+ return true;
+ if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
+ return true;
+ return ! TREE_SIDE_EFFECTS (arg0)
+ && ! TREE_SIDE_EFFECTS (arg1);
+}
+
/* Test whether it is preferable two swap two operands, ARG0 and
ARG1, for example because ARG0 is an integer constant and ARG1
- isn't. */
+ isn't. If REORDER is true, only recommend swapping if we can
+ evaluate the operands in reverse order. */
static bool
-tree_swap_operands_p (tree arg0, tree arg1)
+tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
{
STRIP_SIGN_NOPS (arg0);
STRIP_SIGN_NOPS (arg1);
return 0;
if (TREE_CONSTANT (arg0))
return 1;
+
+ if (optimize_size)
+ return 0;
- if (DECL_P (arg1))
+ if (reorder && flag_evaluation_order
+ && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
return 0;
- if (DECL_P (arg0))
- return 1;
- if (TREE_CODE (arg1) == SAVE_EXPR)
+ if (DECL_P (arg1))
return 0;
- if (TREE_CODE (arg0) == SAVE_EXPR)
+ if (DECL_P (arg0))
return 1;
return 0;
if (kind == 'c')
return t;
-#ifdef MAX_INTEGER_COMPUTATION_MODE
- check_max_integer_computation_mode (expr);
-#endif
orig_t = t;
if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
/* If this is a commutative operation, and ARG0 is a constant, move it
to ARG1 to reduce the number of tests below. */
- if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
- || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
- || code == BIT_AND_EXPR)
- && tree_swap_operands_p (arg0, arg1))
+ if (commutative_tree_code (code)
+ && tree_swap_operands_p (arg0, arg1, true))
return fold (build (code, type, arg1, arg0));
/* Now WINS is set as described above,
case FLOAT_EXPR:
case CONVERT_EXPR:
case FIX_TRUNC_EXPR:
- /* Other kinds of FIX are not handled properly by fold_convert. */
-
+ case FIX_CEIL_EXPR:
+ case FIX_FLOOR_EXPR:
if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
return TREE_OPERAND (t, 0);
if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
&& ((inter_int && final_int) || (inter_float && final_float))
&& inter_prec >= final_prec)
- return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
+ return fold (build1 (code, final_type,
+ TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
/* Likewise, if the intermediate and final types are either both
float or both integer, we don't need the middle conversion if
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
&& TYPE_MODE (final_type) == TYPE_MODE (inter_type))
&& ! final_ptr)
- return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
+ return fold (build1 (code, final_type,
+ TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
/* If we have a sign-extension of a zero-extended value, we can
replace that by a single zero-extension. */
if (inside_int && inter_int && final_int
&& inside_prec < inter_prec && inter_prec < final_prec
&& inside_unsignedp && !inter_unsignedp)
- return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
+ return fold (build1 (code, final_type,
+ TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
/* Two conversions in a row are not needed unless:
- some conversion is floating-point (overstrict for now), or
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
&& TYPE_MODE (final_type) == TYPE_MODE (inter_type))
&& ! final_ptr)
- return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
+ return fold (build1 (code, final_type,
+ TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
}
if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
== ZERO_EXTEND))
{
tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
- and0 = convert (uns, and0);
- and1 = convert (uns, and1);
+ and0 = fold_convert (uns, and0);
+ and1 = fold_convert (uns, and1);
}
#endif
}
if (change)
return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
- convert (TREE_TYPE (t), and0),
- convert (TREE_TYPE (t), and1)));
+ fold_convert (TREE_TYPE (t), and0),
+ fold_convert (TREE_TYPE (t), and1)));
}
- if (!wins)
- {
- if (TREE_CONSTANT (t) != TREE_CONSTANT (arg0))
- {
- if (t == orig_t)
- t = copy_node (t);
- TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
- }
- return t;
- }
- return fold_convert (t, arg0);
+ tem = fold_convert_const (code, TREE_TYPE (t), arg0);
+ return tem ? tem : t;
case VIEW_CONVERT_EXPR:
if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
return t;
case NEGATE_EXPR:
- if (wins)
- {
- if (TREE_CODE (arg0) == INTEGER_CST)
- {
- unsigned HOST_WIDE_INT low;
- HOST_WIDE_INT high;
- int overflow = neg_double (TREE_INT_CST_LOW (arg0),
- TREE_INT_CST_HIGH (arg0),
- &low, &high);
- t = build_int_2 (low, high);
- TREE_TYPE (t) = type;
- TREE_OVERFLOW (t)
- = (TREE_OVERFLOW (arg0)
- | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
- TREE_CONSTANT_OVERFLOW (t)
- = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
- }
- else if (TREE_CODE (arg0) == REAL_CST)
- t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
- }
- else if (TREE_CODE (arg0) == NEGATE_EXPR)
- return TREE_OPERAND (arg0, 0);
- /* Convert -((double)float) into (double)(-float). */
- else if (TREE_CODE (arg0) == NOP_EXPR
- && TREE_CODE (type) == REAL_TYPE)
- {
- tree targ0 = strip_float_extensions (arg0);
- if (targ0 != arg0)
- return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (targ0), targ0));
-
- }
-
- /* Convert - (a - b) to (b - a) for non-floating-point. */
- else if (TREE_CODE (arg0) == MINUS_EXPR
- && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
- return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
- TREE_OPERAND (arg0, 0));
-
- /* Convert -f(x) into f(-x) where f is sin, tan or atan. */
- switch (builtin_mathfn_code (arg0))
- {
- case BUILT_IN_SIN:
- case BUILT_IN_SINF:
- case BUILT_IN_SINL:
- case BUILT_IN_TAN:
- case BUILT_IN_TANF:
- case BUILT_IN_TANL:
- case BUILT_IN_ATAN:
- case BUILT_IN_ATANF:
- case BUILT_IN_ATANL:
- if (negate_expr_p (TREE_VALUE (TREE_OPERAND (arg0, 1))))
- {
- tree fndecl, arg, arglist;
-
- fndecl = get_callee_fndecl (arg0);
- arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
- arg = fold (build1 (NEGATE_EXPR, type, arg));
- arglist = build_tree_list (NULL_TREE, arg);
- return build_function_call_expr (fndecl, arglist);
- }
- break;
-
- default:
- break;
- }
+ if (negate_expr_p (arg0))
+ return fold_convert (type, negate_expr (arg0));
return t;
case ABS_EXPR:
{
tree targ0 = strip_float_extensions (arg0);
if (targ0 != arg0)
- return convert (type, fold (build1 (ABS_EXPR, TREE_TYPE (targ0),
- targ0)));
+ return fold_convert (type, fold (build1 (ABS_EXPR,
+ TREE_TYPE (targ0),
+ targ0)));
}
else if (tree_expr_nonnegative_p (arg0))
return arg0;
case CONJ_EXPR:
if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
- return convert (type, arg0);
+ return fold_convert (type, arg0);
else if (TREE_CODE (arg0) == COMPLEX_EXPR)
return build (COMPLEX_EXPR, type,
TREE_OPERAND (arg0, 0),
else if (! FLOAT_TYPE_P (type))
{
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* If we are adding two BIT_AND_EXPR's, both of which are and'ing
with a constant, and the two constants have no bits in common,
&& TREE_CODE (parg1) != MULT_EXPR)
return fold (build (PLUS_EXPR, type,
fold (build (PLUS_EXPR, type,
- convert (type, parg0),
- convert (type, marg))),
- convert (type, parg1)));
+ fold_convert (type, parg0),
+ fold_convert (type, marg))),
+ fold_convert (type, parg1)));
if (TREE_CODE (parg0) != MULT_EXPR
&& TREE_CODE (parg1) == MULT_EXPR)
return fold (build (PLUS_EXPR, type,
fold (build (PLUS_EXPR, type,
- convert (type, parg1),
- convert (type, marg))),
- convert (type, parg0)));
+ fold_convert (type, parg1),
+ fold_convert (type, marg))),
+ fold_convert (type, parg0)));
}
if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
{
/* See if ARG1 is zero and X + ARG1 reduces to X. */
if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* Likewise if the operands are reversed. */
if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
- return non_lvalue (convert (type, arg1));
+ return non_lvalue (fold_convert (type, arg1));
/* Convert x+x into x*2.0. */
if (operand_equal_p (arg0, arg1, 0)
if (minus_lit0)
{
if (con0 == 0)
- return convert (type, associate_trees (var0, minus_lit0,
- MINUS_EXPR, type));
+ return fold_convert (type,
+ associate_trees (var0, minus_lit0,
+ MINUS_EXPR, type));
else
{
con0 = associate_trees (con0, minus_lit0,
MINUS_EXPR, type);
- return convert (type, associate_trees (var0, con0,
- PLUS_EXPR, type));
+ return fold_convert (type,
+ associate_trees (var0, con0,
+ PLUS_EXPR, type));
}
}
con0 = associate_trees (con0, lit0, code, type);
- return convert (type, associate_trees (var0, con0, code, type));
+ return fold_convert (type, associate_trees (var0, con0,
+ code, type));
}
}
/* The return value should always have
the same type as the original expression. */
if (TREE_TYPE (t1) != TREE_TYPE (t))
- t1 = convert (TREE_TYPE (t), t1);
+ t1 = fold_convert (TREE_TYPE (t), t1);
return t1;
}
&& (FLOAT_TYPE_P (type)
|| (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
&& negate_expr_p (arg1)
- && (! TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
- && (! TREE_SIDE_EFFECTS (arg1) || TREE_CONSTANT (arg0)))
+ && reorder_operands_p (arg0, arg1))
return fold (build (MINUS_EXPR, type, negate_expr (arg1),
TREE_OPERAND (arg0, 0)));
if (! FLOAT_TYPE_P (type))
{
if (! wins && integer_zerop (arg0))
- return negate_expr (convert (type, arg1));
+ return negate_expr (fold_convert (type, arg1));
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
-
- /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
- about the case where C is a constant, just try one of the
- four possibilities. */
-
- if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
- && operand_equal_p (TREE_OPERAND (arg0, 1),
- TREE_OPERAND (arg1, 1), 0))
- return fold (build (MULT_EXPR, type,
- fold (build (MINUS_EXPR, type,
- TREE_OPERAND (arg0, 0),
- TREE_OPERAND (arg1, 0))),
- TREE_OPERAND (arg0, 1)));
+ return non_lvalue (fold_convert (type, arg0));
/* Fold A - (A & B) into ~B & A. */
if (!TREE_SIDE_EFFECTS (arg0)
TREE_OPERAND (arg1, 1))),
arg0));
}
+
+ /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
+ any power of 2 minus 1. */
+ if (TREE_CODE (arg0) == BIT_AND_EXPR
+ && TREE_CODE (arg1) == BIT_AND_EXPR
+ && operand_equal_p (TREE_OPERAND (arg0, 0),
+ TREE_OPERAND (arg1, 0), 0))
+ {
+ tree mask0 = TREE_OPERAND (arg0, 1);
+ tree mask1 = TREE_OPERAND (arg1, 1);
+ tree tem = fold (build1 (BIT_NOT_EXPR, type, mask0));
+
+ if (operand_equal_p (tem, mask1, 0))
+ {
+ tem = fold (build (BIT_XOR_EXPR, type,
+ TREE_OPERAND (arg0, 0), mask1));
+ return fold (build (MINUS_EXPR, type, tem, mask1));
+ }
+ }
}
/* See if ARG1 is zero and X - ARG1 reduces to X. */
else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
ARG0 is zero and X + ARG0 reduces to X, since that would mean
(-ARG1 + ARG0) reduces to -ARG1. */
else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
- return negate_expr (convert (type, arg1));
+ return negate_expr (fold_convert (type, arg1));
/* Fold &x - &x. This can happen from &x.foo - &x.
This is unsafe for certain floats even in non-IEEE formats.
if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
&& operand_equal_p (arg0, arg1, 0))
- return convert (type, integer_zero_node);
+ return fold_convert (type, integer_zero_node);
+
+ /* A - B -> A + (-B) if B is easily negatable. */
+ if (!wins && negate_expr_p (arg1)
+ && (FLOAT_TYPE_P (type)
+ || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
+ return fold (build (PLUS_EXPR, type, arg0, negate_expr (arg1)));
+
+ if (TREE_CODE (arg0) == MULT_EXPR
+ && TREE_CODE (arg1) == MULT_EXPR
+ && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
+ {
+ /* (A * C) - (B * C) -> (A-B) * C. */
+ if (operand_equal_p (TREE_OPERAND (arg0, 1),
+ TREE_OPERAND (arg1, 1), 0))
+ return fold (build (MULT_EXPR, type,
+ fold (build (MINUS_EXPR, type,
+ TREE_OPERAND (arg0, 0),
+ TREE_OPERAND (arg1, 0))),
+ TREE_OPERAND (arg0, 1)));
+ /* (A * C1) - (A * C2) -> A * (C1-C2). */
+ if (operand_equal_p (TREE_OPERAND (arg0, 0),
+ TREE_OPERAND (arg1, 0), 0))
+ return fold (build (MULT_EXPR, type,
+ TREE_OPERAND (arg0, 0),
+ fold (build (MINUS_EXPR, type,
+ TREE_OPERAND (arg0, 1),
+ TREE_OPERAND (arg1, 1)))));
+ }
goto associate;
if (integer_zerop (arg1))
return omit_one_operand (type, arg1, arg0);
if (integer_onep (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* (a * (1 << b)) is (a << b) */
if (TREE_CODE (arg1) == LSHIFT_EXPR
if (TREE_CODE (arg1) == INTEGER_CST
&& 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
- convert (type, arg1),
+ fold_convert (type, arg1),
code, NULL_TREE)))
- return convert (type, tem);
+ return fold_convert (type, tem);
}
else
/* In IEEE floating point, x*1 is not equivalent to x for snans. */
if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
&& real_onep (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* Transform x * -1.0 into -x. */
if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
if (integer_all_onesp (arg1))
return omit_one_operand (type, arg1, arg0);
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
t1 = distribute_bit_expr (code, type, arg0, arg1);
if (t1 != NULL_TREE)
return t1;
case BIT_XOR_EXPR:
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
if (integer_all_onesp (arg1))
return fold (build1 (BIT_NOT_EXPR, type, arg0));
case BIT_AND_EXPR:
if (integer_all_onesp (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
if (integer_zerop (arg1))
return omit_one_operand (type, arg1, arg0);
t1 = distribute_bit_expr (code, type, arg0, arg1);
if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
&& (~TREE_INT_CST_LOW (arg1)
& (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
- return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
+ return fold_convert (type, TREE_OPERAND (arg0, 0));
}
/* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
/* In IEEE floating point, x/1 is not equivalent to x for snans. */
if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
&& real_onep (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
&& real_minus_onep (arg1))
- return non_lvalue (convert (type, negate_expr (arg0)));
+ return non_lvalue (fold_convert (type, negate_expr (arg0)));
/* If ARG1 is a constant, we can convert this to a multiply by the
reciprocal. This does not have the same rounding properties,
case CEIL_DIV_EXPR:
case EXACT_DIV_EXPR:
if (integer_onep (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
if (integer_zerop (arg1))
return t;
if (TREE_CODE (arg1) == INTEGER_CST
&& 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
code, NULL_TREE)))
- return convert (type, tem);
+ return fold_convert (type, tem);
goto binary;
if (TREE_CODE (arg1) == INTEGER_CST
&& 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
code, NULL_TREE)))
- return convert (type, tem);
+ return fold_convert (type, tem);
goto binary;
case LSHIFT_EXPR:
shift:
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
if (integer_zerop (arg0))
return omit_one_operand (type, arg0, arg1);
if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
{
tree tem = build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
- tem = convert (TREE_TYPE (arg1), tem);
+ tem = fold_convert (TREE_TYPE (arg1), tem);
tem = const_binop (MINUS_EXPR, tem, arg1, 0);
return fold (build (RROTATE_EXPR, type, arg0, tem));
}
return tem;
return t;
}
- return convert (type, tem);
+ return fold_convert (type, tem);
case TRUTH_ANDIF_EXPR:
/* Note that the operands of this must be ints
("true" is a fixed value perhaps depending on the language.) */
/* If first arg is constant zero, return it. */
if (integer_zerop (arg0))
- return convert (type, arg0);
+ return fold_convert (type, arg0);
case TRUTH_AND_EXPR:
/* If either arg is constant true, drop it. */
if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
- return non_lvalue (convert (type, arg1));
+ return non_lvalue (fold_convert (type, arg1));
if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
/* Preserve sequence points. */
&& (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* If second arg is constant zero, result is zero, but first arg
must be evaluated. */
if (integer_zerop (arg1))
("true" is a fixed value perhaps depending on the language.) */
/* If first arg is constant true, return it. */
if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
- return convert (type, arg0);
+ return fold_convert (type, arg0);
case TRUTH_OR_EXPR:
/* If either arg is constant zero, drop it. */
if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
- return non_lvalue (convert (type, arg1));
+ return non_lvalue (fold_convert (type, arg1));
if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
/* Preserve sequence points. */
&& (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* If second arg is constant true, result is true, but we must
evaluate first arg. */
if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
case TRUTH_XOR_EXPR:
/* If either arg is constant zero, drop it. */
if (integer_zerop (arg0))
- return non_lvalue (convert (type, arg1));
+ return non_lvalue (fold_convert (type, arg1));
if (integer_zerop (arg1))
- return non_lvalue (convert (type, arg0));
+ return non_lvalue (fold_convert (type, arg0));
/* If either arg is constant true, this is a logical inversion. */
if (integer_onep (arg0))
- return non_lvalue (convert (type, invert_truthvalue (arg1)));
+ return non_lvalue (fold_convert (type, invert_truthvalue (arg1)));
if (integer_onep (arg1))
- return non_lvalue (convert (type, invert_truthvalue (arg0)));
+ return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
return t;
case EQ_EXPR:
case LE_EXPR:
case GE_EXPR:
/* If one arg is a real or integer constant, put it last. */
- if (tree_swap_operands_p (arg0, arg1))
+ if (tree_swap_operands_p (arg0, arg1, true))
return fold (build (swap_tree_comparison (code), type, arg1, arg0));
if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
/* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
- return fold (build (code, type, convert (newtype, targ0),
- convert (newtype, targ1)));
+ return fold (build (code, type, fold_convert (newtype, targ0),
+ fold_convert (newtype, targ1)));
/* (-a) CMP (-b) -> b CMP a */
if (TREE_CODE (arg0) == NEGATE_EXPR
&& ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
{
t = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
- return omit_one_operand (type, convert (type, t), arg0);
+ return omit_one_operand (type, fold_convert (type, t), arg0);
}
/* Fold comparisons against infinity. */
size_int (precision - size), 0);
newconst = fold (build (BIT_AND_EXPR,
TREE_TYPE (varop), newconst,
- convert (TREE_TYPE (varop),
- mask)));
+ fold_convert (TREE_TYPE (varop),
+ mask)));
}
t = build (code, type,
size_int (precision - size), 0);
newconst = fold (build (BIT_AND_EXPR,
TREE_TYPE (varop), newconst,
- convert (TREE_TYPE (varop),
- mask)));
+ fold_convert (TREE_TYPE (varop),
+ mask)));
}
t = build (code, type,
{
case GT_EXPR:
return omit_one_operand (type,
- convert (type, integer_zero_node),
+ fold_convert (type,
+ integer_zero_node),
arg0);
case GE_EXPR:
return fold (build (EQ_EXPR, type, arg0, arg1));
case LE_EXPR:
return omit_one_operand (type,
- convert (type, integer_one_node),
+ fold_convert (type,
+ integer_one_node),
arg0);
case LT_EXPR:
return fold (build (NE_EXPR, type, arg0, arg1));
{
case LT_EXPR:
return omit_one_operand (type,
- convert (type, integer_zero_node),
+ fold_convert (type,
+ integer_zero_node),
arg0);
case LE_EXPR:
return fold (build (EQ_EXPR, type, arg0, arg1));
case GE_EXPR:
return omit_one_operand (type,
- convert (type, integer_one_node),
+ fold_convert (type,
+ integer_one_node),
arg0);
case GT_EXPR:
return fold (build (NE_EXPR, type, arg0, arg1));
st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
return fold
(build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
- type, convert (st0, arg0),
- convert (st1, integer_zero_node)));
+ type, fold_convert (st0, arg0),
+ fold_convert (st1, integer_zero_node)));
}
}
}
&& (TREE_TYPE (t1) == TREE_TYPE (tem)
|| (TREE_CODE (t1) == INTEGER_CST
&& int_fits_type_p (t1, TREE_TYPE (tem)))))
- return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
+ return fold (build (code, type, tem,
+ fold_convert (TREE_TYPE (tem), t1)));
/* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
constant, we can simplify it. */
TREE_TYPE (TREE_OPERAND (arg0, 0)),
TREE_OPERAND (arg0, 1),
TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
- convert (TREE_TYPE (arg0),
- integer_one_node)),
+ fold_convert (TREE_TYPE (arg0),
+ integer_one_node)),
arg1));
else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
&& integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
TREE_TYPE (TREE_OPERAND (arg0, 1)),
TREE_OPERAND (arg0, 0),
TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
- convert (TREE_TYPE (arg0),
- integer_one_node)),
+ fold_convert (TREE_TYPE (arg0),
+ integer_one_node)),
arg1));
}
{
tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
tree newmod = build (TREE_CODE (arg0), newtype,
- convert (newtype, TREE_OPERAND (arg0, 0)),
- convert (newtype, TREE_OPERAND (arg0, 1)));
+ fold_convert (newtype,
+ TREE_OPERAND (arg0, 0)),
+ fold_convert (newtype,
+ TREE_OPERAND (arg0, 1)));
- return build (code, type, newmod, convert (newtype, arg1));
+ return build (code, type, newmod, fold_convert (newtype, arg1));
}
/* If this is an NE comparison of zero with an AND of one, remove the
if (code == NE_EXPR && integer_zerop (arg1)
&& TREE_CODE (arg0) == BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (arg0, 1)))
- return convert (type, arg0);
+ return fold_convert (type, arg0);
/* If we have (A & C) == C where C is a power of 2, convert this into
(A & C) != 0. Similarly for NE_EXPR. */
return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
TREE_OPERAND (arg1, 1)),
- convert (TREE_TYPE (arg0), integer_zero_node));
+ fold_convert (TREE_TYPE (arg0), integer_zero_node));
else if ((code == LT_EXPR || code == GE_EXPR)
&& TREE_UNSIGNED (TREE_TYPE (arg0))
&& integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
return
build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
- convert (TREE_TYPE (arg0),
- build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
- TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
- convert (TREE_TYPE (arg0), integer_zero_node));
+ fold_convert (TREE_TYPE (arg0),
+ build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
+ TREE_OPERAND (TREE_OPERAND (arg1, 0),
+ 1))),
+ fold_convert (TREE_TYPE (arg0), integer_zero_node));
/* Simplify comparison of something with itself. (For IEEE
floating-point, we can only do some of these simplifications.) */
&& (optimize || TREE_CODE (arg1) == INTEGER_CST))
{
t1 = optimize_bit_field_compare (code, type, arg0, arg1);
- return t1 ? t1 : t;
+ if (t1)
+ return t1;
}
/* If this is a comparison of complex values and either or both sides
/* Pedantic ANSI C says that a conditional expression is never an lvalue,
so all simple results must be passed through pedantic_non_lvalue. */
if (TREE_CODE (arg0) == INTEGER_CST)
- return pedantic_non_lvalue
- (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
- else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
+ {
+ tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
+ /* Only optimize constant conditions when the selected branch
+ has the same type as the COND_EXPR. This avoids optimizing
+ away "c ? x : throw", where the throw has a void type. */
+ if (! VOID_TYPE_P (TREE_TYPE (tem))
+ || VOID_TYPE_P (TREE_TYPE (t)))
+ return pedantic_non_lvalue (tem);
+ return t;
+ }
+ if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
return pedantic_omit_one_operand (type, arg1, arg0);
/* If we have A op B ? A : C, we may be able to convert this to a
switch (comp_code)
{
case EQ_EXPR:
- return
- pedantic_non_lvalue
- (convert (type,
- negate_expr
- (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
- arg1))));
+ tem = fold_convert (TREE_TYPE (TREE_OPERAND (t, 1)), arg1);
+ tem = fold_convert (type, negate_expr (tem));
+ return pedantic_non_lvalue (tem);
case NE_EXPR:
- return pedantic_non_lvalue (convert (type, arg1));
+ return pedantic_non_lvalue (fold_convert (type, arg1));
case GE_EXPR:
case GT_EXPR:
if (TREE_UNSIGNED (TREE_TYPE (arg1)))
- arg1 = convert ((*lang_hooks.types.signed_type)
- (TREE_TYPE (arg1)), arg1);
- return pedantic_non_lvalue
- (convert (type, fold (build1 (ABS_EXPR,
- TREE_TYPE (arg1), arg1))));
+ arg1 = fold_convert ((*lang_hooks.types.signed_type)
+ (TREE_TYPE (arg1)), arg1);
+ arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
+ return pedantic_non_lvalue (fold_convert (type, arg1));
case LE_EXPR:
case LT_EXPR:
if (TREE_UNSIGNED (TREE_TYPE (arg1)))
- arg1 = convert ((lang_hooks.types.signed_type)
- (TREE_TYPE (arg1)), arg1);
- return pedantic_non_lvalue
- (negate_expr (convert (type,
- fold (build1 (ABS_EXPR,
- TREE_TYPE (arg1),
- arg1)))));
+ arg1 = fold_convert ((lang_hooks.types.signed_type)
+ (TREE_TYPE (arg1)), arg1);
+ arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
+ arg1 = negate_expr (fold_convert (type, arg1));
+ return pedantic_non_lvalue (arg1);
default:
abort ();
}
if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
{
if (comp_code == NE_EXPR)
- return pedantic_non_lvalue (convert (type, arg1));
+ return pedantic_non_lvalue (fold_convert (type, arg1));
else if (comp_code == EQ_EXPR)
- return pedantic_non_lvalue (convert (type, integer_zero_node));
+ return pedantic_non_lvalue (fold_convert (type, integer_zero_node));
}
/* Try some transformations of A op B ? A : B.
switch (comp_code)
{
case EQ_EXPR:
- return pedantic_non_lvalue (convert (type, arg2));
+ return pedantic_non_lvalue (fold_convert (type, arg2));
case NE_EXPR:
- return pedantic_non_lvalue (convert (type, arg1));
+ return pedantic_non_lvalue (fold_convert (type, arg1));
case LE_EXPR:
case LT_EXPR:
/* In C++ a ?: expression can be an lvalue, so put the
so that we can convert this back to the
corresponding COND_EXPR. */
if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
- return pedantic_non_lvalue
- (convert (type, fold (build (MIN_EXPR, comp_type,
- (comp_code == LE_EXPR
- ? comp_op0 : comp_op1),
- (comp_code == LE_EXPR
- ? comp_op1 : comp_op0)))));
+ return pedantic_non_lvalue (fold_convert
+ (type, fold (build (MIN_EXPR, comp_type,
+ (comp_code == LE_EXPR
+ ? comp_op0 : comp_op1),
+ (comp_code == LE_EXPR
+ ? comp_op1 : comp_op0)))));
break;
case GE_EXPR:
case GT_EXPR:
if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
- return pedantic_non_lvalue
- (convert (type, fold (build (MAX_EXPR, comp_type,
- (comp_code == GE_EXPR
- ? comp_op0 : comp_op1),
- (comp_code == GE_EXPR
- ? comp_op1 : comp_op0)))));
+ return pedantic_non_lvalue (fold_convert
+ (type, fold (build (MAX_EXPR, comp_type,
+ (comp_code == GE_EXPR
+ ? comp_op0 : comp_op1),
+ (comp_code == GE_EXPR
+ ? comp_op1 : comp_op0)))));
break;
default:
abort ();
{
case EQ_EXPR:
/* We can replace A with C1 in this case. */
- arg1 = convert (type, TREE_OPERAND (arg0, 1));
+ arg1 = fold_convert (type, TREE_OPERAND (arg0, 1));
return fold (build (code, type, TREE_OPERAND (t, 0), arg1,
TREE_OPERAND (t, 2)));
/* If the second operand is simpler than the third, swap them
since that produces better jump optimization results. */
- if (tree_swap_operands_p (TREE_OPERAND (t, 1), TREE_OPERAND (t, 2)))
+ if (tree_swap_operands_p (TREE_OPERAND (t, 1),
+ TREE_OPERAND (t, 2), false))
{
/* See if this can be inverted. If it can't, possibly because
it was a floating-point inequality comparison, don't do
if (integer_zerop (TREE_OPERAND (t, 1))
&& integer_onep (TREE_OPERAND (t, 2))
&& truth_value_p (TREE_CODE (arg0)))
- return pedantic_non_lvalue (convert (type,
- invert_truthvalue (arg0)));
+ return pedantic_non_lvalue (fold_convert (type,
+ invert_truthvalue (arg0)));
/* Look for expressions of the form A & 2 ? 2 : 0. The result of this
operation is simply A & 2. */
&& TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
&& operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
arg1, 1))
- return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
+ return pedantic_non_lvalue (fold_convert (type,
+ TREE_OPERAND (arg0, 0)));
/* Convert A ? B : 0 into A && B if A and B are truth values. */
if (integer_zerop (TREE_OPERAND (t, 2))
case COMPOUND_EXPR:
/* When pedantic, a compound expression can be neither an lvalue
nor an integer constant expression. */
- if (TREE_SIDE_EFFECTS (arg0) || pedantic)
+ if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
return t;
/* Don't let (0, 0) be null pointer constant. */
- if (integer_zerop (arg1))
- return build1 (NOP_EXPR, type, arg1);
- return convert (type, arg1);
+ tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
+ : fold_convert (type, arg1);
+ return pedantic_non_lvalue (tem);
case COMPLEX_EXPR:
if (wins)
case IMAGPART_EXPR:
if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
- return convert (type, integer_zero_node);
+ return fold_convert (type, integer_zero_node);
else if (TREE_CODE (arg0) == COMPLEX_EXPR)
return omit_one_operand (type, TREE_OPERAND (arg0, 1),
TREE_OPERAND (arg0, 0));
case WITH_CLEANUP_EXPR: len = 2; break;
default: break;
}
- /* FALLTHROUGH */
+ /* Fall through. */
case 'r':
case '<':
case '1':
if (TYPE_PRECISION (TREE_TYPE (size_one_node))
> TREE_INT_CST_LOW (op1)
&& TREE_INT_CST_HIGH (op1) == 0
- && 0 != (t1 = convert (type,
- const_binop (LSHIFT_EXPR, size_one_node,
- op1, 0)))
+ && 0 != (t1 = fold_convert (type,
+ const_binop (LSHIFT_EXPR,
+ size_one_node,
+ op1, 0)))
&& ! TREE_OVERFLOW (t1))
return multiple_of_p (type, t1, bottom);
}
OSDN Git Service
