basic-block.h (cdi_direction): Assign values to all enumeration constants.

2007-05-04  Josh Conner  <jconner@apple.com>

	* basic-block.h (cdi_direction): Assign values to all enumeration
	constants.
	(dom_computed): Remove.
	(dom_info_state): New.
	(set_dom_info_availability): New.
	* tree-ssa-loop-im.c (determine_invariantness): Initialize
	walk_data.dom_direction.
	* cfghooks.c (delete_basic_block): Use dom_info_available_p()
	instead of dom_computed[].
	(split_edge): Likewise.
	(create_basic_block): Likewise.
	(merge_blocks): Likewise.
	* ifcvt.c (find_if_header): Likewise.
	* tree-cfgcleanup.c (cleanup_tree_cfg): Likewise.
	* tree-ssa-dce.c (remove_dead_stmt): Likewise.
	* tree-ssa.c (verify_ssa): Likewise.
	* tree-cfg.c (tree_verify_flow_info): Likewise.
	(remove_edge_and_dominated_blocks): Likewise.
	* dominance.c (dom_computed): Make static.
	(calc_dfs_tree_nonrec): Change third param to a bool.
	(calc_dfs_tree): Change second param to a bool.
	(calc_idioms): Change second param to a bool.  Use
	dom_convert_dir_to_idx.
	(init_dom_info): Validate dir before using.
	(dom_convert_dir_to_idx): New.
	(calculate_dominance_info): Use dom_convert_dir_to_idx.  New
	variable 'reverse' used for calling calc_dfs_tree and calc_idoms.
	(free_dominance_info): Use dom_convert_dir_to_idx.
	(get_immediate_dominator): Likewise.
	(set_immediate_dominator): Likewise.
	(get_dominated_by): Likewise.
	(redirect_immediate_dominators): Likewise.
	(nearest_common_denominator): Likewise.
	(dominated_by_p): Likewise.
	(bb_dom_dfs_in): Likewise.
	(bb_dom_dfs_out): Likewise.
	(recount_dominator): Likewise.
	(iterate_fix_dominators): Likewise.
	(add_to_dominance_info): Likewise.
	(delete_from_dominance_info): Likewise.
	(first_dom_son): Likewise.
	(next_dom_son): Likewise.
	(dom_info_available_p): Likewise.
	(dom_info_state): New.
	(set_dom_info_availability): New.

From-SVN: r124439

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 86cc306e240451ab61388ca969c84589c5f76c43..dd4beb2ad42474040257ab19026176aabf3b6a30 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,51 @@
+2007-05-04  Josh Conner  <jconner@apple.com>
+
+       * basic-block.h (cdi_direction): Assign values to all enumeration
+       constants.
+       (dom_computed): Remove.
+       (dom_info_state): New.
+       (set_dom_info_availability): New.
+       * tree-ssa-loop-im.c (determine_invariantness): Initialize
+       walk_data.dom_direction.
+       * cfghooks.c (delete_basic_block): Use dom_info_available_p()
+       instead of dom_computed[].
+       (split_edge): Likewise.
+       (create_basic_block): Likewise.
+       (merge_blocks): Likewise.
+       * ifcvt.c (find_if_header): Likewise.
+       * tree-cfgcleanup.c (cleanup_tree_cfg): Likewise.
+       * tree-ssa-dce.c (remove_dead_stmt): Likewise.
+       * tree-ssa.c (verify_ssa): Likewise.
+       * tree-cfg.c (tree_verify_flow_info): Likewise.
+       (remove_edge_and_dominated_blocks): Likewise.
+       * dominance.c (dom_computed): Make static.
+       (calc_dfs_tree_nonrec): Change third param to a bool.
+       (calc_dfs_tree): Change second param to a bool.
+       (calc_idioms): Change second param to a bool.  Use
+       dom_convert_dir_to_idx.
+       (init_dom_info): Validate dir before using.
+       (dom_convert_dir_to_idx): New.
+       (calculate_dominance_info): Use dom_convert_dir_to_idx.  New
+       variable 'reverse' used for calling calc_dfs_tree and calc_idoms.
+       (free_dominance_info): Use dom_convert_dir_to_idx.
+       (get_immediate_dominator): Likewise.
+       (set_immediate_dominator): Likewise.
+       (get_dominated_by): Likewise.
+       (redirect_immediate_dominators): Likewise.
+       (nearest_common_denominator): Likewise.
+       (dominated_by_p): Likewise.
+       (bb_dom_dfs_in): Likewise.
+       (bb_dom_dfs_out): Likewise.
+       (recount_dominator): Likewise.
+       (iterate_fix_dominators): Likewise.
+       (add_to_dominance_info): Likewise.
+       (delete_from_dominance_info): Likewise.
+       (first_dom_son): Likewise.
+       (next_dom_son): Likewise.
+       (dom_info_available_p): Likewise.
+       (dom_info_state): New.
+       (set_dom_info_availability): New.
+
 2007-05-04  Andreas Krebbel  <krebbel1@de.ibm.com>
 
        * config/s390/s390.md ("fix_trunc<mode>di2", "fix_trunc<mode>si2"):

diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index bfdec0e550ecd63c8951d24bfd5204df232be867..6286a5d1ed72cb0935b41f3ff1a0f5e28643e9d1 100644 (file)
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -936,8 +936,8 @@ extern void reorder_basic_blocks (void);
 
 enum cdi_direction
 {
-  CDI_DOMINATORS,
-  CDI_POST_DOMINATORS
+  CDI_DOMINATORS = 1,
+  CDI_POST_DOMINATORS = 2
 };
 
 enum dom_state
@@ -947,8 +947,8 @@ enum dom_state
   DOM_OK               /* Everything is ok.  */
 };
 
-extern enum dom_state dom_computed[2];
-
+extern enum dom_state dom_info_state (enum cdi_direction);
+extern void set_dom_info_availability (enum cdi_direction, enum dom_state);
 extern bool dom_info_available_p (enum cdi_direction);
 extern void calculate_dominance_info (enum cdi_direction);
 extern void free_dominance_info (enum cdi_direction);

diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 1fa3aa76498e2451c1245a0808720932fa597cf8..9e2eae75d492754164c507065f0e9d5d857f36ae 100644 (file)
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -486,9 +486,9 @@ delete_basic_block (basic_block bb)
   while (EDGE_COUNT (bb->succs) != 0)
     remove_edge (EDGE_SUCC (bb, 0));
 
-  if (dom_computed[CDI_DOMINATORS])
+  if (dom_info_available_p (CDI_DOMINATORS))
     delete_from_dominance_info (CDI_DOMINATORS, bb);
-  if (dom_computed[CDI_POST_DOMINATORS])
+  if (dom_info_available_p (CDI_POST_DOMINATORS))
     delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
 
   /* Remove the basic block from the array.  */
@@ -527,10 +527,10 @@ split_edge (edge e)
       single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
     }
 
-  if (dom_computed[CDI_DOMINATORS])
+  if (dom_info_available_p (CDI_DOMINATORS))
     set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret));
 
