This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] avail_expr_stack is no longer file scoped
- From: Suzanne & Jeff <suzanne dot jeff dot law at gmail dot com>
- To: gcc-patches <gcc-patches at gcc dot gnu dot org>
- Date: Fri, 18 Sep 2015 20:56:54 -0600
- Subject: [PATCH] avail_expr_stack is no longer file scoped
- Authentication-results: sourceware.org; auth=none
Similar to the previous patch, except this time working on
avail_expr_stack. It's a bit more complex because tree-ssa-threadedge.c
calls back into lookup_avail_expr, so we need to get avail_expr_stack
passed around in there too. But we were going to need to do that anyway.
I believe this is the last required piece of infrastructure to fix
47679. The actual remaining patch for 47679 is trivial ;-)
Bootstrapped & regression tested on x86-linux-gnu. Installed on the trunk.
jeff
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.
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index fd2566c..936af99 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -78,9 +78,6 @@ struct edge_info
vec<cond_equivalence> 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<expr_elt_hasher> *);
@@ -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<expr_elt_hasher> *avail_exprs
= new hash_table<expr_elt_hasher> (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 48c4ca7..ba25e07 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<tree> 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<jump_thread_edge *> *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<jump_thread_edge *> *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 0def2e0..023b0f7 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 5e81390..cfb8329 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 <gcond *> (stmt))
return vrp_evaluate_conditional (gimple_cond_code (cond_stmt),