[backport gcc-4.8/trunk r193882, depends on PR48814 backport ] gcc/ 2012-11-28 Richard Biener PR c/35634 * gimple.h (gimplify_self_mod_expr): Declare. * gimplify.c (gimplify_self_mod_expr): Export. Take a different type for performing the arithmetic in. (gimplify_expr): Adjust. * tree-vect-loop-manip.c (vect_can_advance_ivs_p): Strip sign conversions we can re-apply after adjusting the IV. gcc/c-family/ 2012-11-28 Richard Biener PR c/35634 * c-gimplify.c (c_gimplify_expr): Gimplify self-modify expressions here and use a type with proper overflow behavior for types that would need to be promoted for the arithmetic. gcc/testsuite/ 2012-11-28 Richard Biener PR c/35634 * gcc.dg/torture/pr35634.c: New testcase. * g++.dg/torture/pr35634.C: Likewise. * gcc.dg/vect/pr18536.c: Mark worker function noinline. --- gcc-4.7.2/gcc/c-family/c-gimplify.c.~1~ 2011-04-12 11:27:18.000000000 +0200 +++ gcc-4.7.2/gcc/c-family/c-gimplify.c 2012-12-02 17:46:43.000000000 +0100 @@ -173,16 +173,37 @@ c_gimplify_expr (tree *expr_p, gimple_se { enum tree_code code = TREE_CODE (*expr_p); - /* This is handled mostly by gimplify.c, but we have to deal with - not warning about int x = x; as it is a GCC extension to turn off - this warning but only if warn_init_self is zero. */ - if (code == DECL_EXPR - && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL - && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) - && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) - && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) - && !warn_init_self) - TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; + switch (code) + { + case DECL_EXPR: + /* This is handled mostly by gimplify.c, but we have to deal with + not warning about int x = x; as it is a GCC extension to turn off + this warning but only if warn_init_self is zero. */ + if (TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL + && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p)) + && !TREE_STATIC (DECL_EXPR_DECL (*expr_p)) + && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p)) + && !warn_init_self) + TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1; + break; + + case PREINCREMENT_EXPR: + case PREDECREMENT_EXPR: + case POSTINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + { + tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 0)); + if (INTEGRAL_TYPE_P (type) && c_promoting_integer_type_p (type)) + { + if (TYPE_OVERFLOW_UNDEFINED (type)) + type = unsigned_type_for (type); + return gimplify_self_mod_expr (expr_p, pre_p, post_p, 1, type); + } + break; + } + + default:; + } return GS_UNHANDLED; } --- gcc-4.7.2/gcc/gimple.h.~1~ 2012-08-06 16:34:27.000000000 +0200 +++ gcc-4.7.2/gcc/gimple.h 2012-12-02 17:46:43.000000000 +0100 @@ -1091,6 +1091,8 @@ extern enum gimplify_status gimplify_exp bool (*) (tree), fallback_t); extern void gimplify_type_sizes (tree, gimple_seq *); extern void gimplify_one_sizepos (tree *, gimple_seq *); +enum gimplify_status gimplify_self_mod_expr (tree *, gimple_seq *, gimple_seq *, + bool, tree); extern bool gimplify_stmt (tree *, gimple_seq *); extern gimple gimplify_body (tree, bool); extern void push_gimplify_context (struct gimplify_ctx *); --- gcc-4.7.2/gcc/gimplify.c.~1~ 2012-12-02 17:45:28.000000000 +0100 +++ gcc-4.7.2/gcc/gimplify.c 2012-12-02 17:46:43.000000000 +0100 @@ -2198,11 +2198,13 @@ gimplify_compound_lval (tree *expr_p, gi *EXPR_P should be stored. WANT_VALUE is nonzero iff we want to use the value of this expression - in another expression. */ + in another expression. -static enum gimplify_status + ARITH_TYPE is the type the computation should be performed in. */ + +enum gimplify_status gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, - bool want_value) + bool want_value, tree arith_type) { enum tree_code code; tree lhs, lvalue, rhs, t1; @@ -2263,27 +2265,32 @@ gimplify_self_mod_expr (tree *expr_p, gi return ret; } + if (postfix) + lhs = get_initialized_tmp_var (lhs, pre_p, NULL); + /* For POINTERs increment, use POINTER_PLUS_EXPR. */ if (POINTER_TYPE_P (TREE_TYPE (lhs))) { rhs = convert_to_ptrofftype_loc (loc, rhs); if (arith_code == MINUS_EXPR) rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs); - arith_code = POINTER_PLUS_EXPR; + t1 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (*expr_p), lhs, rhs); } + else + t1 = fold_convert (TREE_TYPE (*expr_p), + fold_build2 (arith_code, arith_type, + fold_convert (arith_type, lhs), + fold_convert (arith_type, rhs))); if (postfix) { - tree t2 = get_initialized_tmp_var (lhs, pre_p, NULL); - t1 = build2 (arith_code, TREE_TYPE (*expr_p), t2, rhs); gimplify_assign (lvalue, t1, pre_p); gimplify_seq_add_seq (orig_post_p, post); - *expr_p = t2; + *expr_p = lhs; return GS_ALL_DONE; } else { - t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs); *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1); return GS_OK; } @@ -6888,7 +6895,8 @@ gimplify_expr (tree *expr_p, gimple_seq case PREINCREMENT_EXPR: case PREDECREMENT_EXPR: ret = gimplify_self_mod_expr (expr_p, pre_p, post_p, - fallback != fb_none); + fallback != fb_none, + TREE_TYPE (*expr_p)); break; case ARRAY_REF: --- gcc-4.7.2/gcc/testsuite/g++.dg/torture/pr35634.C.~1~ 1970-01-01 01:00:00.000000000 +0100 +++ gcc-4.7.2/gcc/testsuite/g++.dg/torture/pr35634.C 2012-12-02 17:46:43.000000000 +0100 @@ -0,0 +1,19 @@ +/* { dg-do run } */ + +extern "C" void abort (void); +extern "C" void exit (int); + +void foo (int i) +{ + static int n; + if (i < -128 || i > 127) + abort (); + if (++n > 1000) + exit (0); +} + +int main () +{ + char c; + for (c = 0; ; c++) foo (c); +} --- gcc-4.7.2/gcc/testsuite/gcc.dg/torture/pr35634.c.~1~ 1970-01-01 01:00:00.000000000 +0100 +++ gcc-4.7.2/gcc/testsuite/gcc.dg/torture/pr35634.c 2012-12-02 17:46:43.000000000 +0100 @@ -0,0 +1,19 @@ +/* { dg-do run } */ + +void abort (void); +void exit (int); + +void foo (int i) +{ + static int n; + if (i < -128 || i > 127) + abort (); + if (++n > 1000) + exit (0); +} + +int main () +{ + char c; + for (c = 0; ; c++) foo (c); +} --- gcc-4.7.2/gcc/testsuite/gcc.dg/vect/pr18536.c.~1~ 2005-03-31 20:34:19.000000000 +0200 +++ gcc-4.7.2/gcc/testsuite/gcc.dg/vect/pr18536.c 2012-12-02 17:46:43.000000000 +0100 @@ -5,7 +5,7 @@ #define N 16 -int main1 (short a, short *b) +__attribute__ ((noinline)) int main1 (short a, short *b) { while (++a < 4) *b++ = 2; --- gcc-4.7.2/gcc/tree-vect-loop-manip.c.~1~ 2012-08-10 15:21:31.000000000 +0200 +++ gcc-4.7.2/gcc/tree-vect-loop-manip.c 2012-12-02 17:50:22.000000000 +0100 @@ -1711,6 +1711,7 @@ vect_can_advance_ivs_p (loop_vec_info lo return false; } + STRIP_NOPS (access_fn); if (vect_print_dump_info (REPORT_DETAILS)) { fprintf (vect_dump, "Access function of PHI: ");