Skip to content

R
riscv-gcc-1
Commit 8e33db8f by Jeff Law Committed by Jeff Law
Options

[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
parent 8788ec94
Showing with 153 additions and 75 deletions
gcc/ChangeLog
2015-09-18 Jeff Law <law@redhat.com>
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 ...
(dom_opt_dom_walker): New private member holding the const_and_copies
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;
......
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
......
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 */
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),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment