From d2552094b8c0a8aaa92d831ee3de2a72cc20d642 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 27 Sep 2017 11:09:41 +0000 Subject: invoke.texi (graphite-max-bbs-per-function): Remove. 2017-09-27 Richard Biener * doc/invoke.texi (graphite-max-bbs-per-function): Remove. (graphite-max-nb-scop-params): Document special value zero. * domwalk.h (dom_walker::STOP): New symbolical constant. (dom_walker::dom_walker): Add optional parameter for bb to RPO mapping. (dom_walker::~dom_walker): Declare. (dom_walker::before_dom_children): Document STOP return value. (dom_walker::m_user_bb_to_rpo): New member. (dom_walker::m_bb_to_rpo): Likewise. * domwalk.c (dom_walker::dom_walker): Compute bb to RPO mapping here if not provided by the user. (dom_walker::~dom_walker): Free bb to RPO mapping if not provided by the user. (dom_walker::STOP): Define. (dom_walker::walk): Do not compute bb to RPO mapping here. Support STOP return value from before_dom_children to stop walking. * graphite-optimize-isl.c (optimize_isl): If the schedule is the same still generate code if -fgraphite-identity or -floop-parallelize-all are given. * graphite-scop-detection.c: Include cfganal.h. (gather_bbs::gather_bbs): Get and pass through bb to RPO mapping. (gather_bbs::before_dom_children): Return STOP for BBs not in the region. (build_scops): Compute bb to RPO mapping and pass it to the domwalk. Treat --param graphite-max-nb-scop-params=0 as not limiting the number of params. * graphite.c (graphite_initialize): Remove limit on the number of basic-blocks in a function. * params.def (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION): Remove. (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS): Adjust to documented default value of 10. From-SVN: r253226 --- gcc/domwalk.c | 72 +++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 45 insertions(+), 27 deletions(-) (limited to 'gcc/domwalk.c') diff --git a/gcc/domwalk.c b/gcc/domwalk.c index ff6604e5686..102a2936ba4 100644 --- a/gcc/domwalk.c +++ b/gcc/domwalk.c @@ -174,13 +174,29 @@ sort_bbs_postorder (basic_block *bbs, int n) If SKIP_UNREACHBLE_BLOCKS is true, then we need to set EDGE_EXECUTABLE on every edge in the CFG. */ dom_walker::dom_walker (cdi_direction direction, - bool skip_unreachable_blocks) + bool skip_unreachable_blocks, + int *bb_index_to_rpo) : m_dom_direction (direction), m_skip_unreachable_blocks (skip_unreachable_blocks), - m_unreachable_dom (NULL) + m_user_bb_to_rpo (bb_index_to_rpo != NULL), + m_unreachable_dom (NULL), + m_bb_to_rpo (bb_index_to_rpo) { + /* Compute the basic-block index to RPO mapping if not provided by + the user. */ + if (! m_bb_to_rpo && direction == CDI_DOMINATORS) + { + int *postorder = XNEWVEC (int, n_basic_blocks_for_fn (cfun)); + int postorder_num = pre_and_rev_post_order_compute (NULL, postorder, + true); + m_bb_to_rpo = XNEWVEC (int, last_basic_block_for_fn (cfun)); + for (int i = 0; i < postorder_num; ++i) + m_bb_to_rpo[postorder[i]] = i; + free (postorder); + } + /* If we are not skipping unreachable blocks, then there is nothing - to do. */ + further to do. */ if (!m_skip_unreachable_blocks) return; @@ -194,6 +210,14 @@ dom_walker::dom_walker (cdi_direction direction, } } +/* Destructor. */ + +dom_walker::~dom_walker () +{ + if (! m_user_bb_to_rpo) + free (m_bb_to_rpo); +} + /* Return TRUE if BB is reachable, false otherwise. */ bool @@ -254,6 +278,8 @@ dom_walker::propagate_unreachable_to_edges (basic_block bb, m_unreachable_dom = bb; } +const edge dom_walker::STOP = (edge)-1; + /* Recursively walk the dominator tree. BB is the basic block we are currently visiting. */ @@ -264,17 +290,7 @@ dom_walker::walk (basic_block bb) basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun) * 2); int sp = 0; - int *postorder, postorder_num; - - if (m_dom_direction == CDI_DOMINATORS) - { - postorder = XNEWVEC (int, n_basic_blocks_for_fn (cfun)); - postorder_num = pre_and_rev_post_order_compute (NULL, postorder, true); - bb_postorder = XNEWVEC (int, last_basic_block_for_fn (cfun)); - for (int i = 0; i < postorder_num; ++i) - bb_postorder[postorder[i]] = i; - free (postorder); - } + bb_postorder = m_bb_to_rpo; while (true) { @@ -283,13 +299,14 @@ dom_walker::walk (basic_block bb) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun) || bb == EXIT_BLOCK_PTR_FOR_FN (cfun)) { + edge taken_edge = NULL; /* Callback for subclasses to do custom things before we have walked the dominator children, but before we walk statements. */ if (this->bb_reachable (cfun, bb)) { - edge taken_edge = before_dom_children (bb); - if (taken_edge) + taken_edge = before_dom_children (bb); + if (taken_edge && taken_edge != STOP) { edge_iterator ei; edge e; @@ -306,12 +323,17 @@ dom_walker::walk (basic_block bb) worklist[sp++] = bb; worklist[sp++] = NULL; - int saved_sp = sp; - for (dest = first_dom_son (m_dom_direction, bb); - dest; dest = next_dom_son (m_dom_direction, dest)) - worklist[sp++] = dest; - if (sp - saved_sp > 1 && m_dom_direction == CDI_DOMINATORS) - sort_bbs_postorder (&worklist[saved_sp], sp - saved_sp); + /* If the callback returned NONE then we are supposed to + stop and not even propagate EDGE_EXECUTABLE further. */ + if (taken_edge != STOP) + { + int saved_sp = sp; + for (dest = first_dom_son (m_dom_direction, bb); + dest; dest = next_dom_son (m_dom_direction, dest)) + worklist[sp++] = dest; + if (sp - saved_sp > 1 && m_dom_direction == CDI_DOMINATORS) + sort_bbs_postorder (&worklist[saved_sp], sp - saved_sp); + } } /* NULL is used to mark pop operations in the recursion stack. */ while (sp > 0 && !worklist[sp - 1]) @@ -331,10 +353,6 @@ dom_walker::walk (basic_block bb) else break; } - if (m_dom_direction == CDI_DOMINATORS) - { - free (bb_postorder); - bb_postorder = NULL; - } + bb_postorder = NULL; free (worklist); } -- cgit v1.2.3