-  if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY)
+  if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
     {
       /* There are two cases:
 
@@ -586,9 +586,9 @@ create_basic_block (void *head, void *end, basic_block after)
 
   ret = cfg_hooks->create_basic_block (head, end, after);
 
-  if (dom_computed[CDI_DOMINATORS])
+  if (dom_info_available_p (CDI_DOMINATORS))
     add_to_dominance_info (CDI_DOMINATORS, ret);
-  if (dom_computed[CDI_POST_DOMINATORS])
+  if (dom_info_available_p (CDI_POST_DOMINATORS))
     add_to_dominance_info (CDI_POST_DOMINATORS, ret);
 
   return ret;
@@ -676,12 +676,12 @@ merge_blocks (basic_block a, basic_block b)
   /* B hasn't quite yet ceased to exist.  Attempt to prevent mishap.  */
   b->preds = b->succs = NULL;
 
-  if (dom_computed[CDI_DOMINATORS])
+  if (dom_info_available_p (CDI_DOMINATORS))
     redirect_immediate_dominators (CDI_DOMINATORS, b, a);
 
-  if (dom_computed[CDI_DOMINATORS])
+  if (dom_info_available_p (CDI_DOMINATORS))
     delete_from_dominance_info (CDI_DOMINATORS, b);
-  if (dom_computed[CDI_POST_DOMINATORS])
+  if (dom_info_available_p (CDI_POST_DOMINATORS))
     delete_from_dominance_info (CDI_POST_DOMINATORS, b);
 
   expunge_block (b);

diff --git a/gcc/dominance.c b/gcc/dominance.c
index 819e7d450299d9214be7bc03cee85b5f777d6327..a9af9d52d15939adfebdabdfc4b57cfd82d5d854 100644 (file)
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -46,7 +46,7 @@
 #include "timevar.h"
 
 /* Whether the dominators and the postdominators are available.  */
-enum dom_state dom_computed[2];
+static enum dom_state dom_computed[2];
 
 /* We name our nodes with integers, beginning with 1.  Zero is reserved for
    'undefined' or 'end of list'.  The name of each node is given by the dfs
@@ -114,13 +114,12 @@ struct dom_info
 
 static void init_dom_info (struct dom_info *, enum cdi_direction);
 static void free_dom_info (struct dom_info *);
-static void calc_dfs_tree_nonrec (struct dom_info *, basic_block,
-                                 enum cdi_direction);
-static void calc_dfs_tree (struct dom_info *, enum cdi_direction);
+static void calc_dfs_tree_nonrec (struct dom_info *, basic_block, bool);
+static void calc_dfs_tree (struct dom_info *, bool);
 static void compress (struct dom_info *, TBB);
 static TBB eval (struct dom_info *, TBB);
 static void link_roots (struct dom_info *, TBB, TBB);
-static void calc_idoms (struct dom_info *, enum cdi_direction);
+static void calc_idoms (struct dom_info *, bool);
 void debug_dominance_info (enum cdi_direction);
 
 /* Keeps track of the*/
@@ -168,11 +167,34 @@ init_dom_info (struct dom_info *di, enum cdi_direction dir)
   di->dfsnum = 1;
   di->nodes = 0;
 
-  di->fake_exit_edge = dir ? BITMAP_ALLOC (NULL) : NULL;
+  switch (dir)
+    {
+      case CDI_DOMINATORS:
+       di->fake_exit_edge = NULL;
+       break;
+      case CDI_POST_DOMINATORS:
+       di->fake_exit_edge = BITMAP_ALLOC (NULL);
+       break;
+      default:
+       gcc_unreachable ();
+       break;
+    }
 }
 
 #undef init_ar
 
+/* Map dominance calculation type to array index used for various
+   dominance information arrays.  This version is simple -- it will need
+   to be modified, obviously, if additional values are added to
+   cdi_direction.  */
+
+static unsigned int
+dom_convert_dir_to_idx (enum cdi_direction dir)
+{
+  gcc_assert (dir == CDI_DOMINATORS || dir == CDI_POST_DOMINATORS);
+  return dir - 1;
+}
+
 /* Free all allocated memory in DI, but not DI itself.  */
 
 static void
@@ -199,8 +221,7 @@ free_dom_info (struct dom_info *di)
    assigned their dfs number and are linked together to form a tree.  */
 
 static void
-calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb,
-                     enum cdi_direction reverse)
+calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
 {
   /* We call this _only_ if bb is not already visited.  */
   edge e;
@@ -311,7 +332,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb,
    because there may be nodes from which the EXIT_BLOCK is unreachable.  */
 
 static void
-calc_dfs_tree (struct dom_info *di, enum cdi_direction reverse)
+calc_dfs_tree (struct dom_info *di, bool reverse)
 {
   /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE).  */
   basic_block begin = reverse ? EXIT_BLOCK_PTR : ENTRY_BLOCK_PTR;
@@ -471,7 +492,7 @@ link_roots (struct dom_info *di, TBB v, TBB w)
    On return the immediate dominator to node V is in di->dom[V].  */
 
 static void
-calc_idoms (struct dom_info *di, enum cdi_direction reverse)
+calc_idoms (struct dom_info *di, bool reverse)
 {
   TBB v, w, k, par;
   basic_block en_block;
@@ -590,19 +611,20 @@ compute_dom_fast_query (enum cdi_direction dir)
 {
   int num = 0;
   basic_block bb;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
 
   gcc_assert (dom_info_available_p (dir));
 
-  if (dom_computed[dir] == DOM_OK)
+  if (dom_computed[dir_index] == DOM_OK)
     return;
 
   FOR_ALL_BB (bb)
     {
-      if (!bb->dom[dir]->father)
-       assign_dfs_numbers (bb->dom[dir], &num);
+      if (!bb->dom[dir_index]->father)
+       assign_dfs_numbers (bb->dom[dir_index], &num);
     }
 
-  dom_computed[dir] = DOM_OK;
+  dom_computed[dir_index] = DOM_OK;
 }
 
 /* The main entry point into this module.  DIR is set depending on whether
@@ -613,35 +635,37 @@ calculate_dominance_info (enum cdi_direction dir)
 {
   struct dom_info di;
   basic_block b;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  bool reverse = (dir == CDI_POST_DOMINATORS) ? true : false;
 
-  if (dom_computed[dir] == DOM_OK)
+  if (dom_computed[dir_index] == DOM_OK)
     return;
 
   timevar_push (TV_DOMINANCE);
   if (!dom_info_available_p (dir))
     {
-      gcc_assert (!n_bbs_in_dom_tree[dir]);
+      gcc_assert (!n_bbs_in_dom_tree[dir_index]);
 
       FOR_ALL_BB (b)
        {
-         b->dom[dir] = et_new_tree (b);
+         b->dom[dir_index] = et_new_tree (b);
        }
-      n_bbs_in_dom_tree[dir] = n_basic_blocks;
+      n_bbs_in_dom_tree[dir_index] = n_basic_blocks;
 
       init_dom_info (&di, dir);
-      calc_dfs_tree (&di, dir);
-      calc_idoms (&di, dir);
+      calc_dfs_tree (&di, reverse);
+      calc_idoms (&di, reverse);
 
       FOR_EACH_BB (b)
        {
          TBB d = di.dom[di.dfs_order[b->index]];
 
          if (di.dfs_to_bb[d])
-           et_set_father (b->dom[dir], di.dfs_to_bb[d]->dom[dir]);
+           et_set_father (b->dom[dir_index], di.dfs_to_bb[d]->dom[dir_index]);
        }
 
       free_dom_info (&di);
-      dom_computed[dir] = DOM_NO_FAST_QUERY;
+      dom_computed[dir_index] = DOM_NO_FAST_QUERY;
     }
 
   compute_dom_fast_query (dir);
@@ -654,29 +678,31 @@ void
 free_dominance_info (enum cdi_direction dir)
 {
   basic_block bb;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
 
   if (!dom_info_available_p (dir))
     return;
 
   FOR_ALL_BB (bb)
     {
-      et_free_tree_force (bb->dom[dir]);
-      bb->dom[dir] = NULL;
+      et_free_tree_force (bb->dom[dir_index]);
+      bb->dom[dir_index] = NULL;
     }
   et_free_pools ();
 
-  n_bbs_in_dom_tree[dir] = 0;
+  n_bbs_in_dom_tree[dir_index] = 0;
 
-  dom_computed[dir] = DOM_NONE;
+  dom_computed[dir_index] = DOM_NONE;
 }
 
 /* Return the immediate dominator of basic block BB.  */
 basic_block
 get_immediate_dominator (enum cdi_direction dir, basic_block bb)
 {
-  struct et_node *node = bb->dom[dir];
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  struct et_node *node = bb->dom[dir_index];
 
-  gcc_assert (dom_computed[dir]);
+  gcc_assert (dom_computed[dir_index]);
 
   if (!node->father)
     return NULL;
@@ -690,9 +716,10 @@ inline void
 set_immediate_dominator (enum cdi_direction dir, basic_block bb,
                         basic_block dominated_by)
 {
-  struct et_node *node = bb->dom[dir];
-
-  gcc_assert (dom_computed[dir]);
+  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)
     {
@@ -702,10 +729,10 @@ set_immediate_dominator (enum cdi_direction dir, basic_block bb,
     }
 
   if (dominated_by)
-    et_set_father (node, dominated_by->dom[dir]);
+    et_set_father (node, dominated_by->dom[dir_index]);
 
-  if (dom_computed[dir] == DOM_OK)
-    dom_computed[dir] = DOM_NO_FAST_QUERY;
+  if (dom_computed[dir_index] == DOM_OK)
+    dom_computed[dir_index] = DOM_NO_FAST_QUERY;
 }
 
 /* Store all basic blocks immediately dominated by BB into BBS and return
@@ -713,10 +740,11 @@ set_immediate_dominator (enum cdi_direction dir, basic_block bb,
 int
 get_dominated_by (enum cdi_direction dir, basic_block bb, basic_block **bbs)
 {
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
   int n;
-  struct et_node *node = bb->dom[dir], *son = node->son, *ason;
-
-  gcc_assert (dom_computed[dir]);
+  struct et_node *node = bb->dom[dir_index], *son = node->son, *ason;
+ 
+  gcc_assert (dom_computed[dir_index]);
 
   if (!son)
     {
@@ -766,9 +794,13 @@ void
 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
                               basic_block to)
 {
-  struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
+  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]);
+  gcc_assert (dom_computed[dir_index]);
 
   if (!bb_node->son)
     return;
@@ -781,22 +813,24 @@ redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
       et_set_father (son, to_node);
     }
 
-  if (dom_computed[dir] == DOM_OK)
-    dom_computed[dir] = DOM_NO_FAST_QUERY;
+  if (dom_computed[dir_index] == DOM_OK)
+    dom_computed[dir_index] = DOM_NO_FAST_QUERY;
 }
 
 /* Find first basic block in the tree dominating both BB1 and BB2.  */
 basic_block
 nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 {
-  gcc_assert (dom_computed[dir]);
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+
+  gcc_assert (dom_computed[dir_index]);
 
   if (!bb1)
     return bb2;
   if (!bb2)
     return bb1;
 
-  return et_nca (bb1->dom[dir], bb2->dom[dir])->data;
+  return et_nca (bb1->dom[dir_index], bb2->dom[dir_index])->data;
 }
 
 
@@ -898,11 +932,12 @@ nearest_common_dominator_for_set (enum cdi_direction dir, bitmap blocks)
 bool
 dominated_by_p (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 { 
-  struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
-
-  gcc_assert (dom_computed[dir]);
+  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] == DOM_OK)
+  if (dom_computed[dir_index] == DOM_OK)
     return (n1->dfs_num_in >= n2->dfs_num_in
            && n1->dfs_num_out <= n2->dfs_num_out);
 
@@ -914,9 +949,10 @@ dominated_by_p (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 unsigned
 bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
 {
-  struct et_node *n = bb->dom[dir];
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  struct et_node *n = bb->dom[dir_index];
 
-  gcc_assert (dom_computed[dir] == DOM_OK);
+  gcc_assert (dom_computed[dir_index] == DOM_OK);
   return n->dfs_num_in;
 }
 
@@ -925,9 +961,10 @@ bb_dom_dfs_in (enum cdi_direction dir, basic_block bb)
 unsigned
 bb_dom_dfs_out (enum cdi_direction dir, basic_block bb)
 {
-  struct et_node *n = bb->dom[dir];
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  struct et_node *n = bb->dom[dir_index];
 
-  gcc_assert (dom_computed[dir] == DOM_OK);
+  gcc_assert (dom_computed[dir_index] == DOM_OK);
   return n->dfs_num_out;
 }
 
@@ -981,11 +1018,12 @@ verify_dominators (enum cdi_direction dir)
 basic_block
 recount_dominator (enum cdi_direction dir, basic_block bb)
 {
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
   basic_block dom_bb = NULL;
   edge e;
   edge_iterator ei;
 
-  gcc_assert (dom_computed[dir]);
+  gcc_assert (dom_computed[dir_index]);
 
   if (dir == CDI_DOMINATORS)
     {
@@ -1017,10 +1055,11 @@ recount_dominator (enum cdi_direction dir, basic_block bb)
 void
 iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
 {
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
   int i, changed = 1;
   basic_block old_dom, new_dom;
 
-  gcc_assert (dom_computed[dir]);
+  gcc_assert (dom_computed[dir_index]);
 
   for (i = 0; i < n; i++)
     set_immediate_dominator (dir, bbs[i], NULL);
@@ -1047,28 +1086,32 @@ iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
 void
 add_to_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  gcc_assert (dom_computed[dir]);
-  gcc_assert (!bb->dom[dir]);
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+
+  gcc_assert (dom_computed[dir_index]);
+  gcc_assert (!bb->dom[dir_index]);
 
-  n_bbs_in_dom_tree[dir]++;
+  n_bbs_in_dom_tree[dir_index]++;
   
-  bb->dom[dir] = et_new_tree (bb);
+  bb->dom[dir_index] = et_new_tree (bb);
 
-  if (dom_computed[dir] == DOM_OK)
-    dom_computed[dir] = DOM_NO_FAST_QUERY;
+  if (dom_computed[dir_index] == DOM_OK)
+    dom_computed[dir_index] = DOM_NO_FAST_QUERY;
 }
 
 void
 delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  gcc_assert (dom_computed[dir]);
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
 
-  et_free_tree (bb->dom[dir]);
-  bb->dom[dir] = NULL;
-  n_bbs_in_dom_tree[dir]--;
+  gcc_assert (dom_computed[dir_index]);
 
-  if (dom_computed[dir] == DOM_OK)
-    dom_computed[dir] = DOM_NO_FAST_QUERY;
+  et_free_tree (bb->dom[dir_index]);
+  bb->dom[dir_index] = NULL;
+  n_bbs_in_dom_tree[dir_index]--;
+
+  if (dom_computed[dir_index] == DOM_OK)
+    dom_computed[dir_index] = DOM_NO_FAST_QUERY;
 }
 
 /* Returns the first son of BB in the dominator or postdominator tree
@@ -1077,7 +1120,8 @@ delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
 basic_block
 first_dom_son (enum cdi_direction dir, basic_block bb)
 {
-  struct et_node *son = bb->dom[dir]->son;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  struct et_node *son = bb->dom[dir_index]->son;
 
   return son ? son->data : NULL;
 }
@@ -1088,17 +1132,40 @@ first_dom_son (enum cdi_direction dir, basic_block bb)
 basic_block
 next_dom_son (enum cdi_direction dir, basic_block bb)
 {
-  struct et_node *next = bb->dom[dir]->right;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+  struct et_node *next = bb->dom[dir_index]->right;
 
   return next->father->son == next ? NULL : next->data;
 }
 
+/* Return dominance availability for dominance info DIR.  */
+
+enum dom_state
+dom_info_state (enum cdi_direction dir)
+{
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+
+  return dom_computed[dir_index];
+}
+
+/* Set the dominance availability for dominance info DIR to NEW_STATE.  */
+
+void
+set_dom_info_availability (enum cdi_direction dir, enum dom_state new_state)
+{
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+
+  dom_computed[dir_index] = new_state;
+}
+
 /* Returns true if dominance information for direction DIR is available.  */
 
 bool
 dom_info_available_p (enum cdi_direction dir)
 {
-  return dom_computed[dir] != DOM_NONE;
+  unsigned int dir_index = dom_convert_dir_to_idx (dir);
+
+  return dom_computed[dir_index] != DOM_NONE;
 }
 
 void

diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index 4a993d3ee400c6cf44f8384cdc9a32415f67838c..64a897cc9edb15ac02a2d07f3cb4fceb36534296 100644 (file)
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -2932,7 +2932,7 @@ find_if_header (basic_block test_bb, int pass)
       && find_cond_trap (test_bb, then_edge, else_edge))
     goto success;
 
-  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY
+  if (dom_info_state (CDI_POST_DOMINATORS) >= DOM_NO_FAST_QUERY
       && (! HAVE_conditional_execution || reload_completed))
     {
       if (find_if_case_1 (test_bb, then_edge, else_edge))

diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index efe0a1cb0a1f0d77c6ca8e11b625cbc49359c232..0b0ed8675914fb5af09e48d0472ca4c2b6a7396e 100644 (file)
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -3865,7 +3865,7 @@ tree_verify_flow_info (void)
        }
     }
 
-  if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY)
+  if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
     verify_dominators (CDI_DOMINATORS);
 
   return err;
@@ -5375,7 +5375,7 @@ remove_edge_and_dominated_blocks (edge e)
   basic_block bb, dbb;
   bitmap_iterator bi;
 
-  if (!dom_computed[CDI_DOMINATORS])
+  if (!dom_info_available_p (CDI_DOMINATORS))
     {
       remove_edge (e);
       return;

diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index aaf6ce8ee268c97a1ab6cd83a46e595de617d0aa..1bf416ea76850411552dc8e10c00c27ff0ff0150 100644 (file)
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -609,7 +609,7 @@ cleanup_tree_cfg (void)
 
      If dominance information is available, there cannot be any unreachable
      blocks.  */
-  if (!dom_computed[CDI_DOMINATORS])
+  if (!dom_info_available_p (CDI_DOMINATORS))
     {
       changed = delete_unreachable_blocks ();
       calculate_dominance_info (CDI_DOMINATORS);
@@ -624,7 +624,7 @@ cleanup_tree_cfg (void)
 
   changed |= cleanup_tree_cfg_1 ();
 
-  gcc_assert (dom_computed[CDI_DOMINATORS]);
+  gcc_assert (dom_info_available_p (CDI_DOMINATORS));
   compact_blocks ();
 
 #ifdef ENABLE_CHECKING

diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 7da5cdffbb0cb1393113bbb505137e54a3fd8bac..381a3429e0728fff474888ff3789af847c20c01c 100644 (file)
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -591,7 +591,7 @@ remove_dead_stmt (block_stmt_iterator *i, basic_block bb)
       basic_block post_dom_bb;
 
       /* The post dominance info has to be up-to-date.  */
-      gcc_assert (dom_computed[CDI_POST_DOMINATORS] == DOM_OK);
+      gcc_assert (dom_info_state (CDI_POST_DOMINATORS) == DOM_OK);
       /* Get the immediate post dominator of bb.  */
       post_dom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
 

diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index c5578cfc9e37fedb84d68ea72969758851c05d45..1d0c4ade3032c0af30157b93bb5d64c0da62d0d5 100644 (file)
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -794,6 +794,7 @@ determine_invariantness (void)
   struct dom_walk_data walk_data;
 
   memset (&walk_data, 0, sizeof (struct dom_walk_data));
+  walk_data.dom_direction = CDI_DOMINATORS;
   walk_data.before_dom_children_before_stmts = determine_invariantness_stmt;
 
   init_walk_dominator_tree (&walk_data);
@@ -864,6 +865,7 @@ move_computations (void)
   struct dom_walk_data walk_data;
 
   memset (&walk_data, 0, sizeof (struct dom_walk_data));
+  walk_data.dom_direction = CDI_DOMINATORS;
   walk_data.before_dom_children_before_stmts = move_computations_stmt;
 
   init_walk_dominator_tree (&walk_data);

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 51e1fa2af4b502c505d3cb46a1b934b2463347db..3dfc34f05b9a0b33dd7faa3c39153568c4d51666 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -606,7 +606,7 @@ verify_ssa (bool check_modified_stmt)
   basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
   ssa_op_iter iter;
   tree op;
-  enum dom_state orig_dom_state = dom_computed[CDI_DOMINATORS];
+  enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
   bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
 
   gcc_assert (!need_ssa_update_p ());
@@ -747,7 +747,7 @@ verify_ssa (bool check_modified_stmt)
   if (orig_dom_state == DOM_NONE)
     free_dominance_info (CDI_DOMINATORS);
   else
-    dom_computed[CDI_DOMINATORS] = orig_dom_state;
+    set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
   
   BITMAP_FREE (names_defined_in_bb);
   timevar_pop (TV_TREE_SSA_VERIFY);