From 19353855bfc05914faaee9f297684f608fd9a485 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Thu, 12 Jul 2018 07:08:34 +0000 Subject: [PATCH] tree-ssa-sccvn.c (mprts_hook_cnt): Remove. 2018-07-12 Richard Biener * tree-ssa-sccvn.c (mprts_hook_cnt): Remove. (vn_lookup_simplify_result): Remove recursion limit applied here. (vn_nary_build_or_lookup_1): Adjust. (try_to_simplify): Likewise. * gimple-match-head.c (gimple_resimplify1): Instead apply one here. (gimple_resimplify2): Likewise. (gimple_resimplify3): Likewise. (gimple_resimplify4): Likewise. From-SVN: r262573 --- gcc/ChangeLog | 13 ++++++++++ gcc/gimple-match-head.c | 56 +++++++++++++++++++++++++++++++++++++++++ gcc/tree-ssa-sccvn.c | 10 +------- 3 files changed, 70 insertions(+), 9 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5c86553ce6d..d8a65861e5a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2018-07-12 Richard Biener + + * tree-ssa-sccvn.c (mprts_hook_cnt): Remove. + (vn_lookup_simplify_result): Remove recursion limit applied + here. + (vn_nary_build_or_lookup_1): Adjust. + (try_to_simplify): Likewise. + * gimple-match-head.c (gimple_resimplify1): Instead apply one + here. + (gimple_resimplify2): Likewise. + (gimple_resimplify3): Likewise. + (gimple_resimplify4): Likewise. + 2018-07-11 Jakub Jelinek * config/i386/avx512bitalgintrin.h (_mm512_mask_bitshuffle_epi64_mask): diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c index 1a12bb35e01..c5a19239798 100644 --- a/gcc/gimple-match-head.c +++ b/gcc/gimple-match-head.c @@ -97,13 +97,30 @@ gimple_resimplify1 (gimple_seq *seq, gimple_match_op *res_op, } } + /* Limit recursion, there are cases like PR80887 and others, for + example when value-numbering presents us with unfolded expressions + that we are really not prepared to handle without eventual + oscillation like ((_50 + 0) + 8) where _50 gets mapped to _50 + itself as available expression. */ + static unsigned depth; + if (depth > 10) + { + if (dump_file && (dump_flags & TDF_FOLDING)) + fprintf (dump_file, "Aborting expression simplification due to " + "deep recursion\n"); + return false; + } + + ++depth; gimple_match_op res_op2 (*res_op); if (gimple_simplify (&res_op2, seq, valueize, res_op->code, res_op->type, res_op->ops[0])) { + --depth; *res_op = res_op2; return true; } + --depth; return false; } @@ -151,14 +168,27 @@ gimple_resimplify2 (gimple_seq *seq, gimple_match_op *res_op, canonicalized = true; } + /* Limit recursion, see gimple_resimplify1. */ + static unsigned depth; + if (depth > 10) + { + if (dump_file && (dump_flags & TDF_FOLDING)) + fprintf (dump_file, "Aborting expression simplification due to " + "deep recursion\n"); + return false; + } + + ++depth; gimple_match_op res_op2 (*res_op); if (gimple_simplify (&res_op2, seq, valueize, res_op->code, res_op->type, res_op->ops[0], res_op->ops[1])) { + --depth; *res_op = res_op2; return true; } + --depth; return canonicalized; } @@ -205,14 +235,27 @@ gimple_resimplify3 (gimple_seq *seq, gimple_match_op *res_op, canonicalized = true; } + /* Limit recursion, see gimple_resimplify1. */ + static unsigned depth; + if (depth > 10) + { + if (dump_file && (dump_flags & TDF_FOLDING)) + fprintf (dump_file, "Aborting expression simplification due to " + "deep recursion\n"); + return false; + } + + ++depth; gimple_match_op res_op2 (*res_op); if (gimple_simplify (&res_op2, seq, valueize, res_op->code, res_op->type, res_op->ops[0], res_op->ops[1], res_op->ops[2])) { + --depth; *res_op = res_op2; return true; } + --depth; return canonicalized; } @@ -229,15 +272,28 @@ gimple_resimplify4 (gimple_seq *seq, gimple_match_op *res_op, { /* No constant folding is defined for four-operand functions. */ + /* Limit recursion, see gimple_resimplify1. */ + static unsigned depth; + if (depth > 10) + { + if (dump_file && (dump_flags & TDF_FOLDING)) + fprintf (dump_file, "Aborting expression simplification due to " + "deep recursion\n"); + return false; + } + + ++depth; gimple_match_op res_op2 (*res_op); if (gimple_simplify (&res_op2, seq, valueize, res_op->code, res_op->type, res_op->ops[0], res_op->ops[1], res_op->ops[2], res_op->ops[3])) { + --depth; *res_op = res_op2; return true; } + --depth; return false; } diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 1e16e13cfa1..de3531d4e0b 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -1648,7 +1648,6 @@ vn_reference_lookup_or_insert_for_pieces (tree vuse, } static vn_nary_op_t vn_nary_op_insert_stmt (gimple *stmt, tree result); -static unsigned mprts_hook_cnt; /* Hook for maybe_push_res_to_seq, lookup the expression in the VN tables. */ @@ -1672,13 +1671,8 @@ vn_lookup_simplify_result (gimple_match_op *res_op) vn_nary_op_t vnresult = NULL; tree res = vn_nary_op_lookup_pieces (length, (tree_code) res_op->code, res_op->type, ops, &vnresult); - /* We can end up endlessly recursing simplifications if the lookup above - presents us with a def-use chain that mirrors the original simplification. - See PR80887 for an example. Limit successful lookup artificially - to 10 times if we are called as mprts_hook. */ if (res - && mprts_hook - && --mprts_hook_cnt == 0) + && mprts_hook) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Resetting mprts_hook after too many " @@ -1701,7 +1695,6 @@ vn_nary_build_or_lookup_1 (gimple_match_op *res_op, bool insert) So first simplify and lookup this expression to see if it is already available. */ mprts_hook = vn_lookup_simplify_result; - mprts_hook_cnt = 9; bool res = false; switch (TREE_CODE_LENGTH ((tree_code) res_op->code)) { @@ -4051,7 +4044,6 @@ try_to_simplify (gassign *stmt) /* First try constant folding based on our current lattice. */ mprts_hook = vn_lookup_simplify_result; - mprts_hook_cnt = 9; tem = gimple_fold_stmt_to_constant_1 (stmt, vn_valueize, vn_valueize); mprts_hook = NULL; if (tem -- 2.30.2