From: Roger Sayle Date: Sat, 7 Feb 2004 18:57:35 +0000 (+0000) Subject: re PR middle-end/13696 (enum not useable as array index?) X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=088414c1224f0b20e3bc0c953bebb7273284f48c;p=gcc.git re PR middle-end/13696 (enum not useable as array index?) PR middle-end/13696 * fold-const.c (fold_convert): New function to provide type conversion to the middle-end without using convert. (negate_expr, associate_trees, size_diffop, omit_one_operand, operand_equal_for_comparison_p, pedantic_omit_one_operand, invert_truthvalue, optimize_bit_field_compare, range_binop, decode_field_reference, make_range, build_range_check, unextend, fold_truthop, extract_muldiv_1, fold_mathfn_compare, fold_binary_op_with_conditional_arg, fold_inf_compare, fold_single_bit_test, fold, multiple_of_p): Replace all calls to convert with calls to fold_convert. * g++.dg/opt/fold1.C: New test case. From-SVN: r77464 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 7ac030651c4..aa425183fdf 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2004-02-07 Roger Sayle + + PR middle-end/13696 + * fold-const.c (fold_convert): New function to provide type + conversion to the middle-end without using convert. + (negate_expr, associate_trees, size_diffop, omit_one_operand, + operand_equal_for_comparison_p, pedantic_omit_one_operand, + invert_truthvalue, optimize_bit_field_compare, range_binop, + decode_field_reference, make_range, build_range_check, unextend, + fold_truthop, extract_muldiv_1, fold_mathfn_compare, + fold_binary_op_with_conditional_arg, fold_inf_compare, + fold_single_bit_test, fold, multiple_of_p): Replace all calls to + convert with calls to fold_convert. + 2004-02-07 Jan Hubicka * genrecog.c (find_operand): add extra argument stop. diff --git a/gcc/fold-const.c b/gcc/fold-const.c index b93665c94d0..b51a510f05c 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -70,6 +70,7 @@ 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 int comparison_to_compcode (enum tree_code); @@ -971,7 +972,7 @@ negate_expr (tree t) 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) || ! flag_trapping_math) - return convert (type, tem); + return fold_convert (type, tem); break; case COMPLEX_CST: @@ -988,7 +989,7 @@ negate_expr (tree t) 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) @@ -997,16 +998,16 @@ negate_expr (tree t) if (negate_expr_p (TREE_OPERAND (t, 1)) && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1))) - return convert (type, - fold (build (MINUS_EXPR, TREE_TYPE (t), - negate_expr (TREE_OPERAND (t, 1)), - TREE_OPERAND (t, 0)))); + 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 convert (type, - fold (build (MINUS_EXPR, TREE_TYPE (t), - negate_expr (TREE_OPERAND (t, 0)), - TREE_OPERAND (t, 1)))); + return fold_convert (type, + fold (build (MINUS_EXPR, TREE_TYPE (t), + negate_expr (TREE_OPERAND (t, 0)), + TREE_OPERAND (t, 1)))); } break; @@ -1014,10 +1015,10 @@ negate_expr (tree t) /* - (A - B) -> B - A */ if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations) && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1))) - return convert (type, - fold (build (MINUS_EXPR, TREE_TYPE (t), - TREE_OPERAND (t, 1), - TREE_OPERAND (t, 0)))); + return fold_convert (type, + fold (build (MINUS_EXPR, TREE_TYPE (t), + TREE_OPERAND (t, 1), + TREE_OPERAND (t, 0)))); break; case MULT_EXPR: @@ -1031,16 +1032,16 @@ negate_expr (tree t) { 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; @@ -1050,7 +1051,7 @@ negate_expr (tree t) { tem = strip_float_extensions (t); if (tem != t && negate_expr_p (tem)) - return convert (type, negate_expr (tem)); + return fold_convert (type, negate_expr (tem)); } break; @@ -1072,7 +1073,8 @@ negate_expr (tree t) 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); } /* Split a tree IN into a constant, literal and variable parts that could be @@ -1191,16 +1193,18 @@ associate_trees (tree t1, tree t2, enum tree_code code, tree type) 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))); } /* Combine two integer constants ARG1 and ARG2 under operation CODE @@ -1670,20 +1674,21 @@ size_diffop (tree arg0, tree arg1) 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))); } @@ -1848,6 +1853,115 @@ fold_convert_const (enum tree_code code, tree type, tree arg1) } 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 (); +} /* Return an expr equal to X but certainly not valid as an lvalue. */ @@ -2277,10 +2391,10 @@ operand_equal_for_comparison_p (tree arg0, tree arg1, tree other) /* 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; } @@ -2476,7 +2590,7 @@ eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1) 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); @@ -2489,7 +2603,7 @@ omit_one_operand (tree type, tree result, tree omitted) 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); @@ -2529,7 +2643,7 @@ invert_truthvalue (tree arg) 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, @@ -2594,7 +2708,8 @@ invert_truthvalue (tree arg) 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); @@ -2768,7 +2883,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type, 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); @@ -2798,27 +2913,27 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type, 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)); } } @@ -2826,7 +2941,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type, 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 @@ -2841,7 +2956,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type, 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)); @@ -2935,7 +3050,7 @@ decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize, /* 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; @@ -3101,7 +3216,7 @@ range_binop (enum tree_code code, tree type, tree arg0, int upper0_p, 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; } @@ -3141,7 +3256,7 @@ range_binop (enum tree_code code, tree type, tree arg0, int upper0_p, abort (); } - return convert (type, result ? integer_one_node : integer_zero_node); + return fold_convert (type, result ? integer_one_node : integer_zero_node); } /* Given EXP, a logical expression, set the range it is testing into @@ -3165,7 +3280,8 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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) { @@ -3242,7 +3358,7 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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; @@ -3256,7 +3372,7 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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; @@ -3264,9 +3380,11 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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; @@ -3274,7 +3392,7 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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: @@ -3330,10 +3448,10 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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 @@ -3356,8 +3474,10 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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 @@ -3365,8 +3485,8 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) 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; @@ -3377,8 +3497,8 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh) /* 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; @@ -3427,7 +3547,7 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree high) 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)); @@ -3443,8 +3563,8 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree 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); } @@ -3473,10 +3593,10 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree 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))); } } @@ -3484,7 +3604,8 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree high) && ! 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; } @@ -3724,17 +3845,18 @@ unextend (tree c, int p, int unsignedp, tree mask) 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)); } /* Find ways of folding logical expressions of LHS and RHS: @@ -3852,9 +3974,9 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree 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); @@ -3994,14 +4116,14 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) 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, @@ -4011,14 +4133,14 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) { 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, @@ -4028,9 +4150,9 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) { 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); } } @@ -4065,9 +4187,9 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) 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. @@ -4122,14 +4244,14 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) { 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; } } @@ -4158,12 +4280,12 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs) 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); } } @@ -4348,7 +4470,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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: @@ -4378,7 +4501,7 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) /* 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, @@ -4389,7 +4512,7 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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: @@ -4405,8 +4528,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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; @@ -4425,13 +4548,14 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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; @@ -4448,8 +4572,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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. */ @@ -4478,8 +4602,8 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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); + 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)) @@ -4499,15 +4623,16 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) /* 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; @@ -4530,22 +4655,22 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) 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 @@ -4564,15 +4689,15 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type) && 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; @@ -4739,8 +4864,8 @@ fold_binary_op_with_conditional_arg (enum tree_code code, tree type, { 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 @@ -4793,10 +4918,10 @@ fold_binary_op_with_conditional_arg (enum tree_code code, tree type, 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); } @@ -4868,14 +4993,14 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code, /* 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. */ @@ -4899,7 +5024,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code, /* 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); } @@ -4920,7 +5045,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code, 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 @@ -5006,14 +5131,14 @@ fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1) 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). */ @@ -5100,8 +5225,8 @@ fold_single_bit_test (enum tree_code code, tree arg0, tree arg1, { 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. */ @@ -5137,7 +5262,7 @@ fold_single_bit_test (enum tree_code code, tree arg0, tree arg1, 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 = convert (intermediate_type, inner); + inner = fold_convert (intermediate_type, inner); if (bitnum != 0) inner = build (RSHIFT_EXPR, intermediate_type, @@ -5152,7 +5277,7 @@ fold_single_bit_test (enum tree_code code, tree arg0, tree arg1, inner, integer_one_node); /* Make sure to return the proper type. */ - inner = convert (result_type, inner); + inner = fold_convert (result_type, inner); return inner; } @@ -5516,7 +5641,8 @@ fold (tree expr) 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_convert (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 @@ -5531,14 +5657,16 @@ fold (tree expr) && ! (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_convert (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_convert (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 @@ -5562,7 +5690,8 @@ fold (tree expr) && ! (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_convert (final_type, + TREE_OPERAND (TREE_OPERAND (t, 0), 0)); } if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR @@ -5615,15 +5744,15 @@ fold (tree 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))); } tem = fold_convert_const (code, TREE_TYPE (t), arg0); @@ -5704,8 +5833,9 @@ fold (tree 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; @@ -5713,7 +5843,7 @@ fold (tree expr) 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), @@ -5755,7 +5885,7 @@ fold (tree expr) 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, @@ -5796,16 +5926,16 @@ fold (tree expr) && 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) @@ -5873,11 +6003,11 @@ fold (tree 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) @@ -6070,19 +6200,22 @@ fold (tree expr) 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)); } } @@ -6094,7 +6227,7 @@ fold (tree expr) /* 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; } @@ -6116,9 +6249,9 @@ fold (tree expr) 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)); + return non_lvalue (fold_convert (type, arg0)); /* Fold A - (A & B) into ~B & A. */ if (!TREE_SIDE_EFFECTS (arg0) @@ -6158,13 +6291,13 @@ fold (tree expr) /* 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. @@ -6174,7 +6307,7 @@ fold (tree expr) 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) @@ -6222,7 +6355,7 @@ fold (tree expr) 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 @@ -6236,9 +6369,9 @@ fold (tree 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 @@ -6254,7 +6387,7 @@ fold (tree expr) /* 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))) @@ -6475,7 +6608,7 @@ fold (tree expr) 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; @@ -6501,7 +6634,7 @@ fold (tree expr) 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)); @@ -6527,7 +6660,7 @@ fold (tree expr) 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); @@ -6543,7 +6676,7 @@ fold (tree expr) 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))). @@ -6584,12 +6717,12 @@ fold (tree expr) /* 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, @@ -6771,7 +6904,7 @@ fold (tree expr) 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; @@ -6788,7 +6921,7 @@ fold (tree expr) 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; @@ -6804,7 +6937,7 @@ fold (tree expr) 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; @@ -6823,7 +6956,7 @@ fold (tree expr) 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); @@ -6836,7 +6969,7 @@ fold (tree expr) 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)); } @@ -6900,7 +7033,7 @@ fold (tree expr) 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 @@ -6908,15 +7041,15 @@ fold (tree expr) ("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)) @@ -6996,15 +7129,15 @@ fold (tree expr) ("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)) @@ -7018,14 +7151,14 @@ fold (tree expr) 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: @@ -7049,8 +7182,8 @@ fold (tree expr) /* 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 @@ -7082,7 +7215,7 @@ fold (tree 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. */ @@ -7210,8 +7343,8 @@ fold (tree expr) 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, @@ -7271,8 +7404,8 @@ fold (tree expr) 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, @@ -7338,14 +7471,16 @@ fold (tree expr) { 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)); @@ -7375,14 +7510,16 @@ fold (tree expr) { 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)); @@ -7419,8 +7556,8 @@ fold (tree expr) 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))); } } } @@ -7466,7 +7603,8 @@ fold (tree expr) && (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. */ @@ -7509,8 +7647,8 @@ fold (tree expr) 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))) @@ -7521,8 +7659,8 @@ fold (tree expr) 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)); } @@ -7540,10 +7678,12 @@ fold (tree expr) { 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 @@ -7551,7 +7691,7 @@ fold (tree expr) 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. */ @@ -7610,7 +7750,7 @@ fold (tree 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)) @@ -7620,10 +7760,11 @@ fold (tree expr) && 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.) */ @@ -7974,32 +8115,26 @@ fold (tree expr) 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 (); } @@ -8012,9 +8147,9 @@ fold (tree expr) 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. @@ -8061,9 +8196,9 @@ fold (tree expr) 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 @@ -8071,22 +8206,22 @@ fold (tree expr) 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 (); @@ -8106,7 +8241,7 @@ fold (tree expr) { 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))); @@ -8186,8 +8321,8 @@ fold (tree expr) 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. */ @@ -8199,7 +8334,8 @@ fold (tree expr) && 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)) @@ -8228,9 +8364,9 @@ fold (tree expr) if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1)) return t; /* Don't let (0, 0) be null pointer constant. */ - if (integer_zerop (arg1)) - return pedantic_non_lvalue (build1 (NOP_EXPR, type, arg1)); - return pedantic_non_lvalue (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) @@ -8255,7 +8391,7 @@ fold (tree expr) 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)); @@ -8617,9 +8753,10 @@ multiple_of_p (tree type, tree top, tree bottom) 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); } diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d64a333bb18..20a9683a0f3 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2004-02-07 Roger Sayle + + PR middle-end/13696 + * g++.dg/opt/fold1.C: New test case. + 2003-02-06 Giovanni Bajo PR c++/14033 diff --git a/gcc/testsuite/g++.dg/opt/fold1.C b/gcc/testsuite/g++.dg/opt/fold1.C new file mode 100644 index 00000000000..98f1b519115 --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/fold1.C @@ -0,0 +1,17 @@ +// PR middle-end/13696 +// { dg-do compile } +// { dg-options "-O2" } + +extern void x(unsigned long*); + +enum e { red, blue, green }; + +struct s { + unsigned long l; +}; +struct s map[1][256]; + +void +f(int i,e j) { + x(&(map[i][j].l)); +}