CbC/CbC_gcc: gcc/dominance.c comparison

comparison gcc/dominance.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 return (basic_block) node->father->data;
 }
 /* Set the immediate dominator of the block possibly removing
 existing edge.  NULL can be used to remove any edge.  */
-inline void
+void
 set_immediate_dominator (enum cdi_direction dir, basic_block bb,
 			 basic_block dominated_by)
 {
 unsigned int dir_index = dom_convert_dir_to_idx (dir);
 struct et_node *node = bb->dom[dir_index];
 gcc_assert (dom_computed[dir_index]);
 if (node->father)
 {
 if (node->father->data == dominated_by)
 /* Returns the list of basic blocks immediately dominated by BB, in the
 direction DIR.  */
 VEC (basic_block, heap) *
 get_dominated_by (enum cdi_direction dir, basic_block bb)
 {
-int n;
 unsigned int dir_index = dom_convert_dir_to_idx (dir);
 struct et_node *node = bb->dom[dir_index], *son = node->son, *ason;
 VEC (basic_block, heap) *bbs = NULL;
 gcc_assert (dom_computed[dir_index]);
 if (!son)
 return NULL;
 VEC_safe_push (basic_block, heap, bbs, (basic_block) son->data);
-for (ason = son->right, n = 1; ason != son; ason = ason->right)
+for (ason = son->right; ason != son; ason = ason->right)
 VEC_safe_push (basic_block, heap, bbs, (basic_block) ason->data);
 return bbs;
 }
 /* Returns the list of basic blocks that are immediately dominated (in
 direction DIR) by some block between N_REGION ones stored in REGION,
 except for blocks in the REGION itself.  */
 VEC (basic_block, heap) *
 get_dominated_by_region (enum cdi_direction dir, basic_block *region,
 			 unsigned n_region)
 {
 unsigned i;
 region[i]->flags &= ~BB_DUPLICATED;
 return doms;
 }
+/* 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)
+{
+VEC(basic_block, heap) *bbs = NULL;
+unsigned i;
+i = 0;
+VEC_safe_push (basic_block, heap, bbs, bb);
+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));
+return bbs;
+}
 /* Redirect all edges pointing to BB to TO.  */
 void
 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
 			       basic_block to)
 {
 unsigned int dir_index = dom_convert_dir_to_idx (dir);
 struct et_node *bb_node, *to_node, *son;
 bb_node = bb->dom[dir_index];
 to_node = to->dom[dir_index];
 gcc_assert (dom_computed[dir_index]);
 nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
 {
 unsigned i, first;
 bitmap_iterator bi;
 basic_block dom;
 first = bitmap_first_set_bit (blocks);
 dom = BASIC_BLOCK (first);
 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
 if (dom != BASIC_BLOCK (i))
 dom = nearest_common_dominator (dir, dom, BASIC_BLOCK (i));
 2. The number for when we visit a node on the way back up the tree
 You can view these as bounds for the range of dfs numbers the
 nodes in the subtree of the dominator tree rooted at that node
 will contain.
 The dominator tree is always a simple acyclic tree, so there are
 only three possible relations two nodes in the dominator tree have
 to each other:
 1. Node A is above Node B (and thus, Node A dominates node B)
 A
 |
 C
 In the above case, DFS_Number_In of A will be <= DFS_Number_In of
 B, and DFS_Number_Out of A will be >= DFS_Number_Out of B.  This is
 because we must hit A in the dominator tree *before* B on the walk
 down, and we will hit A *after* B on the walk back up
 2. Node A is below node B (and thus, node B dominates node A)
 B
 |
 A
 / \
 C   D
 In the above case, DFS_Number_In of A will be >= DFS_Number_In of
 B, and DFS_Number_Out of A will be <= DFS_Number_Out of B.
 This is because we must hit A in the dominator tree *after* B on
 the walk down, and we will hit A *before* B on the walk back up
 3. Node A and B are siblings (and thus, neither dominates the other)
 C
 |
 D
 Thus, it is sufficient to write
 A_Dominates_B (node A, node B)
 {
 return DFS_Number_In(A) <= DFS_Number_In(B)
 && DFS_Number_Out (A) >= DFS_Number_Out(B);
 }
 A_Dominated_by_B (node A, node B)
 {
 }  */
 /* Return TRUE in case BB1 is dominated by BB2.  */
 bool
 dominated_by_p (enum cdi_direction dir, const_basic_block bb1, const_basic_block bb2)
 {
 unsigned int dir_index = dom_convert_dir_to_idx (dir);
 struct et_node *n1 = bb1->dom[dir_index], *n2 = bb2->dom[dir_index];
 gcc_assert (dom_computed[dir_index]);
 if (dom_computed[dir_index] == DOM_OK)
 return (n1->dfs_num_in >= n2->dfs_num_in
 	    && n1->dfs_num_out <= n2->dfs_num_out);
 gcc_assert (dom_computed[dir_index]);
 gcc_assert (!bb->dom[dir_index]);
 n_bbs_in_dom_tree[dir_index]++;
 bb->dom[dir_index] = et_new_tree (bb);
 if (dom_computed[dir_index] == DOM_OK)
 dom_computed[dir_index] = DOM_NO_FAST_QUERY;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/dominance.c @ 55:77e2b8dfacca gcc-4.4.5