From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2140) id DA3FF3858412; Sat, 4 Dec 2021 06:12:19 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DA3FF3858412 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Alexandre Oliva To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/aoliva/heads/testme)] [PR103024, PR103530] support throwing compares and non-boolean types X-Act-Checkin: gcc X-Git-Author: Alexandre Oliva X-Git-Refname: refs/users/aoliva/heads/testme X-Git-Oldrev: daca416fc2816a5e481b26c8d2010127101d77ce X-Git-Newrev: 623fabc300ffadb03defb49bfec0ca5d48356508 Message-Id: <20211204061219.DA3FF3858412@sourceware.org> Date: Sat, 4 Dec 2021 06:12:19 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 04 Dec 2021 06:12:20 -0000 https://gcc.gnu.org/g:623fabc300ffadb03defb49bfec0ca5d48356508 commit 623fabc300ffadb03defb49bfec0ca5d48356508 Author: Alexandre Oliva Date: Sat Dec 4 03:06:00 2021 -0300 [PR103024,PR103530] support throwing compares and non-boolean types Diff: --- gcc/gimple-harden-conditionals.cc | 74 ++++++++++++++++++++++++++++++++++++--- gcc/testsuite/g++.dg/pr103024.C | 12 +++++++ gcc/testsuite/g++.dg/pr103530.C | 27 ++++++++++++++ 3 files changed, 109 insertions(+), 4 deletions(-) diff --git a/gcc/gimple-harden-conditionals.cc b/gcc/gimple-harden-conditionals.cc index cfa2361d65b..ee332f9e8db 100644 --- a/gcc/gimple-harden-conditionals.cc +++ b/gcc/gimple-harden-conditionals.cc @@ -33,6 +33,7 @@ along with GCC; see the file COPYING3. If not see #include "basic-block.h" #include "cfghooks.h" #include "cfgloop.h" +#include "tree-eh.h" #include "diagnostic.h" #include "intl.h" @@ -304,6 +305,24 @@ make_pass_harden_conditional_branches (gcc::context *ctxt) return new pass_harden_conditional_branches (ctxt); } +/* Return the fallthru edge of a block whose other edge is an EH + edge. */ +static inline edge +non_eh_succ_edge (basic_block bb) +{ + gcc_checking_assert (EDGE_COUNT (bb->succs) == 2); + + edge ret = find_fallthru_edge (bb->succs); + + int eh_idx = EDGE_SUCC (bb, 0) == ret; + edge eh = EDGE_SUCC (bb, eh_idx); + + gcc_checking_assert (!(ret->flags & EDGE_EH) + && (eh->flags & EDGE_EH)); + + return ret; +} + /* Harden boolean-yielding compares in FUN. */ unsigned int @@ -394,7 +413,11 @@ pass_harden_compares::execute (function *fun) if (VECTOR_TYPE_P (TREE_TYPE (op1))) continue; - gcc_checking_assert (TREE_CODE (TREE_TYPE (lhs)) == BOOLEAN_TYPE); + /* useless_type_conversion_p enables conversions from 1-bit + integer types to boolean to be discarded. */ + gcc_checking_assert (TREE_CODE (TREE_TYPE (lhs)) == BOOLEAN_TYPE + || (INTEGRAL_TYPE_P (TREE_TYPE (lhs)) + && TYPE_PRECISION (TREE_TYPE (lhs)) == 1)); tree rhs = copy_ssa_name (lhs); @@ -405,6 +428,20 @@ pass_harden_compares::execute (function *fun) won't be debug stmts only. */ gsi_next_nondebug (&gsi_split); + bool throwing_compare_p = stmt_ends_bb_p (asgn); + if (throwing_compare_p) + { + basic_block nbb = split_edge (non_eh_succ_edge + (gimple_bb (asgn))); + gsi_split = gsi_start_bb (nbb); + + if (dump_file) + fprintf (dump_file, + "Splitting non-EH edge from block %i into %i" + " after a throwing compare\n", + gimple_bb (asgn)->index, nbb->index); + } + bool same_p = (op1 == op2); op1 = detach_value (loc, &gsi_split, op1); op2 = same_p ? op1 : detach_value (loc, &gsi_split, op2); @@ -418,17 +455,46 @@ pass_harden_compares::execute (function *fun) if (!gsi_end_p (gsi_split)) { gsi_prev (&gsi_split); - split_block (bb, gsi_stmt (gsi_split)); + basic_block obb = gsi_bb (gsi_split); + basic_block nbb = split_block (obb, gsi_stmt (gsi_split))->dest; gsi_next (&gsi_split); gcc_checking_assert (gsi_end_p (gsi_split)); single_succ_edge (bb)->goto_locus = loc; if (dump_file) - fprintf (dump_file, "Splitting block %i\n", bb->index); + fprintf (dump_file, + "Splitting block %i into %i" + " before the conditional trap branch\n", + obb->index, nbb->index); + } + + /* If the check assignment must end a basic block, we can't + insert the conditional branch in the same block, so split + the block again, and prepare to insert the conditional + branch in the new block. + + Also assign an EH region to the compare. Even though it's + unlikely that the hardening compare will throw after the + original compare didn't, the compiler won't even know that + it's the same compare operands, so add the EH edge anyway. */ + if (throwing_compare_p) + { + add_stmt_to_eh_lp (asgnck, lookup_stmt_eh_lp (asgn)); + make_eh_edges (asgnck); + + basic_block nbb = split_edge (non_eh_succ_edge + (gimple_bb (asgnck))); + gsi_split = gsi_start_bb (nbb); + + if (dump_file) + fprintf (dump_file, + "Splitting non-EH edge from block %i into %i after" + " the newly-inserted reversed throwing compare\n", + gimple_bb (asgnck)->index, nbb->index); } - gcc_checking_assert (single_succ_p (bb)); + gcc_checking_assert (single_succ_p (gsi_bb (gsi_split))); insert_check_and_trap (loc, &gsi_split, EDGE_TRUE_VALUE, EQ_EXPR, lhs, rhs); diff --git a/gcc/testsuite/g++.dg/pr103024.C b/gcc/testsuite/g++.dg/pr103024.C new file mode 100644 index 00000000000..15e68d40213 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr103024.C @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-fnon-call-exceptions -fharden-compares -fsignaling-nans" } */ + +struct G4ErrorMatrix { + G4ErrorMatrix(int); + ~G4ErrorMatrix(); +}; +double PropagateError_charge; +void PropagateError() { + G4ErrorMatrix transf(0); + int field(PropagateError_charge && field); +} diff --git a/gcc/testsuite/g++.dg/pr103530.C b/gcc/testsuite/g++.dg/pr103530.C new file mode 100644 index 00000000000..726b0eb3427 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr103530.C @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fharden-compares" } */ + +enum E:bool +{ E0, E1 }; + +int x; + +E +baz (E rtt) +{ + return rtt == E0 ? E1 : E0; +} + +bool bar (); + +void +foo (E) +{ + E a = x ? E1 : E0; + if (bar ()) + if (bar ()) + { + E b = baz (a); + foo (b); + } +}