On 12/10/15 16:49, Tom de Vries wrote:
Hi,
I've committed the following patch series to the gomp-4_0-branch.
1 Add pass_dominator::jump_threading_p ()
2 Add dom_walker::walk_until
3 Add pass_dominator::sese_mode_p ()
4 Add skip_stmt parm to pass_dominator::get_sese ()
5 Add oacc kernels related infra functions
6 Add pass_dominator_oacc_kernels
The patch series adds a pass pass_dominator_oacc_kernels, which does the
pass_dominator optimizations (with the exception of jump threading) on
each oacc kernels region rather than on the whole function.
Bootstrapped and reg-tested on x86_64.
I'll post the patches individually, in reply to this email.
This patch adds the possibility to pass_dominators to switch off the
jump threading optimization.
Note that we do not disable threadedge_initialize_values /
threadedge_finalize_values, since the values stored there are used for
other optimizations as well.
Thanks,
- Tom
Add pass_dominator::jump_threading_p ()
2015-10-12 Tom de Vries <t...@codesourcery.com>
* tree-ssa-dom.c (dom_opt_dom_walker::dom_opt_dom_walker): Add
jump_threading_p parameters.
(dom_opt_dom_walker::m_jump_threading_p): New private var.
(pass_dominator::jump_threading_p): New protected virtual function.
(pass_dominator::execute): Handle jump_threading_p.
(dom_opt_dom_walker::before_dom_children)
(dom_opt_dom_walker::after_dom_children): Handle m_jump_threading_p.
---
gcc/tree-ssa-dom.c | 109 +++++++++++++++++++++++++++++++----------------------
1 file changed, 64 insertions(+), 45 deletions(-)
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index a8b7038..162d9ed 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -492,11 +492,14 @@ class dom_opt_dom_walker : public dom_walker
public:
dom_opt_dom_walker (cdi_direction direction,
class const_and_copies *const_and_copies,
- class avail_exprs_stack *avail_exprs_stack)
+ class avail_exprs_stack *avail_exprs_stack,
+ bool jump_threading_p)
: dom_walker (direction),
m_const_and_copies (const_and_copies),
m_avail_exprs_stack (avail_exprs_stack),
- m_dummy_cond (NULL) {}
+ m_dummy_cond (NULL),
+ m_jump_threading_p (jump_threading_p)
+ {}
virtual void before_dom_children (basic_block);
virtual void after_dom_children (basic_block);
@@ -509,6 +512,7 @@ private:
class avail_exprs_stack *m_avail_exprs_stack;
gcond *m_dummy_cond;
+ bool m_jump_threading_p;
};
/* Jump threading, redundancy elimination and const/copy propagation.
@@ -544,6 +548,10 @@ public:
virtual bool gate (function *) { return flag_tree_dom != 0; }
virtual unsigned int execute (function *);
+ protected:
+ /* Return true if pass should perform jump threading. */
+ virtual bool jump_threading_p (void) { return true; }
+
}; // class pass_dominator
unsigned int
@@ -578,25 +586,29 @@ pass_dominator::execute (function *fun)
/* Initialize the value-handle array. */
threadedge_initialize_values ();
- /* We need accurate information regarding back edges in the CFG
- for jump threading; this may include back edges that are not part of
- a single loop. */
- mark_dfs_back_edges ();
-
- /* We want to create the edge info structures before the dominator walk
- so that they'll be in place for the jump threader, particularly when
- threading through a join block.
-
- The conditions will be lazily updated with global equivalences as
- we reach them during the dominator walk. */
- basic_block bb;
- FOR_EACH_BB_FN (bb, fun)
- record_edge_info (bb);
+ if (jump_threading_p ())
+ {
+ /* We need accurate information regarding back edges in the CFG
+ for jump threading; this may include back edges that are not part of
+ a single loop. */
+ mark_dfs_back_edges ();
+
+ /* We want to create the edge info structures before the dominator walk
+ so that they'll be in place for the jump threader, particularly when
+ threading through a join block.
+
+ The conditions will be lazily updated with global equivalences as
+ we reach them during the dominator walk. */
+ basic_block bb;
+ FOR_EACH_BB_FN (bb, fun)
+ record_edge_info (bb);
+ }
/* Recursively walk the dominator tree optimizing statements. */
dom_opt_dom_walker walker (CDI_DOMINATORS,
const_and_copies,
- avail_exprs_stack);
+ avail_exprs_stack,
+ jump_threading_p ());
walker.walk (fun->cfg->x_entry_block_ptr);
{
@@ -616,10 +628,13 @@ pass_dominator::execute (function *fun)
duplication and CFG manipulation. */
update_ssa (TODO_update_ssa);
- free_all_edge_infos ();
+ if (jump_threading_p ())
+ {
+ free_all_edge_infos ();
- /* Thread jumps, creating duplicate blocks as needed. */
- cfg_altered |= thread_through_all_blocks (first_pass_instance);
+ /* Thread jumps, creating duplicate blocks as needed. */
+ cfg_altered |= thread_through_all_blocks (first_pass_instance);
+ }
if (cfg_altered)
free_dominance_info (CDI_DOMINATORS);
@@ -1314,7 +1329,8 @@ dom_opt_dom_walker::before_dom_children (basic_block bb)
optimize_stmt (bb, gsi, m_const_and_copies, m_avail_exprs_stack);
/* Now prepare to process dominated blocks. */
- record_edge_info (bb);
+ if (m_jump_threading_p)
+ record_edge_info (bb);
cprop_into_successor_phis (bb, m_const_and_copies);
}
@@ -1327,35 +1343,38 @@ dom_opt_dom_walker::after_dom_children (basic_block bb)
{
gimple *last;
- /* If we have an outgoing edge to a block with multiple incoming and
- outgoing edges, then we may be able to thread the edge, i.e., we
- may be able to statically determine which of the outgoing edges
- will be traversed when the incoming edge from BB is traversed. */
- if (single_succ_p (bb)
- && (single_succ_edge (bb)->flags & EDGE_ABNORMAL) == 0
- && potentially_threadable_block (single_succ (bb)))
- {
- thread_across_edge (single_succ_edge (bb));
- }
- else if ((last = last_stmt (bb))
- && gimple_code (last) == GIMPLE_COND
- && EDGE_COUNT (bb->succs) == 2
- && (EDGE_SUCC (bb, 0)->flags & EDGE_ABNORMAL) == 0
- && (EDGE_SUCC (bb, 1)->flags & EDGE_ABNORMAL) == 0)
+ if (m_jump_threading_p)
{
- edge true_edge, false_edge;
+ /* If we have an outgoing edge to a block with multiple incoming and
+ outgoing edges, then we may be able to thread the edge, i.e., we
+ may be able to statically determine which of the outgoing edges
+ will be traversed when the incoming edge from BB is traversed. */
+ if (single_succ_p (bb)
+ && (single_succ_edge (bb)->flags & EDGE_ABNORMAL) == 0
+ && potentially_threadable_block (single_succ (bb)))
+ {
+ thread_across_edge (single_succ_edge (bb));
+ }
+ else if ((last = last_stmt (bb))
+ && gimple_code (last) == GIMPLE_COND
+ && EDGE_COUNT (bb->succs) == 2
+ && (EDGE_SUCC (bb, 0)->flags & EDGE_ABNORMAL) == 0
+ && (EDGE_SUCC (bb, 1)->flags & EDGE_ABNORMAL) == 0)
+ {
+ edge true_edge, false_edge;
- extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
+ extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
- /* Only try to thread the edge if it reaches a target block with
- more than one predecessor and more than one successor. */
- if (potentially_threadable_block (true_edge->dest))
- thread_across_edge (true_edge);
+ /* Only try to thread the edge if it reaches a target block with
+ more than one predecessor and more than one successor. */
+ if (potentially_threadable_block (true_edge->dest))
+ thread_across_edge (true_edge);
- /* Similarly for the ELSE arm. */
- if (potentially_threadable_block (false_edge->dest))
- thread_across_edge (false_edge);
+ /* Similarly for the ELSE arm. */
+ if (potentially_threadable_block (false_edge->dest))
+ thread_across_edge (false_edge);
+ }
}
/* These remove expressions local to BB from the tables. */
--
1.9.1
