From 8e33db8fc08900f77200506f2cdf5c50e2fbfcba Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Fri, 18 Sep 2015 20:56:15 -0600 Subject: [PATCH] [PATCH] avail_expr_stack is no longer file scoped PR tree-optimization/47679 * tree-ssa-dom.c (avail_exprs_stack): No longer file scoped. Move it here ... (dom_opt_dom_walker): New private member holding the avail_exprs_stack object. Update constructor. (pass_dominator::execute): Corresponding chagnes to declaration and initialization of avail_exprs_stack. Update constructor call for dom_opt_dom_walker object. (lookup_avail_expr, record_cond): Accept additional argument. Pass it down to children as needed. (record_equivalences_from_incoming_edge): Likewise. (eliminate_redundant_computations): Likewise. (record_equivalences_from_stmt): Likewise. (simplify_stmt_for_jump_threading): Likewise. (record_temporary_equivalences): Likewise. (optimize_stmt): Likewise. (dom_opt_dom_walker::thread_across_edge): Update access to avail_exprs_stack object and pass it to children as needed. (dom_opt_dom_walker::before_dom_children): Similarly. (dom_opt_dom_walker::after_dom_children): Similarly. * tree-ssa-threadedge.c (pfn_simplify): New typedef. (record_temporary_equivalences_from_stmts_at_dest): Use new typedef. Add avail_expr_stack argument. Pass it to children as needed. (dummy_simplify): Likewise. (simplify_control_stmt_condition): Likewise. (thread_around_empty_blocks): Likewise. (thread_through_normal_block): Likewise. (thread_across_edge): Likewise. * tree-ssa-threadedge.h (thread_across_edge): Update prototype. * tree-vrp.c (simplify_stmt_for_jump_threading): Update. From-SVN: r227931 --- gcc/ChangeLog | 31 ++++++++++ gcc/tree-ssa-dom.c | 123 ++++++++++++++++++++++---------------- gcc/tree-ssa-threadedge.c | 69 ++++++++++++++------- gcc/tree-ssa-threadedge.h | 2 +- gcc/tree-vrp.c | 3 +- 5 files changed, 153 insertions(+), 75 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 475497713f4..4d0b1f5b4d4 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,36 @@ 2015-09-18 Jeff Law + PR tree-optimization/47679 + * tree-ssa-dom.c (avail_exprs_stack): No longer file scoped. Move + it here ... + (dom_opt_dom_walker): New private member holding the avail_exprs_stack + object. Update constructor. + (pass_dominator::execute): Corresponding chagnes to declaration + and initialization of avail_exprs_stack. Update constructor call + for dom_opt_dom_walker object. + (lookup_avail_expr, record_cond): Accept additional argument. Pass + it down to children as needed. + (record_equivalences_from_incoming_edge): Likewise. + (eliminate_redundant_computations): Likewise. + (record_equivalences_from_stmt): Likewise. + (simplify_stmt_for_jump_threading): Likewise. + (record_temporary_equivalences): Likewise. + (optimize_stmt): Likewise. + (dom_opt_dom_walker::thread_across_edge): Update access to + avail_exprs_stack object and pass it to children as needed. + (dom_opt_dom_walker::before_dom_children): Similarly. + (dom_opt_dom_walker::after_dom_children): Similarly. + * tree-ssa-threadedge.c (pfn_simplify): New typedef. + (record_temporary_equivalences_from_stmts_at_dest): Use new typedef. + Add avail_expr_stack argument. Pass it to children as needed. + (dummy_simplify): Likewise. + (simplify_control_stmt_condition): Likewise. + (thread_around_empty_blocks): Likewise. + (thread_through_normal_block): Likewise. + (thread_across_edge): Likewise. + * tree-ssa-threadedge.h (thread_across_edge): Update prototype. + * tree-vrp.c (simplify_stmt_for_jump_threading): Update. + PR tree-optimization/47679 * tree-ssa-dom.c (const_and_copies): No longer file scoped. Move it here ... diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index fd2566c72dc..936af9919bc 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -78,9 +78,6 @@ struct edge_info vec cond_equivalences; }; -/* Unwindable equivalences, both const/copy and expression varieties. */ -static avail_exprs_stack *avail_exprs_stack; - /* Track whether or not we have changed the control flow graph. */ static bool cfg_altered; @@ -103,16 +100,20 @@ static struct opt_stats_d opt_stats; /* Local functions. */ static void optimize_stmt (basic_block, gimple_stmt_iterator, - class const_and_copies *); -static tree lookup_avail_expr (gimple, bool); -static void record_cond (cond_equivalence *); + class const_and_copies *, + class avail_exprs_stack *); +static tree lookup_avail_expr (gimple, bool, class avail_exprs_stack *); +static void record_cond (cond_equivalence *, class avail_exprs_stack *); static void record_equality (tree, tree, class const_and_copies *); static void record_equivalences_from_phis (basic_block); static void record_equivalences_from_incoming_edge (basic_block, - class const_and_copies *); + class const_and_copies *, + class avail_exprs_stack *); static void eliminate_redundant_computations (gimple_stmt_iterator *, - class const_and_copies *); -static void record_equivalences_from_stmt (gimple, int); + class const_and_copies *, + class avail_exprs_stack *); +static void record_equivalences_from_stmt (gimple, int, + class avail_exprs_stack *); static edge single_incoming_edge_ignoring_loop_edges (basic_block); static void dump_dominator_optimization_stats (FILE *file, hash_table *); @@ -490,9 +491,11 @@ class dom_opt_dom_walker : public dom_walker { public: dom_opt_dom_walker (cdi_direction direction, - class const_and_copies *const_and_copies) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack) : dom_walker (direction), m_const_and_copies (const_and_copies), + m_avail_exprs_stack (avail_exprs_stack), m_dummy_cond (NULL) {} virtual void before_dom_children (basic_block); @@ -503,6 +506,7 @@ private: /* Unwindable equivalences, both const/copy and expression varieties. */ class const_and_copies *m_const_and_copies; + class avail_exprs_stack *m_avail_exprs_stack; gcond *m_dummy_cond; }; @@ -550,7 +554,8 @@ pass_dominator::execute (function *fun) /* Create our hash tables. */ hash_table *avail_exprs = new hash_table (1024); - avail_exprs_stack = new class avail_exprs_stack (avail_exprs); + class avail_exprs_stack *avail_exprs_stack + = new class avail_exprs_stack (avail_exprs); class const_and_copies *const_and_copies = new class const_and_copies (); need_eh_cleanup = BITMAP_ALLOC (NULL); need_noreturn_fixup.create (0); @@ -589,7 +594,9 @@ pass_dominator::execute (function *fun) record_edge_info (bb); /* Recursively walk the dominator tree optimizing statements. */ - dom_opt_dom_walker walker (CDI_DOMINATORS, const_and_copies); + dom_opt_dom_walker walker (CDI_DOMINATORS, + const_and_copies, + avail_exprs_stack); walker.walk (fun->cfg->x_entry_block_ptr); { @@ -749,9 +756,10 @@ canonicalize_comparison (gcond *condstmt) threading code with a simple API for simplifying statements. */ static tree simplify_stmt_for_jump_threading (gimple stmt, - gimple within_stmt ATTRIBUTE_UNUSED) + gimple within_stmt ATTRIBUTE_UNUSED, + class avail_exprs_stack *avail_exprs_stack) { - return lookup_avail_expr (stmt, false); + return lookup_avail_expr (stmt, false, avail_exprs_stack); } /* Valueize hook for gimple_fold_stmt_to_constant_1. */ @@ -768,13 +776,14 @@ dom_valueize (tree t) return t; } -/* Record into the equivalence tables any equivalences implied by - traversing edge E (which are cached in E->aux). +/* Record into CONST_AND_COPIES and AVAIL_EXPRS_STACK any equivalences implied + by traversing edge E (which are cached in E->aux). Callers are responsible for managing the unwinding markers. */ static void record_temporary_equivalences (edge e, - class const_and_copies *const_and_copies) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack) { int i; struct edge_info *edge_info = (struct edge_info *) e->aux; @@ -861,7 +870,7 @@ record_temporary_equivalences (edge e, /* If we have 0 = COND or 1 = COND equivalences, record them into our expression hash tables. */ for (i = 0; edge_info->cond_equivalences.iterate (i, &eq); ++i) - record_cond (eq); + record_cond (eq, avail_exprs_stack); } } @@ -880,16 +889,16 @@ dom_opt_dom_walker::thread_across_edge (edge e) /* Push a marker on both stacks so we can unwind the tables back to their current state. */ - avail_exprs_stack->push_marker (); + m_avail_exprs_stack->push_marker (); m_const_and_copies->push_marker (); /* Traversing E may result in equivalences we can utilize. */ - record_temporary_equivalences (e, m_const_and_copies); + record_temporary_equivalences (e, m_const_and_copies, m_avail_exprs_stack); /* With all the edge equivalences in the tables, go ahead and attempt to thread through E->dest. */ ::thread_across_edge (m_dummy_cond, e, false, - m_const_and_copies, avail_exprs_stack, + m_const_and_copies, m_avail_exprs_stack, simplify_stmt_for_jump_threading); /* And restore the various tables to their state before @@ -898,7 +907,7 @@ dom_opt_dom_walker::thread_across_edge (edge e) XXX The code in tree-ssa-threadedge.c will restore the state of the const_and_copies table. We we just have to restore the expression table. */ - avail_exprs_stack->pop_to_marker (); + m_avail_exprs_stack->pop_to_marker (); } /* PHI nodes can create equivalences too. @@ -989,12 +998,14 @@ single_incoming_edge_ignoring_loop_edges (basic_block bb) return retval; } -/* Record any equivalences created by the incoming edge to BB. If BB - has more than one incoming edge, then no equivalence is created. */ +/* Record any equivalences created by the incoming edge to BB into + CONST_AND_COPIES and AVAIL_EXPRS_STACK. If BB has more than one + incoming edge, then no equivalence is created. */ static void record_equivalences_from_incoming_edge (basic_block bb, - class const_and_copies *const_and_copies) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack) { edge e; basic_block parent; @@ -1009,7 +1020,7 @@ record_equivalences_from_incoming_edge (basic_block bb, /* If we had a single incoming edge from our parent block, then enter any data associated with the edge into our tables. */ if (e && e->src == parent) - record_temporary_equivalences (e, const_and_copies); + record_temporary_equivalences (e, const_and_copies, avail_exprs_stack); } /* Dump statistics for the hash table HTAB. */ @@ -1041,12 +1052,14 @@ dump_dominator_optimization_stats (FILE *file, } -/* Enter condition equivalence into the expression hash table. +/* Enter condition equivalence P into AVAIL_EXPRS_HASH. + This indicates that a conditional expression has a known boolean value. */ static void -record_cond (cond_equivalence *p) +record_cond (cond_equivalence *p, + class avail_exprs_stack *avail_exprs_stack) { class expr_hash_elt *element = new expr_hash_elt (&p->cond, p->value); expr_hash_elt **slot; @@ -1056,7 +1069,6 @@ record_cond (cond_equivalence *p) if (*slot == NULL) { *slot = element; - avail_exprs_stack->record_expr (element, NULL, '1'); } else @@ -1280,10 +1292,11 @@ dom_opt_dom_walker::before_dom_children (basic_block bb) /* Push a marker on the stacks of local information so that we know how far to unwind when we finalize this block. */ - avail_exprs_stack->push_marker (); + m_avail_exprs_stack->push_marker (); m_const_and_copies->push_marker (); - record_equivalences_from_incoming_edge (bb, m_const_and_copies); + record_equivalences_from_incoming_edge (bb, m_const_and_copies, + m_avail_exprs_stack); /* PHI nodes can create equivalences too. */ record_equivalences_from_phis (bb); @@ -1291,13 +1304,14 @@ dom_opt_dom_walker::before_dom_children (basic_block bb) /* Create equivalences from redundant PHIs. PHIs are only truly redundant when they exist in the same block, so push another marker and unwind right afterwards. */ - avail_exprs_stack->push_marker (); + m_avail_exprs_stack->push_marker (); for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - eliminate_redundant_computations (&gsi, m_const_and_copies); - avail_exprs_stack->pop_to_marker (); + eliminate_redundant_computations (&gsi, m_const_and_copies, + m_avail_exprs_stack); + m_avail_exprs_stack->pop_to_marker (); for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - optimize_stmt (bb, gsi, m_const_and_copies); + optimize_stmt (bb, gsi, m_const_and_copies, m_avail_exprs_stack); /* Now prepare to process dominated blocks. */ record_edge_info (bb); @@ -1345,19 +1359,20 @@ dom_opt_dom_walker::after_dom_children (basic_block bb) } /* These remove expressions local to BB from the tables. */ - avail_exprs_stack->pop_to_marker (); + m_avail_exprs_stack->pop_to_marker (); m_const_and_copies->pop_to_marker (); } /* Search for redundant computations in STMT. If any are found, then replace them with the variable holding the result of the computation. - If safe, record this expression into the available expression hash - table. */ + If safe, record this expression into AVAIL_EXPRS_STACK and + CONST_AND_COPIES. */ static void eliminate_redundant_computations (gimple_stmt_iterator* gsi, - class const_and_copies *const_and_copies) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack) { tree expr_type; tree cached_lhs; @@ -1384,7 +1399,7 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi, insert = false; /* Check if the expression has been computed before. */ - cached_lhs = lookup_avail_expr (stmt, insert); + cached_lhs = lookup_avail_expr (stmt, insert, avail_exprs_stack); opt_stats.num_exprs_considered++; @@ -1459,12 +1474,14 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi, /* STMT, a GIMPLE_ASSIGN, may create certain equivalences, in either the available expressions table or the const_and_copies table. - Detect and record those equivalences. */ -/* We handle only very simple copy equivalences here. The heavy + Detect and record those equivalences into AVAIL_EXPRS_STACK. + + We handle only very simple copy equivalences here. The heavy lifing is done by eliminate_redundant_computations. */ static void -record_equivalences_from_stmt (gimple stmt, int may_optimize_p) +record_equivalences_from_stmt (gimple stmt, int may_optimize_p, + class avail_exprs_stack *avail_exprs_stack) { tree lhs; enum tree_code lhs_code; @@ -1567,7 +1584,7 @@ record_equivalences_from_stmt (gimple stmt, int may_optimize_p) /* Finally enter the statement into the available expression table. */ - lookup_avail_expr (new_stmt, true); + lookup_avail_expr (new_stmt, true, avail_exprs_stack); } } @@ -1649,7 +1666,8 @@ cprop_into_stmt (gimple stmt) cprop_operand (stmt, op_p); } -/* Optimize the statement pointed to by iterator SI. +/* Optimize the statement in block BB pointed to by iterator SI + using equivalences from CONST_AND_COPIES and AVAIL_EXPRS_STACK. We try to perform some simplistic global redundancy elimination and constant propagation: @@ -1666,7 +1684,8 @@ cprop_into_stmt (gimple stmt) static void optimize_stmt (basic_block bb, gimple_stmt_iterator si, - class const_and_copies *const_and_copies) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack) { gimple stmt, old_stmt; bool may_optimize_p; @@ -1756,7 +1775,8 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si, } update_stmt_if_modified (stmt); - eliminate_redundant_computations (&si, const_and_copies); + eliminate_redundant_computations (&si, const_and_copies, + avail_exprs_stack); stmt = gsi_stmt (si); /* Perform simple redundant store elimination. */ @@ -1778,7 +1798,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si, else new_stmt = gimple_build_assign (rhs, lhs); gimple_set_vuse (new_stmt, gimple_vuse (stmt)); - cached_lhs = lookup_avail_expr (new_stmt, false); + cached_lhs = lookup_avail_expr (new_stmt, false, avail_exprs_stack); if (cached_lhs && rhs == cached_lhs) { @@ -1798,7 +1818,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si, /* Record any additional equivalences created by this statement. */ if (is_gimple_assign (stmt)) - record_equivalences_from_stmt (stmt, may_optimize_p); + record_equivalences_from_stmt (stmt, may_optimize_p, avail_exprs_stack); /* If STMT is a COND_EXPR and it was modified, then we may know where it goes. If that is the case, then mark the CFG as altered. @@ -1876,7 +1896,7 @@ vuse_eq (ao_ref *, tree vuse1, unsigned int cnt, void *data) return NULL; } -/* Search for an existing instance of STMT in the AVAIL_EXPRS table. +/* Search for an existing instance of STMT in the AVAIL_EXPRS_STACK table. If found, return its LHS. Otherwise insert STMT in the table and return NULL_TREE. @@ -1885,7 +1905,8 @@ vuse_eq (ao_ref *, tree vuse1, unsigned int cnt, void *data) we finish processing this block and its children. */ static tree -lookup_avail_expr (gimple stmt, bool insert) +lookup_avail_expr (gimple stmt, bool insert, + class avail_exprs_stack *avail_exprs_stack) { expr_hash_elt **slot; tree lhs; diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c index 48c4ca765db..ba25e077679 100644 --- a/gcc/tree-ssa-threadedge.c +++ b/gcc/tree-ssa-threadedge.c @@ -56,6 +56,8 @@ static int stmt_count; /* Array to record value-handles per SSA_NAME. */ vec ssa_name_values; +typedef tree (pfn_simplify) (gimple, gimple, class avail_exprs_stack *); + /* Set the value for the SSA name NAME to VALUE. */ void @@ -256,10 +258,10 @@ fold_assignment_stmt (gimple stmt) static gimple record_temporary_equivalences_from_stmts_at_dest (edge e, - const_and_copies *const_and_copies, - tree (*simplify) (gimple, - gimple), - bool backedge_seen) + const_and_copies *const_and_copies, + avail_exprs_stack *avail_exprs_stack, + pfn_simplify simplify, + bool backedge_seen) { gimple stmt = NULL; gimple_stmt_iterator gsi; @@ -412,7 +414,7 @@ record_temporary_equivalences_from_stmts_at_dest (edge e, if (!cached_lhs || (TREE_CODE (cached_lhs) != SSA_NAME && !is_gimple_min_invariant (cached_lhs))) - cached_lhs = (*simplify) (stmt, stmt); + cached_lhs = (*simplify) (stmt, stmt, avail_exprs_stack); /* Restore the statement's original uses/defs. */ i = 0; @@ -445,7 +447,8 @@ record_temporary_equivalences_from_stmts_at_dest (edge e, necessarily valid. We use this callback rather than the ones provided by DOM/VRP to achieve that effect. */ static tree -dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED, gimple stmt2 ATTRIBUTE_UNUSED) +dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED, gimple stmt2 ATTRIBUTE_UNUSED, + class avail_exprs_stack *avail_exprs_stack ATTRIBUTE_UNUSED) { return NULL_TREE; } @@ -459,13 +462,16 @@ dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED, gimple stmt2 ATTRIBUTE_UNUSED) a condition using pass specific information. Return the simplified condition or NULL if simplification could - not be performed. */ + not be performed. + + The available expression table is referenced via AVAIL_EXPRS_STACK. */ static tree simplify_control_stmt_condition (edge e, gimple stmt, + class avail_exprs_stack *avail_exprs_stack, gcond *dummy_cond, - tree (*simplify) (gimple, gimple), + pfn_simplify simplify, bool handle_dominating_asserts) { tree cond, cached_lhs; @@ -552,7 +558,7 @@ simplify_control_stmt_condition (edge e, then use the pass specific callback to simplify the condition. */ if (!cached_lhs || !is_gimple_min_invariant (cached_lhs)) - cached_lhs = (*simplify) (dummy_cond, stmt); + cached_lhs = (*simplify) (dummy_cond, stmt, avail_exprs_stack); /* If we were just testing that an integral type was != 0, and that failed, just return the first operand. This gives the FSM code a @@ -614,7 +620,7 @@ simplify_control_stmt_condition (edge e, /* If we haven't simplified to an invariant yet, then use the pass specific callback to try and simplify it further. */ if (cached_lhs && ! is_gimple_min_invariant (cached_lhs)) - cached_lhs = (*simplify) (stmt, stmt); + cached_lhs = (*simplify) (stmt, stmt, avail_exprs_stack); /* We couldn't find an invariant. But, callers of this function may be able to do something useful with the @@ -764,12 +770,16 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src) return false. DUMMY_COND, HANDLE_DOMINATING_ASSERTS and SIMPLIFY are used to - try and simplify the condition at the end of TAKEN_EDGE->dest. */ + try and simplify the condition at the end of TAKEN_EDGE->dest. + + The available expression table is referenced via AVAIL_EXPRS_STACK. */ + static bool thread_around_empty_blocks (edge taken_edge, gcond *dummy_cond, + class avail_exprs_stack *avail_exprs_stack, bool handle_dominating_asserts, - tree (*simplify) (gimple, gimple), + pfn_simplify simplify, bitmap visited, vec *path, bool *backedge_seen_p) @@ -818,6 +828,7 @@ thread_around_empty_blocks (edge taken_edge, simplify = dummy_simplify; return thread_around_empty_blocks (taken_edge, dummy_cond, + avail_exprs_stack, handle_dominating_asserts, simplify, visited, @@ -846,7 +857,8 @@ thread_around_empty_blocks (edge taken_edge, simplify = dummy_simplify; /* Extract and simplify the condition. */ - cond = simplify_control_stmt_condition (taken_edge, stmt, dummy_cond, + cond = simplify_control_stmt_condition (taken_edge, stmt, + avail_exprs_stack, dummy_cond, simplify, handle_dominating_asserts); /* If the condition can be statically computed and we have not already @@ -869,6 +881,7 @@ thread_around_empty_blocks (edge taken_edge, thread_around_empty_blocks (taken_edge, dummy_cond, + avail_exprs_stack, handle_dominating_asserts, simplify, visited, @@ -1187,7 +1200,8 @@ thread_through_normal_block (edge e, gcond *dummy_cond, bool handle_dominating_asserts, const_and_copies *const_and_copies, - tree (*simplify) (gimple, gimple), + avail_exprs_stack *avail_exprs_stack, + pfn_simplify simplify, vec *path, bitmap visited, bool *backedge_seen_p) @@ -1210,6 +1224,7 @@ thread_through_normal_block (edge e, temporary equivalences we can detect. */ gimple stmt = record_temporary_equivalences_from_stmts_at_dest (e, const_and_copies, + avail_exprs_stack, simplify, *backedge_seen_p); @@ -1248,7 +1263,8 @@ thread_through_normal_block (edge e, tree cond; /* Extract and simplify the condition. */ - cond = simplify_control_stmt_condition (e, stmt, dummy_cond, simplify, + cond = simplify_control_stmt_condition (e, stmt, avail_exprs_stack, + dummy_cond, simplify, handle_dominating_asserts); if (!cond) @@ -1293,6 +1309,7 @@ thread_through_normal_block (edge e, bitmap_set_bit (visited, e->dest->index); thread_around_empty_blocks (taken_edge, dummy_cond, + avail_exprs_stack, handle_dominating_asserts, simplify, visited, @@ -1348,8 +1365,10 @@ thread_through_normal_block (edge e, the simplified condition with left-hand sides of ASSERT_EXPRs they are used in. - STACK is used to undo temporary equivalences created during the walk of - E->dest. + CONST_AND_COPIES is used to undo temporary equivalences created during the + walk of E->dest. + + The available expression table is referenced vai AVAIL_EXPRS_STACK. SIMPLIFY is a pass-specific function used to simplify statements. */ @@ -1357,9 +1376,10 @@ void thread_across_edge (gcond *dummy_cond, edge e, bool handle_dominating_asserts, - const_and_copies *const_and_copies, - avail_exprs_stack *avail_exprs_stack, - tree (*simplify) (gimple, gimple)) + class const_and_copies *const_and_copies, + class avail_exprs_stack *avail_exprs_stack, + tree (*simplify) (gimple, gimple, + class avail_exprs_stack *)) { bitmap visited = BITMAP_ALLOC (NULL); bool backedge_seen; @@ -1376,7 +1396,9 @@ thread_across_edge (gcond *dummy_cond, int threaded = thread_through_normal_block (e, dummy_cond, handle_dominating_asserts, - const_and_copies, simplify, path, + const_and_copies, + avail_exprs_stack, + simplify, path, visited, &backedge_seen); if (threaded > 0) { @@ -1467,6 +1489,7 @@ thread_across_edge (gcond *dummy_cond, simplify = dummy_simplify; found = thread_around_empty_blocks (taken_edge, dummy_cond, + avail_exprs_stack, handle_dominating_asserts, simplify, visited, @@ -1479,7 +1502,9 @@ thread_across_edge (gcond *dummy_cond, if (!found) found = thread_through_normal_block (path->last ()->e, dummy_cond, handle_dominating_asserts, - const_and_copies, simplify, path, + const_and_copies, + avail_exprs_stack, + simplify, path, visited, &backedge_seen) > 0; /* If we were able to thread through a successor of E->dest, then diff --git a/gcc/tree-ssa-threadedge.h b/gcc/tree-ssa-threadedge.h index 0def2e0103f..023b0f791d9 100644 --- a/gcc/tree-ssa-threadedge.h +++ b/gcc/tree-ssa-threadedge.h @@ -33,6 +33,6 @@ extern void propagate_threaded_block_debug_into (basic_block, basic_block); extern void thread_across_edge (gcond *, edge, bool, const_and_copies *, avail_exprs_stack *, - tree (*) (gimple, gimple)); + tree (*) (gimple, gimple, avail_exprs_stack *)); #endif /* GCC_TREE_SSA_THREADEDGE_H */ diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 5e813906ac7..cfb832916e4 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -10066,7 +10066,8 @@ const_and_copies *equiv_stack; for any overflow warnings. */ static tree -simplify_stmt_for_jump_threading (gimple stmt, gimple within_stmt) +simplify_stmt_for_jump_threading (gimple stmt, gimple within_stmt, + class avail_exprs_stack *avail_exprs_stack ATTRIBUTE_UNUSED) { if (gcond *cond_stmt = dyn_cast (stmt)) return vrp_evaluate_conditional (gimple_cond_code (cond_stmt), -- 2.30.2