CbC/CbC_gcc: gcc/dominance.c comparison

comparison gcc/dominance.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "tm.h"
 #include "rtl.h"
 #include "hard-reg-set.h"
 #include "obstack.h"
 #include "basic-block.h"
-#include "toplev.h"
+#include "diagnostic-core.h"
 #include "et-forest.h"
 #include "timevar.h"
 #include "vecprim.h"
 #include "pointer-set.h"
 #include "graphds.h"
 return doms;
 }
 /* Returns the list of basic blocks including BB dominated by BB, in the
-direction DIR.  The vector will be sorted in preorder.  */
+direction DIR up to DEPTH in the dominator tree.  The DEPTH of zero will
+produce a vector containing all dominated blocks.  The vector will be sorted
+in preorder.  */
 VEC (basic_block, heap) *
-get_all_dominated_blocks (enum cdi_direction dir, basic_block bb)
+get_dominated_to_depth (enum cdi_direction dir, basic_block bb, int depth)
 {
 VEC(basic_block, heap) *bbs = NULL;
 unsigned i;
+unsigned next_level_start;
 i = 0;
 VEC_safe_push (basic_block, heap, bbs, bb);
+next_level_start = 1; /* = VEC_length (basic_block, bbs); */
 do
 {
 basic_block son;
 bb = VEC_index (basic_block, bbs, i++);
 for (son = first_dom_son (dir, bb);
 	   son;
 	   son = next_dom_son (dir, son))
 	VEC_safe_push (basic_block, heap, bbs, son);
-}
-while (i < VEC_length (basic_block, bbs));
+if (i == next_level_start && --depth)
+	next_level_start = VEC_length (basic_block, bbs);
+}
+while (i < next_level_start);
 return bbs;
+}
+/* Returns the list of basic blocks including BB dominated by BB, in the
+direction DIR.  The vector will be sorted in preorder.  */
+VEC (basic_block, heap) *
+get_all_dominated_blocks (enum cdi_direction dir, basic_block bb)
+{
+return get_dominated_to_depth (dir, bb, 0);
 }
 /* Redirect all edges pointing to BB to TO.  */
 void
 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
 gcc_assert (dom_computed[dir_index] == DOM_OK);
 return n->dfs_num_out;
 }
 /* Verify invariants of dominator structure.  */
-void
+DEBUG_FUNCTION void
 verify_dominators (enum cdi_direction dir)
 {
 int err = 0;
 basic_block bb, imm_bb, imm_bb_correct;
 struct dom_info di;
 VEC_safe_push (int, heap, sccs[g->vertices[a].component], a);
 for (i = nc - 1; i >= 0; i--)
 {
 dom = NULL;
-for (si = 0; VEC_iterate (int, sccs[i], si, a); si++)
+FOR_EACH_VEC_ELT (int, sccs[i], si, a)
 	{
 	  bb = VEC_index (basic_block, bbs, a);
 	  FOR_EACH_EDGE (e, ei, bb->preds)
 	    {
 	      if (root_of_dom_tree (CDI_DOMINATORS, e->src) != ybb)
 	      dom = nearest_common_dominator (CDI_DOMINATORS, dom, e->src);
 	    }
 	}
 gcc_assert (dom != NULL);
-for (si = 0; VEC_iterate (int, sccs[i], si, a); si++)
+FOR_EACH_VEC_ELT (int, sccs[i], si, a)
 	{
 	  bb = VEC_index (basic_block, bbs, a);
 	  set_immediate_dominator (CDI_DOMINATORS, bb, dom);
 	}
 }
 {
 /* Split the tree now.  If the idoms of blocks in BBS are not
 	 conservatively correct, setting the dominators using the
 	 heuristics in prune_bbs_to_update_dominators could
 	 create cycles in the dominance "tree", and cause ICE.  */
-for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
+FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
 	set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
 }
 prune_bbs_to_update_dominators (bbs, conservative);
 n = VEC_length (basic_block, bbs);
 return;
 }
 /* Construct the graph G.  */
 map = pointer_map_create ();
-for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
+FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
 {
 /* If the dominance tree is conservatively correct, split it now.  */
 if (conservative)
 	set_immediate_dominator (CDI_DOMINATORS, bb, NULL);
 *pointer_map_insert (map, bb) = (void *) (size_t) i;
 *pointer_map_insert (map, ENTRY_BLOCK_PTR) = (void *) (size_t) n;
 g = new_graph (n + 1);
 for (y = 0; y < g->n_vertices; y++)
 g->vertices[y].data = BITMAP_ALLOC (NULL);
-for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)
+FOR_EACH_VEC_ELT (basic_block, bbs, i, bb)
 {
 FOR_EACH_EDGE (e, ei, bb->preds)
 	{
 	  dom = root_of_dom_tree (CDI_DOMINATORS, e->src);
 	  if (dom == bb)
 	    continue;
 	  dom_i = (size_t) *pointer_map_contains (map, dom);
 	  /* Do not include parallel edges to G.  */
-	  if (bitmap_bit_p ((bitmap) g->vertices[dom_i].data, i))
+	  if (!bitmap_set_bit ((bitmap) g->vertices[dom_i].data, i))
 	    continue;
-	  bitmap_set_bit ((bitmap) g->vertices[dom_i].data, i);
 	  add_edge (g, dom_i, i);
 	}
 }
 for (y = 0; y < g->n_vertices; y++)
 BITMAP_FREE (g->vertices[y].data);
 unsigned int dir_index = dom_convert_dir_to_idx (dir);
 return dom_computed[dir_index] != DOM_NONE;
 }
-void
+DEBUG_FUNCTION void
 debug_dominance_info (enum cdi_direction dir)
 {
 basic_block bb, bb2;
 FOR_EACH_BB (bb)
 if ((bb2 = get_immediate_dominator (dir, bb)))
 }
 /* Prints to stderr representation of the dominance tree (for direction DIR)
 rooted in ROOT.  */
-void
+DEBUG_FUNCTION void
 debug_dominance_tree (enum cdi_direction dir, basic_block root)
 {
 debug_dominance_tree_1 (dir, root, 0, false);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/dominance.c @ 67:f6334be47118