From 12c4f7dcafc3fb469e995d283dccbb4a5945f11c Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 17 Mar 2017 12:48:56 +0000 Subject: [PATCH] =?utf8?q?re=20PR=20c++/80075=20(ICE:=20"statement=20marke?= =?utf8?q?d=20for=20throw,=20but=20doesn=E2=80=99t"=20with=20-fnon-call-ex?= =?utf8?q?ceptions)?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit 2017-03-17 Richard Biener PR middle-end/80075 * tree-eh.c (stmt_could_throw_1_p): Only handle gimple assigns. Properly verify the LHS before the RHS possibly claims to be handled. (stmt_could_throw_p): Hande gimple conds fully here. Clobbers do not throw. * g++.dg/torture/pr80075.C: New testcase. From-SVN: r246223 --- gcc/ChangeLog | 9 +++++++++ gcc/testsuite/ChangeLog | 5 +++++ gcc/testsuite/g++.dg/torture/pr80075.C | 27 +++++++++++++++++++++++++ gcc/tree-eh.c | 36 ++++++++++++++++++++++------------ 4 files changed, 65 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/g++.dg/torture/pr80075.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 76da3f1..9af5815 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,12 @@ +2017-03-17 Richard Biener + + PR middle-end/80075 + * tree-eh.c (stmt_could_throw_1_p): Only handle gimple assigns. + Properly verify the LHS before the RHS possibly claims to be + handled. + (stmt_could_throw_p): Hande gimple conds fully here. Clobbers + do not throw. + 2017-03-17 Martin Jambor * doc/invoke.texi (Option Options): Include -fipa-vrp in the list. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 72c74df..144030e 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2017-03-17 Richard Biener + + PR middle-end/80075 + * g++.dg/torture/pr80075.C: New testcase. + 2017-03-16 Michael Meissner PR target/71294 diff --git a/gcc/testsuite/g++.dg/torture/pr80075.C b/gcc/testsuite/g++.dg/torture/pr80075.C new file mode 100644 index 0000000..5bc8020 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr80075.C @@ -0,0 +1,27 @@ +// { dg-do compile } +// { dg-additional-options "-fnon-call-exceptions" } + +struct s { + int i; +}; + +extern int use_memcpy; +extern void my_memcpy(void*, void*, int); + +int +f (struct s* p) +{ + struct s a; + + try + { + a = (struct s){}; + if (!use_memcpy) + *p = a; + else + my_memcpy (p, &a, sizeof (struct s)); + } catch (...) { + return 0; + } + return 1; +} diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index 0b785e9..fc016d7 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -2726,9 +2726,9 @@ tree_could_trap_p (tree expr) an assignment or a conditional) may throw. */ static bool -stmt_could_throw_1_p (gimple *stmt) +stmt_could_throw_1_p (gassign *stmt) { - enum tree_code code = gimple_expr_code (stmt); + enum tree_code code = gimple_assign_rhs_code (stmt); bool honor_nans = false; bool honor_snans = false; bool fp_operation = false; @@ -2742,11 +2742,8 @@ stmt_could_throw_1_p (gimple *stmt) || TREE_CODE_CLASS (code) == tcc_binary || code == FMA_EXPR) { - if (is_gimple_assign (stmt) - && TREE_CODE_CLASS (code) == tcc_comparison) + if (TREE_CODE_CLASS (code) == tcc_comparison) t = TREE_TYPE (gimple_assign_rhs1 (stmt)); - else if (gimple_code (stmt) == GIMPLE_COND) - t = TREE_TYPE (gimple_cond_lhs (stmt)); else t = gimple_expr_type (stmt); fp_operation = FLOAT_TYPE_P (t); @@ -2759,17 +2756,21 @@ stmt_could_throw_1_p (gimple *stmt) honor_trapv = true; } + /* First check the LHS. */ + if (tree_could_trap_p (gimple_assign_lhs (stmt))) + return true; + /* Check if the main expression may trap. */ - t = is_gimple_assign (stmt) ? gimple_assign_rhs2 (stmt) : NULL; ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv, - honor_nans, honor_snans, t, + honor_nans, honor_snans, + gimple_assign_rhs2 (stmt), &handled); if (handled) return ret; /* If the expression does not trap, see if any of the individual operands may trap. */ - for (i = 0; i < gimple_num_ops (stmt); i++) + for (i = 1; i < gimple_num_ops (stmt); i++) if (tree_could_trap_p (gimple_op (stmt, i))) return true; @@ -2795,11 +2796,22 @@ stmt_could_throw_p (gimple *stmt) case GIMPLE_CALL: return !gimple_call_nothrow_p (as_a (stmt)); - case GIMPLE_ASSIGN: case GIMPLE_COND: - if (!cfun->can_throw_non_call_exceptions) + { + if (!cfun->can_throw_non_call_exceptions) + return false; + gcond *cond = as_a (stmt); + tree lhs = gimple_cond_lhs (cond); + return operation_could_trap_p (gimple_cond_code (cond), + FLOAT_TYPE_P (TREE_TYPE (lhs)), + false, NULL_TREE); + } + + case GIMPLE_ASSIGN: + if (!cfun->can_throw_non_call_exceptions + || gimple_clobber_p (stmt)) return false; - return stmt_could_throw_1_p (stmt); + return stmt_could_throw_1_p (as_a (stmt)); case GIMPLE_ASM: if (!cfun->can_throw_non_call_exceptions) -- 2.7.4