From patchwork Sat Oct 20 19:56:41 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martin Jambor X-Patchwork-Id: 987233 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-487956-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=suse.cz Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="CAlLuTJL"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 42ctpx1Fssz9sC2 for ; Sun, 21 Oct 2018 06:57:11 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:mime-version:content-type; q=dns; s=default; b=l7UqTxp/Z4HQZNv0+qq1A/4qi7Q7Re2jcs3IOD3cY3RpLl6FAM c18vGZID/HG1Xvb6Jmh9YHMm52cKJDD22CNo5uDHeLbRWUaBuIK4dAYXiK/Jlc6t h7lBEIMjDSMic2LwLbTL9HlfJPQKiG9gNv2ixV2ySdrJEan3cpYRlNwPw= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:mime-version:content-type; s= default; bh=ynssxtg0Cp7hMpyY9BMFAdskCTA=; b=CAlLuTJLOd4W3p3zQ8kM tKuPnWT+pi2DdDf9hK434Vbc/0igEekAMINZsNkQuywdYgQRon2BA5T77qsQhlKO 5/B2WVa6TFOAtUoJhdKOLfUXnmi8GCaPUsNJXzmKSTDEX6SsGWGkZ65s5GtyJTNp 23fXWIMQssLfvjDaTyerdiY= Received: (qmail 92302 invoked by alias); 20 Oct 2018 19:57:02 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 92285 invoked by uid 89); 20 Oct 2018 19:57:02 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy=safely, H*Ad:D*cz, simpler, sk:lookup_ X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 20 Oct 2018 19:56:57 +0000 Received: from relay1.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id F298AAE77 for ; Sat, 20 Oct 2018 19:56:54 +0000 (UTC) From: Martin Jambor To: GCC Patches Cc: Richard Biener , Jan Hubicka Subject: [PATCH] Add a fun parameter to three stmt_could_throw... functions User-Agent: Notmuch/0.26 (https://notmuchmail.org) Emacs/26.1 (x86_64-suse-linux-gnu) Date: Sat, 20 Oct 2018 21:56:41 +0200 Message-ID: MIME-Version: 1.0 X-IsSubscribed: yes Hi, This long patch only does one simple thing, adds an explicit function parameter to predicates stmt_could_throw_p, stmt_can_throw_external and stmt_can_throw_internal. My motivation was ability to use stmt_can_throw_external in IPA analysis phase without the need to push cfun. As I have discovered, we were already doing that in cgraph.c, which this patch avoids as well. In the process, I had to add a struct function parameter to stmt_could_throw_p and decided to also change the interface of stmt_can_throw_internal just for the sake of some minimal consistency. In the process I have discovered that calling method cgraph_node::create_version_clone_with_body (used by ipa-split, ipa-sra, OMP simd and multiple_target) leads to calls of stmt_can_throw_external with NULL cfun. I have worked around this by making stmt_can_throw_external and stmt_could_throw_p gracefully accept NULL and just be pessimistic in that case. The problem with fixing this in a better way is that struct function for the clone is created after cloning edges where we attempt to push the yet not existing cfun, and moving it before would require a bit of surgery in tree-inline.c. A slightly hackish but simpler fix might be to explicitely pass the "old" function to symbol_table::create_edge because it should be just as good at that moment. In any event, that is a topic for another patch. I believe that currently we incorrectly implicitly use cfun in maybe_clean_eh_stmt_fn and maybe_duplicate_eh_stmt_fn, both in tree-eh.c, and so I have fixed these cases too. The bulk of other changes is just mechanical adding of cfun to all users. Bootstrapped and tested on x86_64-linux (also with extra NULLing and restoring cfun to double check it is not used in a place I missed), OK for trunk? Thanks, Martin 2018-10-20 Martin Jambor * tree-eh.h (stmt_could_throw_p): Add function parameter. (stmt_can_throw_external): Likewise. (stmt_can_throw_internal): Likewise. * tree-eh.c (lower_eh_constructs_2): Pass cfun to stmt_could_throw_p. (lower_eh_constructs_2): Likewise. (stmt_could_throw_p): Add fun parameter, use it instead of cfun. (stmt_can_throw_external): Likewise. (stmt_can_throw_internal): Likewise. (maybe_clean_eh_stmt_fn): Pass cfun to stmt_could_throw_p. (maybe_clean_or_replace_eh_stmt): Pass cfun to stmt_could_throw_p. (maybe_duplicate_eh_stmt_fn): Pass new_fun to stmt_could_throw_p. (maybe_duplicate_eh_stmt): Pass cfun to stmt_could_throw_p. (pass_lower_eh_dispatch::execute): Pass cfun to stmt_can_throw_external. (cleanup_empty_eh): Likewise. (verify_eh_edges): Pass cfun to stmt_could_throw_p. * cgraph.c (cgraph_edge::set_call_stmt): Pass a function to stmt_can_throw_external instead of pushing it to cfun. (symbol_table::create_edge): Likewise. * gimple-fold.c (fold_builtin_atomic_compare_exchange): Pass cfun to stmt_can_throw_internal. * gimple-ssa-evrp.c (evrp_dom_walker::before_dom_children): Pass cfun to stmt_could_throw_p. * gimple-ssa-store-merging.c (handled_load): Pass cfun to stmt_can_throw_internal. (pass_store_merging::execute): Likewise. * gimple-ssa-strength-reduction.c (find_candidates_dom_walker::before_dom_children): Pass cfun to stmt_could_throw_p. * gimplify-me.c (gimple_regimplify_operands): Pass cfun to stmt_can_throw_internal. * ipa-pure-const.c (check_call): Pass cfun to stmt_could_throw_p and to stmt_can_throw_external. (check_stmt): Pass cfun to stmt_could_throw_p. (check_stmt): Pass cfun to stmt_can_throw_external. (pass_nothrow::execute): Likewise. * trans-mem.c (expand_call_tm): Pass cfun to stmt_can_throw_internal. * tree-cfg.c (is_ctrl_altering_stmt): Pass cfun to stmt_can_throw_internal. (verify_gimple_in_cfg): Pass cfun to stmt_could_throw_p. (stmt_can_terminate_bb_p): Pass cfun to stmt_can_throw_external. (gimple_purge_dead_eh_edges): Pass cfun to stmt_can_throw_internal. * tree-complex.c (expand_complex_libcall): Pass cfun to stmt_could_throw_p and to stmt_can_throw_internal. (expand_complex_multiplication): Pass cfun to stmt_can_throw_internal. * tree-inline.c (copy_edges_for_bb): Likewise. (maybe_move_debug_stmts_to_successors): Likewise. * tree-outof-ssa.c (ssa_is_replaceable_p): Pass cfun to stmt_could_throw_p. * tree-parloops.c (oacc_entry_exit_ok_1): Likewise. * tree-sra.c (scan_function): Pass cfun to stmt_can_throw_external. * tree-ssa-alias.c (stmt_kills_ref_p): Pass cfun to stmt_can_throw_internal. * tree-ssa-ccp.c (optimize_atomic_bit_test_and): Likewise. * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Pass cfun to stmt_could_throw_p. (mark_aliased_reaching_defs_necessary_1): Pass cfun to stmt_can_throw_internal. * tree-ssa-forwprop.c (pass_forwprop::execute): Likewise. * tree-ssa-loop-im.c (movement_possibility): Pass cfun to stmt_could_throw_p. * tree-ssa-loop-ivopts.c (find_givs_in_stmt_scev): Likewise. (add_autoinc_candidates): Pass cfun to stmt_can_throw_internal. * tree-ssa-math-opts.c (pass_cse_reciprocals::execute): Likewise. (convert_mult_to_fma_1): Likewise. (convert_to_divmod): Likewise. * tree-ssa-phiprop.c (propagate_with_phi): Likewise. * tree-ssa-pre.c (compute_avail): Pass cfun to stmt_could_throw_p. * tree-ssa-propagate.c (substitute_and_fold_dom_walker::before_dom_children): Likewise. * tree-ssa-reassoc.c (suitable_cond_bb): Likewise. (maybe_optimize_range_tests): Likewise. (linearize_expr_tree): Likewise. (reassociate_bb): Likewise. * tree-ssa-sccvn.c (copy_reference_ops_from_call): Likewise. * tree-ssa-scopedtables.c (hashable_expr_equal_p): Likewise. * tree-ssa-strlen.c (adjust_last_stmt): Likewise. (handle_char_store): Likewise. * tree-vect-data-refs.c (vect_find_stmt_data_reference): Pass cfun to stmt_can_throw_internal. * tree-vect-patterns.c (check_bool_pattern): Pass cfun to stmt_could_throw_p. * tree-vect-stmts.c (vect_finish_stmt_generation_1): Likewise. (vectorizable_call): Pass cfun to stmt_can_throw_internal. (vectorizable_simd_clone_call): Likewise. * value-prof.c (gimple_ic): Pass cfun to stmt_could_throw_p. (gimple_stringop_fixed_value): Likewise. --- gcc/cgraph.c | 10 +++--- gcc/gimple-fold.c | 2 +- gcc/gimple-ssa-evrp.c | 2 +- gcc/gimple-ssa-store-merging.c | 4 +-- gcc/gimple-ssa-strength-reduction.c | 2 +- gcc/gimplify-me.c | 2 +- gcc/ipa-pure-const.c | 10 +++--- gcc/trans-mem.c | 2 +- gcc/tree-cfg.c | 8 ++--- gcc/tree-complex.c | 6 ++-- gcc/tree-eh.c | 52 ++++++++++++++++------------- gcc/tree-eh.h | 6 ++-- gcc/tree-inline.c | 4 +-- gcc/tree-outof-ssa.c | 2 +- gcc/tree-parloops.c | 2 +- gcc/tree-sra.c | 2 +- gcc/tree-ssa-alias.c | 2 +- gcc/tree-ssa-ccp.c | 2 +- gcc/tree-ssa-dce.c | 4 +-- gcc/tree-ssa-forwprop.c | 2 +- gcc/tree-ssa-loop-im.c | 2 +- gcc/tree-ssa-loop-ivopts.c | 4 +-- gcc/tree-ssa-math-opts.c | 11 +++--- gcc/tree-ssa-phiprop.c | 2 +- gcc/tree-ssa-pre.c | 2 +- gcc/tree-ssa-propagate.c | 2 +- gcc/tree-ssa-reassoc.c | 10 +++--- gcc/tree-ssa-sccvn.c | 2 +- gcc/tree-ssa-scopedtables.c | 2 +- gcc/tree-ssa-strlen.c | 4 +-- gcc/tree-vect-data-refs.c | 2 +- gcc/tree-vect-patterns.c | 2 +- gcc/tree-vect-stmts.c | 6 ++-- gcc/value-prof.c | 8 ++--- 34 files changed, 94 insertions(+), 91 deletions(-) diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 8a03f3d6828..48bab9f2749 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -815,9 +815,8 @@ cgraph_edge::set_call_stmt (gcall *new_stmt, bool update_speculative) e = make_direct (new_callee); } - push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl)); - e->can_throw_external = stmt_can_throw_external (new_stmt); - pop_cfun (); + function *fun = DECL_STRUCT_FUNCTION (e->caller->decl); + e->can_throw_external = stmt_can_throw_external (fun, new_stmt); if (e->caller->call_site_hash) cgraph_add_edge_to_call_site_hash (e); } @@ -870,10 +869,9 @@ symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee, edge->count = count; edge->call_stmt = call_stmt; - push_cfun (DECL_STRUCT_FUNCTION (caller->decl)); edge->can_throw_external - = call_stmt ? stmt_can_throw_external (call_stmt) : false; - pop_cfun (); + = call_stmt ? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller->decl), + call_stmt) : false; if (call_stmt && callee && callee->decl && !gimple_check_call_matching_types (call_stmt, callee->decl, diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index fe6bc08bdd9..e862b1a1d4c 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -4023,7 +4023,7 @@ fold_builtin_atomic_compare_exchange (gimple_stmt_iterator *gsi) gimple_set_vuse (g, gimple_vuse (stmt)); SSA_NAME_DEF_STMT (gimple_vdef (g)) = g; tree oldlhs = gimple_call_lhs (stmt); - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) { throws = true; e = find_fallthru_edge (gsi_bb (*gsi)->succs); diff --git a/gcc/gimple-ssa-evrp.c b/gcc/gimple-ssa-evrp.c index 50e8adc1aad..7d952765c5a 100644 --- a/gcc/gimple-ssa-evrp.c +++ b/gcc/gimple-ssa-evrp.c @@ -164,7 +164,7 @@ evrp_dom_walker::before_dom_children (basic_block bb) if ((vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) && (val = value_range_constant_singleton (vr)) && may_propagate_copy (output, val) - && !stmt_could_throw_p (stmt) + && !stmt_could_throw_p (cfun, stmt) && !gimple_has_side_effects (stmt)) { stmts_to_remove.safe_push (stmt); diff --git a/gcc/gimple-ssa-store-merging.c b/gcc/gimple-ssa-store-merging.c index 85dd5bccead..e1ddcb5e558 100644 --- a/gcc/gimple-ssa-store-merging.c +++ b/gcc/gimple-ssa-store-merging.c @@ -4256,7 +4256,7 @@ handled_load (gimple *stmt, store_operand_info *op, } if (gimple_vuse (stmt) && gimple_assign_load_p (stmt) - && !stmt_can_throw_internal (stmt) + && !stmt_can_throw_internal (cfun, stmt) && !gimple_has_volatile_ops (stmt)) { tree mem = gimple_assign_rhs1 (stmt); @@ -4551,7 +4551,7 @@ pass_store_merging::execute (function *fun) } if (gimple_assign_single_p (stmt) && gimple_vdef (stmt) - && !stmt_can_throw_internal (stmt) + && !stmt_can_throw_internal (cfun, stmt) && lhs_valid_for_store_merging_p (gimple_assign_lhs (stmt))) process_store (stmt); else diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index ea81adca7ea..7ed6ae7f88a 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -1775,7 +1775,7 @@ find_candidates_dom_walker::before_dom_children (basic_block bb) { gimple *gs = gsi_stmt (gsi); - if (stmt_could_throw_p (gs)) + if (stmt_could_throw_p (cfun, gs)) continue; if (gimple_vuse (gs) && gimple_assign_single_p (gs)) diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c index 137a5662ccf..269fe6b3bae 100644 --- a/gcc/gimplify-me.c +++ b/gcc/gimplify-me.c @@ -273,7 +273,7 @@ gimple_regimplify_operands (gimple *stmt, gimple_stmt_iterator *gsi_p) || !(i & (ECF_CONST | ECF_PURE))) need_temp = true; } - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) need_temp = true; } } diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c index 66c81be23ec..1ca1d60517e 100644 --- a/gcc/ipa-pure-const.c +++ b/gcc/ipa-pure-const.c @@ -555,9 +555,9 @@ check_call (funct_state local, gcall *call, bool ipa) { int flags = gimple_call_flags (call); tree callee_t = gimple_call_fndecl (call); - bool possibly_throws = stmt_could_throw_p (call); + bool possibly_throws = stmt_could_throw_p (cfun, call); bool possibly_throws_externally = (possibly_throws - && stmt_can_throw_external (call)); + && stmt_can_throw_external (cfun, call)); if (possibly_throws) { @@ -770,7 +770,7 @@ check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa) ipa ? check_ipa_store : check_store); if (gimple_code (stmt) != GIMPLE_CALL - && stmt_could_throw_p (stmt)) + && stmt_could_throw_p (cfun, stmt)) { if (cfun->can_throw_non_call_exceptions) { @@ -778,7 +778,7 @@ check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa) fprintf (dump_file, " can throw; looping\n"); local->looping = true; } - if (stmt_can_throw_external (stmt)) + if (stmt_can_throw_external (cfun, stmt)) { if (dump_file) fprintf (dump_file, " can throw externally\n"); @@ -2307,7 +2307,7 @@ pass_nothrow::execute (function *) for (gimple_stmt_iterator gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi)) - if (stmt_can_throw_external (gsi_stmt (gsi))) + if (stmt_can_throw_external (cfun, gsi_stmt (gsi))) { if (is_gimple_call (gsi_stmt (gsi))) { diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index 1d4eb806202..7e4bcec4030 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -2582,7 +2582,7 @@ expand_call_tm (struct tm_region *region, gassign *assign_stmt; /* Remember if the call was going to throw. */ - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) { edge_iterator ei; edge e; diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 87979bc4d75..d30e4aca773 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -2720,7 +2720,7 @@ is_ctrl_altering_stmt (gimple *t) } /* If a statement can throw, it alters control flow. */ - return stmt_can_throw_internal (t); + return stmt_can_throw_internal (cfun, t); } @@ -5387,7 +5387,7 @@ verify_gimple_in_cfg (struct function *fn, bool verify_nothrow) visited_throwing_stmts.add (stmt); if (lp_nr > 0) { - if (!stmt_could_throw_p (stmt)) + if (!stmt_could_throw_p (cfun, stmt)) { if (verify_nothrow) { @@ -8283,7 +8283,7 @@ stmt_can_terminate_bb_p (gimple *t) /* Eh exception not handled internally terminates execution of the whole function. */ - if (stmt_can_throw_external (t)) + if (stmt_can_throw_external (cfun, t)) return true; /* NORETURN and LONGJMP calls already have an edge to exit. @@ -8599,7 +8599,7 @@ gimple_purge_dead_eh_edges (basic_block bb) edge_iterator ei; gimple *stmt = last_stmt (bb); - if (stmt && stmt_can_throw_internal (stmt)) + if (stmt && stmt_can_throw_internal (cfun, stmt)) return false; for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index 93f274cd213..49088081bb0 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -1010,13 +1010,13 @@ expand_complex_libcall (gimple_stmt_iterator *gsi, tree type, tree ar, tree ai, if (inplace_p) { gimple *old_stmt = gsi_stmt (*gsi); - gimple_call_set_nothrow (stmt, !stmt_could_throw_p (old_stmt)); + gimple_call_set_nothrow (stmt, !stmt_could_throw_p (cfun, old_stmt)); lhs = gimple_assign_lhs (old_stmt); gimple_call_set_lhs (stmt, lhs); gsi_replace (gsi, stmt, true); type = TREE_TYPE (type); - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) { edge_iterator ei; edge e; @@ -1134,7 +1134,7 @@ expand_complex_multiplication (gimple_stmt_iterator *gsi, tree type, /* If optimizing for size or not at all just do a libcall. Same if there are exception-handling edges or signaling NaNs. */ if (optimize == 0 || optimize_bb_for_size_p (gsi_bb (*gsi)) - || stmt_can_throw_internal (gsi_stmt (*gsi)) + || stmt_can_throw_internal (cfun, gsi_stmt (*gsi)) || flag_signaling_nans) { expand_complex_libcall (gsi, type, ar, ai, br, bi, diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index fb931aa4389..1c7d9dc1d59 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -2033,7 +2033,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi) available on the EH edge. Only do so for statements that potentially fall through (no noreturn calls e.g.), otherwise this new assignment might create fake fallthru regions. */ - if (stmt_could_throw_p (stmt) + if (stmt_could_throw_p (cfun, stmt) && gimple_has_lhs (stmt) && gimple_stmt_may_fallthru (stmt) && !tree_could_throw_p (gimple_get_lhs (stmt)) @@ -2051,7 +2051,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi) gsi_insert_after (gsi, s, GSI_SAME_STMT); } /* Look for things that can throw exceptions, and record them. */ - if (state->cur_region && stmt_could_throw_p (stmt)) + if (state->cur_region && stmt_could_throw_p (cfun, stmt)) { record_stmt_eh_region (state->cur_region, stmt); note_eh_region_may_contain_throw (state->cur_region); @@ -2866,10 +2866,10 @@ stmt_could_throw_1_p (gassign *stmt) } -/* Return true if statement STMT could throw an exception. */ +/* Return true if statement STMT within FUN could throw an exception. */ bool -stmt_could_throw_p (gimple *stmt) +stmt_could_throw_p (function *fun, gimple *stmt) { if (!flag_exceptions) return false; @@ -2886,7 +2886,7 @@ stmt_could_throw_p (gimple *stmt) case GIMPLE_COND: { - if (!cfun->can_throw_non_call_exceptions) + if (fun && !fun->can_throw_non_call_exceptions) return false; gcond *cond = as_a (stmt); tree lhs = gimple_cond_lhs (cond); @@ -2896,13 +2896,13 @@ stmt_could_throw_p (gimple *stmt) } case GIMPLE_ASSIGN: - if (!cfun->can_throw_non_call_exceptions + if ((fun && !fun->can_throw_non_call_exceptions) || gimple_clobber_p (stmt)) return false; return stmt_could_throw_1_p (as_a (stmt)); case GIMPLE_ASM: - if (!cfun->can_throw_non_call_exceptions) + if (fun && !fun->can_throw_non_call_exceptions) return false; return gimple_asm_volatile_p (as_a (stmt)); @@ -2936,33 +2936,37 @@ tree_could_throw_p (tree t) return false; } -/* Return true if STMT can throw an exception that is not caught within - the current function (CFUN). */ +/* Return true if STMT can throw an exception that is not caught within its + function FUN. FUN can be NULL but the function is extra conservative + then. */ bool -stmt_can_throw_external (gimple *stmt) +stmt_can_throw_external (function *fun, gimple *stmt) { int lp_nr; - if (!stmt_could_throw_p (stmt)) + if (!stmt_could_throw_p (fun, stmt)) return false; + if (!fun) + return true; - lp_nr = lookup_stmt_eh_lp (stmt); + lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); return lp_nr == 0; } -/* Return true if STMT can throw an exception that is caught within - the current function (CFUN). */ +/* Return true if STMT can throw an exception that is caught within its + function FUN. */ bool -stmt_can_throw_internal (gimple *stmt) +stmt_can_throw_internal (function *fun, gimple *stmt) { int lp_nr; - if (!stmt_could_throw_p (stmt)) + gcc_checking_assert (fun); + if (!stmt_could_throw_p (fun, stmt)) return false; - lp_nr = lookup_stmt_eh_lp (stmt); + lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); return lp_nr > 0; } @@ -2973,7 +2977,7 @@ stmt_can_throw_internal (gimple *stmt) bool maybe_clean_eh_stmt_fn (struct function *ifun, gimple *stmt) { - if (stmt_could_throw_p (stmt)) + if (stmt_could_throw_p (ifun, stmt)) return false; return remove_stmt_from_eh_lp_fn (ifun, stmt); } @@ -2998,7 +3002,7 @@ maybe_clean_or_replace_eh_stmt (gimple *old_stmt, gimple *new_stmt) if (lp_nr != 0) { - bool new_stmt_could_throw = stmt_could_throw_p (new_stmt); + bool new_stmt_could_throw = stmt_could_throw_p (cfun, new_stmt); if (new_stmt == old_stmt && new_stmt_could_throw) return false; @@ -3028,7 +3032,7 @@ maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple *new_stmt, { int old_lp_nr, new_lp_nr; - if (!stmt_could_throw_p (new_stmt)) + if (!stmt_could_throw_p (new_fun, new_stmt)) return false; old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt); @@ -3067,7 +3071,7 @@ maybe_duplicate_eh_stmt (gimple *new_stmt, gimple *old_stmt) { int lp_nr; - if (!stmt_could_throw_p (new_stmt)) + if (!stmt_could_throw_p (cfun, new_stmt)) return false; lp_nr = lookup_stmt_eh_lp (old_stmt); @@ -3862,7 +3866,7 @@ pass_lower_eh_dispatch::execute (function *fun) } else if (gimple_code (last) == GIMPLE_RESX) { - if (stmt_can_throw_external (last)) + if (stmt_can_throw_external (cfun, last)) optimize_clobbers (bb); else flags |= sink_clobbers (bb); @@ -4502,7 +4506,7 @@ cleanup_empty_eh (eh_landing_pad lp) resx = gsi_stmt (gsi); if (resx && is_gimple_resx (resx)) { - if (stmt_can_throw_external (resx)) + if (stmt_can_throw_external (cfun, resx)) optimize_clobbers (bb); else if (sink_clobbers (bb)) ret = true; @@ -4783,7 +4787,7 @@ verify_eh_edges (gimple *stmt) return false; } - if (!stmt_could_throw_p (stmt)) + if (!stmt_could_throw_p (cfun, stmt)) { error ("BB %i last statement has incorrectly set lp", bb->index); return true; diff --git a/gcc/tree-eh.h b/gcc/tree-eh.h index 11e096c9e5f..2bd6a856bd9 100644 --- a/gcc/tree-eh.h +++ b/gcc/tree-eh.h @@ -38,10 +38,10 @@ extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool, extern bool operation_could_trap_p (enum tree_code, bool, bool, tree); extern bool tree_could_trap_p (tree); extern tree rewrite_to_non_trapping_overflow (tree); -extern bool stmt_could_throw_p (gimple *); +extern bool stmt_could_throw_p (function *, gimple *); extern bool tree_could_throw_p (tree); -extern bool stmt_can_throw_external (gimple *); -extern bool stmt_can_throw_internal (gimple *); +extern bool stmt_can_throw_external (function *, gimple *); +extern bool stmt_can_throw_internal (function *, gimple *); extern bool maybe_clean_eh_stmt_fn (struct function *, gimple *); extern bool maybe_clean_eh_stmt (gimple *); extern bool maybe_clean_or_replace_eh_stmt (gimple *, gimple *); diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 913425394e0..297fcd70c82 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -2246,7 +2246,7 @@ copy_edges_for_bb (basic_block bb, profile_count num, profile_count den, propagation can change an INDIRECT_REF which throws into a COMPONENT_REF which doesn't. If the copy can throw, the original could also throw. */ - can_throw = stmt_can_throw_internal (copy_stmt); + can_throw = stmt_can_throw_internal (cfun, copy_stmt); nonlocal_goto = (stmt_can_make_abnormal_goto (copy_stmt) && !computed_goto_p (copy_stmt)); @@ -2514,7 +2514,7 @@ maybe_move_debug_stmts_to_successors (copy_body_data *id, basic_block new_bb) if (gsi_end_p (si) || gsi_one_before_end_p (si) - || !(stmt_can_throw_internal (gsi_stmt (si)) + || !(stmt_can_throw_internal (cfun, gsi_stmt (si)) || stmt_can_make_abnormal_goto (gsi_stmt (si)))) return; diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c index 3f880ef7382..fca15e5f898 100644 --- a/gcc/tree-outof-ssa.c +++ b/gcc/tree-outof-ssa.c @@ -65,7 +65,7 @@ ssa_is_replaceable_p (gimple *stmt) return false; /* If the statement may throw an exception, it cannot be replaced. */ - if (stmt_could_throw_p (stmt)) + if (stmt_could_throw_p (cfun, stmt)) return false; /* Punt if there is more than 1 def. */ diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index e89c8875147..5935cf40927 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -3076,7 +3076,7 @@ oacc_entry_exit_ok_1 (bitmap in_loop_bbs, vec region_bbs, continue; else if (!gimple_has_side_effects (stmt) && !gimple_could_trap_p (stmt) - && !stmt_could_throw_p (stmt) + && !stmt_could_throw_p (cfun, stmt) && !gimple_vdef (stmt) && !gimple_vuse (stmt)) continue; diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index a9681ece0ae..e3e37466283 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -1470,7 +1470,7 @@ scan_function (void) tree t; unsigned i; - if (final_bbs && stmt_can_throw_external (stmt)) + if (final_bbs && stmt_can_throw_external (cfun, stmt)) bitmap_set_bit (final_bbs, bb->index); switch (gimple_code (stmt)) { diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c index 032e79b8ba0..85a5de7ce05 100644 --- a/gcc/tree-ssa-alias.c +++ b/gcc/tree-ssa-alias.c @@ -2396,7 +2396,7 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref) ??? We only need to care about the RHS throwing. For aggregate assignments or similar calls and non-call exceptions the LHS might throw as well. */ - && !stmt_can_throw_internal (stmt)) + && !stmt_can_throw_internal (cfun, stmt)) { tree lhs = gimple_get_lhs (stmt); /* If LHS is literally a base of the access we are done. */ diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index d8a069be529..55ee30e7d13 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -2931,7 +2931,7 @@ optimize_atomic_bit_test_and (gimple_stmt_iterator *gsip, gimple_set_location (g, gimple_location (call)); gimple_set_vuse (g, gimple_vuse (call)); gimple_set_vdef (g, gimple_vdef (call)); - bool throws = stmt_can_throw_internal (call); + bool throws = stmt_can_throw_internal (cfun, call); gimple_call_set_nothrow (as_a (g), gimple_call_nothrow_p (as_a (call))); SSA_NAME_DEF_STMT (gimple_vdef (call)) = g; diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c index 91ce2aa4fc5..a8261b9a476 100644 --- a/gcc/tree-ssa-dce.c +++ b/gcc/tree-ssa-dce.c @@ -195,7 +195,7 @@ mark_stmt_if_obviously_necessary (gimple *stmt, bool aggressive) throw. If a statement could throw, it can be deemed necessary. */ if (cfun->can_throw_non_call_exceptions && !cfun->can_delete_dead_exceptions - && stmt_could_throw_p (stmt)) + && stmt_could_throw_p (cfun, stmt)) { mark_stmt_necessary (stmt, true); return; @@ -473,7 +473,7 @@ mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data) ??? We only need to care about the RHS throwing. For aggregate assignments or similar calls and non-call exceptions the LHS might throw as well. */ - && !stmt_can_throw_internal (def_stmt)) + && !stmt_can_throw_internal (cfun, def_stmt)) { tree base, lhs = gimple_get_lhs (def_stmt); poly_int64 size, offset, max_size; diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index b1ee598fe5f..7449eaf86ae 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -2343,7 +2343,7 @@ pass_forwprop::execute (function *fun) && !gimple_has_volatile_ops (stmt) && (TREE_CODE (gimple_assign_rhs1 (stmt)) != TARGET_MEM_REF) - && !stmt_can_throw_internal (stmt)) + && !stmt_can_throw_internal (cfun, stmt)) { /* Rewrite loads used only in real/imagpart extractions to component-wise loads. */ diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 9c62f20866c..3c59134d840 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -302,7 +302,7 @@ movement_possibility (gimple *stmt) if (stmt_ends_bb_p (stmt) || gimple_has_volatile_ops (stmt) || gimple_has_side_effects (stmt) - || stmt_could_throw_p (stmt)) + || stmt_could_throw_p (cfun, stmt)) return MOVE_IMPOSSIBLE; if (is_gimple_call (stmt)) diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 6b445bd2214..b42f32da2b3 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -1440,7 +1440,7 @@ find_givs_in_stmt_scev (struct ivopts_data *data, gimple *stmt, affine_iv *iv) /* If STMT could throw, then do not consider STMT as defining a GIV. While this will suppress optimizations, we can not safely delete this GIV and associated statements, even if it appears it is not used. */ - if (stmt_could_throw_p (stmt)) + if (stmt_could_throw_p (cfun, stmt)) return false; return true; @@ -3222,7 +3222,7 @@ add_autoinc_candidates (struct ivopts_data *data, tree base, tree step, statement. */ if (use_bb->loop_father != data->current_loop || !dominated_by_p (CDI_DOMINATORS, data->current_loop->latch, use_bb) - || stmt_can_throw_internal (use->stmt) + || stmt_can_throw_internal (cfun, use->stmt) || !cst_and_fits_in_hwi (step)) return; diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index e5aa5310e58..ccff56f4297 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -951,7 +951,7 @@ pass_cse_reciprocals::execute (function *fun) stmt = gsi_stmt (gsi); if (flag_unsafe_math_optimizations && is_gimple_assign (stmt) - && !stmt_can_throw_internal (stmt) + && !stmt_can_throw_internal (cfun, stmt) && gimple_assign_rhs_code (stmt) == RDIV_EXPR) optimize_recip_sqrt (&gsi, def); } @@ -2904,7 +2904,8 @@ convert_mult_to_fma_1 (tree mul_result, tree op1, tree op2) else fma_stmt = gimple_build_call_internal (IFN_FMA, 3, mulop1, op2, addop); gimple_set_lhs (fma_stmt, gimple_get_lhs (use_stmt)); - gimple_call_set_nothrow (fma_stmt, !stmt_can_throw_internal (use_stmt)); + gimple_call_set_nothrow (fma_stmt, !stmt_can_throw_internal (cfun, + use_stmt)); gsi_replace (&gsi, fma_stmt, true); /* Follow all SSA edges so that we generate FMS, FNMA and FNMS regardless of where the negation occurs. */ @@ -3534,7 +3535,7 @@ divmod_candidate_p (gassign *stmt) static bool convert_to_divmod (gassign *stmt) { - if (stmt_can_throw_internal (stmt) + if (stmt_can_throw_internal (cfun, stmt) || !divmod_candidate_p (stmt)) return false; @@ -3560,7 +3561,7 @@ convert_to_divmod (gassign *stmt) && operand_equal_p (op1, gimple_assign_rhs1 (use_stmt), 0) && operand_equal_p (op2, gimple_assign_rhs2 (use_stmt), 0)) { - if (stmt_can_throw_internal (use_stmt)) + if (stmt_can_throw_internal (cfun, use_stmt)) continue; basic_block bb = gimple_bb (use_stmt); @@ -3598,7 +3599,7 @@ convert_to_divmod (gassign *stmt) && operand_equal_p (top_op2, gimple_assign_rhs2 (use_stmt), 0)) { if (use_stmt == top_stmt - || stmt_can_throw_internal (use_stmt) + || stmt_can_throw_internal (cfun, use_stmt) || !dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), top_bb)) continue; diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c index 03dbb390bf8..bb18f3e9b49 100644 --- a/gcc/tree-ssa-phiprop.c +++ b/gcc/tree-ssa-phiprop.c @@ -339,7 +339,7 @@ propagate_with_phi (basic_block bb, gphi *phi, struct phiprop_d *phivn, || types_compatible_p (TREE_TYPE (gimple_assign_lhs (use_stmt)), type)) /* We cannot replace a load that may throw or is volatile. */ - && !stmt_can_throw_internal (use_stmt))) + && !stmt_can_throw_internal (cfun, use_stmt))) continue; /* Check if we can move the loads. The def stmt of the virtual use diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index d1b0cc0c26f..20d3c7807a1 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -3827,7 +3827,7 @@ compute_avail (void) BB_LIVE_VOP_ON_EXIT (block) = gimple_vdef (stmt); if (gimple_has_side_effects (stmt) - || stmt_could_throw_p (stmt) + || stmt_could_throw_p (cfun, stmt) || is_gimple_debug (stmt)) continue; diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c index b1bfdd5c016..c635e3069f4 100644 --- a/gcc/tree-ssa-propagate.c +++ b/gcc/tree-ssa-propagate.c @@ -1038,7 +1038,7 @@ substitute_and_fold_dom_walker::before_dom_children (basic_block bb) if (sprime && sprime != lhs && may_propagate_copy (lhs, sprime) - && !stmt_could_throw_p (stmt) + && !stmt_could_throw_p (cfun, stmt) && !gimple_has_side_effects (stmt) /* We have to leave ASSERT_EXPRs around for jump-threading. */ && (!is_gimple_assign (stmt) diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 6b0bf5c0354..971d926e789 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -3702,7 +3702,7 @@ suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb, || (gimple_code (stmt) != GIMPLE_COND && (backward || !final_range_test_p (stmt))) || gimple_visited_p (stmt) - || stmt_could_throw_p (stmt) + || stmt_could_throw_p (cfun, stmt) || *other_bb == bb) return false; is_cond = gimple_code (stmt) == GIMPLE_COND; @@ -3958,7 +3958,7 @@ maybe_optimize_range_tests (gimple *stmt) else return cfg_cleanup_needed; - if (stmt_could_throw_p (stmt)) + if (stmt_could_throw_p (cfun, stmt)) return cfg_cleanup_needed; /* As relative ordering of post-dominator sons isn't fixed, @@ -5109,14 +5109,14 @@ linearize_expr_tree (vec *ops, gimple *stmt, { binlhsdef = SSA_NAME_DEF_STMT (binlhs); binlhsisreassoc = (is_reassociable_op (binlhsdef, rhscode, loop) - && !stmt_could_throw_p (binlhsdef)); + && !stmt_could_throw_p (cfun, binlhsdef)); } if (TREE_CODE (binrhs) == SSA_NAME) { binrhsdef = SSA_NAME_DEF_STMT (binrhs); binrhsisreassoc = (is_reassociable_op (binrhsdef, rhscode, loop) - && !stmt_could_throw_p (binrhsdef)); + && !stmt_could_throw_p (cfun, binrhsdef)); } /* If the LHS is not reassociable, but the RHS is, we need to swap @@ -5851,7 +5851,7 @@ reassociate_bb (basic_block bb) stmt = gsi_stmt (gsi); if (is_gimple_assign (stmt) - && !stmt_could_throw_p (stmt)) + && !stmt_could_throw_p (cfun, stmt)) { tree lhs, rhs1, rhs2; enum tree_code rhs_code = gimple_assign_rhs_code (stmt); diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 5a05dfb5640..e61f0ba7b8c 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -1210,7 +1210,7 @@ copy_reference_ops_from_call (gcall *call, temp.opcode = CALL_EXPR; temp.op0 = gimple_call_fn (call); temp.op1 = gimple_call_chain (call); - if (stmt_could_throw_p (call) && (lr = lookup_stmt_eh_lp (call)) > 0) + if (stmt_could_throw_p (cfun, call) && (lr = lookup_stmt_eh_lp (call)) > 0) temp.op2 = size_int (lr); temp.off = -1; result->safe_push (temp); diff --git a/gcc/tree-ssa-scopedtables.c b/gcc/tree-ssa-scopedtables.c index 9e751a27152..d1a73a5d64c 100644 --- a/gcc/tree-ssa-scopedtables.c +++ b/gcc/tree-ssa-scopedtables.c @@ -666,7 +666,7 @@ hashable_expr_equal_p (const struct hashable_expr *expr0, expr1->ops.call.args[i], 0)) return false; - if (stmt_could_throw_p (expr0->ops.call.fn_from)) + if (stmt_could_throw_p (cfun, expr0->ops.call.fn_from)) { int lp0 = lookup_stmt_eh_lp (expr0->ops.call.fn_from); int lp1 = lookup_stmt_eh_lp (expr1->ops.call.fn_from); diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index 3fa5ef56f38..fd8c2750116 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -1064,7 +1064,7 @@ adjust_last_stmt (strinfo *si, gimple *stmt, bool is_strcat) if (!integer_zerop (gimple_assign_rhs1 (last.stmt))) return; - if (stmt_could_throw_p (last.stmt)) + if (stmt_could_throw_p (cfun, last.stmt)) return; gsi = gsi_for_stmt (last.stmt); unlink_stmt_vdef (last.stmt); @@ -3253,7 +3253,7 @@ handle_char_store (gimple_stmt_iterator *gsi) { /* When overwriting a '\0' with a '\0', the store can be removed if we know it has been stored in the current function. */ - if (!stmt_could_throw_p (stmt) && si->writable) + if (!stmt_could_throw_p (cfun, stmt) && si->writable) { unlink_stmt_vdef (stmt); release_defs (stmt); diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index c4805e72447..4b3711442e6 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -3844,7 +3844,7 @@ vect_find_stmt_data_reference (loop_p loop, gimple *stmt, return opt_result::failure_at (stmt, "not vectorized: volatile type: %G", stmt); - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) return opt_result::failure_at (stmt, "not vectorized:" " statement can throw an exception: %G", diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index 7956c1326d3..5548d47b87f 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -3235,7 +3235,7 @@ check_bool_pattern (tree var, vec_info *vinfo, hash_set &stmts) /* If the comparison can throw, then is_gimple_condexpr will be false and we can't make a COND_EXPR/VEC_COND_EXPR out of it. */ - if (stmt_could_throw_p (def_stmt)) + if (stmt_could_throw_p (cfun, def_stmt)) return false; comp_vectype = get_vectype_for_scalar_type (TREE_TYPE (rhs1)); diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index 8108d52a3cb..8995da80b1e 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -1711,7 +1711,7 @@ vect_finish_stmt_generation_1 (stmt_vec_info stmt_info, gimple *vec_stmt) e.g. be in a must-not-throw region. Ensure newly created stmts that could throw are part of the same region. */ int lp_nr = lookup_stmt_eh_lp (stmt_info->stmt); - if (lp_nr != 0 && stmt_could_throw_p (vec_stmt)) + if (lp_nr != 0 && stmt_could_throw_p (cfun, vec_stmt)) add_stmt_to_eh_lp (vec_stmt, lp_nr); return vec_stmt_info; @@ -3116,7 +3116,7 @@ vectorizable_call (stmt_vec_info stmt_info, gimple_stmt_iterator *gsi, || TREE_CODE (gimple_call_lhs (stmt)) != SSA_NAME) return false; - gcc_checking_assert (!stmt_can_throw_internal (stmt)); + gcc_checking_assert (!stmt_can_throw_internal (cfun, stmt)); vectype_out = STMT_VINFO_VECTYPE (stmt_info); @@ -3751,7 +3751,7 @@ vectorizable_simd_clone_call (stmt_vec_info stmt_info, && TREE_CODE (gimple_call_lhs (stmt)) != SSA_NAME) return false; - gcc_checking_assert (!stmt_can_throw_internal (stmt)); + gcc_checking_assert (!stmt_can_throw_internal (cfun, stmt)); vectype = STMT_VINFO_VECTYPE (stmt_info); diff --git a/gcc/value-prof.c b/gcc/value-prof.c index 60b982793d1..f3be9ff8747 100644 --- a/gcc/value-prof.c +++ b/gcc/value-prof.c @@ -1392,7 +1392,7 @@ gimple_ic (gcall *icall_stmt, struct cgraph_node *direct_call, /* Build an EH edge for the direct call if necessary. */ lp_nr = lookup_stmt_eh_lp (icall_stmt); - if (lp_nr > 0 && stmt_could_throw_p (dcall_stmt)) + if (lp_nr > 0 && stmt_could_throw_p (cfun, dcall_stmt)) { add_stmt_to_eh_lp (dcall_stmt, lp_nr); } @@ -1410,7 +1410,7 @@ gimple_ic (gcall *icall_stmt, struct cgraph_node *direct_call, PHI_ARG_DEF_FROM_EDGE (phi, e_eh)); } } - if (!stmt_could_throw_p (dcall_stmt)) + if (!stmt_could_throw_p (cfun, dcall_stmt)) gimple_purge_dead_eh_edges (dcall_bb); return dcall_stmt; } @@ -1634,8 +1634,8 @@ gimple_stringop_fixed_value (gcall *vcall_stmt, tree icall_size, profile_probabi } /* Because these are all string op builtins, they're all nothrow. */ - gcc_assert (!stmt_could_throw_p (vcall_stmt)); - gcc_assert (!stmt_could_throw_p (icall_stmt)); + gcc_assert (!stmt_could_throw_p (cfun, vcall_stmt)); + gcc_assert (!stmt_could_throw_p (cfun, icall_stmt)); } /* Find values inside STMT for that we want to measure histograms for