backport: et-forest.h (et_forest_create, [...]): Declarations removed.

	Backport from tree-ssa (relevant changes only):
	2003-12-18  Zdenek Dvorak  <rakdver@atrey.karlin.mff.cuni.cz>

	* et-forest.h (et_forest_create, et_forest_delete,
	et_forest_add_node, et_forest_add_edge, et_forest_remove_node,
	et_forest_remove_edge, et_forest_parent,
	et_forest_common_ancestor, et_forest_node_value,
	et_forest_enumerate_sons): Declarations removed.
	(struct et_node): New.
	(et_new_tree, et_free_tree, et_set_father, et_split, et_nca,
	et_below): Declare.
	* et-forest.c (struct et_forest_occurrence, struct et_forest,
	struct et_forest_node): Removed.
	(et_forest_create, et_forest_delete,
	et_forest_add_node, et_forest_add_edge, et_forest_remove_node,
	et_forest_remove_edge, et_forest_parent,
	et_forest_common_ancestor, et_forest_node_value,
	et_forest_enumerate_sons, splay, remove_all_occurrences,
	find_leftmost_node, find_rightmost_node, calculate_value): Removed.
	(struct et_occ): New.
	(et_nodes, et_occurences): New.
	(set_depth, set_depth_add, set_prev, set_next, et_recomp_min,
	et_check_occ_sanity, et_check_sanity, et_check_tree_sanity,
	record_path_before_1, record_path_before, check_path_after_1,
	check_path_after, et_splay, et_new_occ, et_new_tree,
	et_free_tree, et_set_father, et_split, et_nca, et_below): New.
	* basic-block.h (struct basic_block_def): New field dom.
	(struct dominance_info): Type removed.
	(calculate_dominance_info, free_dominance_info,
	nearest_common_dominator, set_immediate_dominator,
	get_immediate_dominator, dominated_by_p, get_dominated_by,
	add_to_dominance_info, delete_from_dominance_info,
	recount_dominator, redirect_immediate_dominators,
	iterate_fix_dominators, verify_dominators): Declarations
	changed.
	(enum dom_state): New.
	(dom_computed): New variable.
	(first_dom_son, next_dom_son): Declare.
	* dominance.c (struct dominance_info): Removed.
	(BB_NODE, SET_BB_NODE): Removed.
	(calculate_dominance_info, free_dominance_info,
	nearest_common_dominator, set_immediate_dominator,
	get_immediate_dominator, dominated_by_p, get_dominated_by,
	add_to_dominance_info, delete_from_dominance_info,
	recount_dominator, redirect_immediate_dominators,
	iterate_fix_dominators, verify_dominators,
	debug_dominance_info): Work over new datastructure.  Access
	dominance datastructures through CFG.
	(assign_dfs_numbers, compute_dom_fast_query, first_dom_son,
	next_dom_son): New.
	* bt-load.c (dom): Variable removed.
	(augment_live_range, combine_btr_defs, migrate_btr_def,
	migrate_btr_defs, branch_target_load_optimize): Updated for the
	new interface for dominance information.
	* cfg.c {exit_entry_blocks): Update initializer.
	* cfglayout.c (copy_bbs): Removed loops argument. Updated for
	the new interface for dominance information.
	* cfglayout.h (copy_bbs): Declaration changed.
	* cfgloop.c (flow_loop_pre_header_find, flow_loops_cfg_dump,
	flow_loop_scan, canonicalize_loop_headers, flow_loops_find): Updated
	for the new interface for dominance information.
	(flow_loop_scan): Loops argument removed.
	(flow_loops_free): Don't release dominators.
	* cfgloop.h (struct cfg): Dom field removed.
	(flow_loop_scan, loop_split_edge_with, simple_loop_p,
	just_once_each_iteration_p, split_loop_bb): Declaration changed.
	* cfgloopanal.c (simple_loop_exit_p, simple_increment,
	just_once_each_iteration_p, simple_loop_p): Remove loops argument.
	Updated for the new interface for dominance information.
	* cfgloopmanip.c (remove_bbs, find_path, create_preheader,
	split_loop_bb, loopify, duplicate_loop_to_header_edge,
	force_single_succ_latches, loop_split_edge_with): Ditto.
	* gcse.c (dominators): Variable removed.
	(free_code_hoist_mem, compute_code_hoist_data, hoist_code):
	Updated for the new interface for dominance information.
	* ifcvt.c (post_dominators): Variable removed.
	(mark_loop_exit_edges, merge_if_block, find_if_header,
	find_cond_trap, find_if_case_1, find_if_case_2, if_convert):
	Updated for the new interface for dominance information.
	* loop-init.c (rtl_loop_optimizer_init,
	rtl_loop_optimizer_finalize): Ditto.
	* loop-unroll.c (decide_peel_simple, decide_peel_once_rolling,
	decide_peel_completely, decide_unroll_stupid,
	decide_unroll_constant_iterations,
	decide_unroll_runtime_iterations): Loops argument removed.
	Updated for the new interface for dominance information.
	(unroll_and_peel_loops, peel_loops_completely,
	unroll_loop_runtime_iterations): Updated for the new interface for
	dominance information.
	* loop-unswitch.c (may_unswitch_on_p, unswitch_loops,
	unswitch_single_loop, unswitch_loop): Updated for the new
	interface for dominance information.
	* predict.c (process_note_predictions, process_note_prediction,
	estimate_probability, note_prediction_to_br_prob): Ditto.
	* sched-rgn.c (find_rgns, init_regions): Ditto.
	* toplev.c (rest_of_handle_branch_prob): Free the dominators.

From-SVN: r75226

gcc/ChangeLog

+2003-12-30  Steven Bosscher  <steven@gcc.gnu.org>
+
+	Backport from tree-ssa (relevant changes only):
+	2003-12-18  Zdenek Dvorak  <rakdver@atrey.karlin.mff.cuni.cz>
+
+	* et-forest.h (et_forest_create, et_forest_delete,
+	et_forest_add_node, et_forest_add_edge, et_forest_remove_node,
+	et_forest_remove_edge, et_forest_parent,
+	et_forest_common_ancestor, et_forest_node_value,
+	et_forest_enumerate_sons): Declarations removed.
+	(struct et_node): New.
+	(et_new_tree, et_free_tree, et_set_father, et_split, et_nca,
+	et_below): Declare.
+	* et-forest.c (struct et_forest_occurrence, struct et_forest,
+	struct et_forest_node): Removed.
+	(et_forest_create, et_forest_delete,
+	et_forest_add_node, et_forest_add_edge, et_forest_remove_node,
+	et_forest_remove_edge, et_forest_parent,
+	et_forest_common_ancestor, et_forest_node_value,
+	et_forest_enumerate_sons, splay, remove_all_occurrences,
+	find_leftmost_node, find_rightmost_node, calculate_value): Removed.
+	(struct et_occ): New.
+	(et_nodes, et_occurences): New.
+	(set_depth, set_depth_add, set_prev, set_next, et_recomp_min,
+	et_check_occ_sanity, et_check_sanity, et_check_tree_sanity,
+	record_path_before_1, record_path_before, check_path_after_1,
+	check_path_after, et_splay, et_new_occ, et_new_tree,
+	et_free_tree, et_set_father, et_split, et_nca, et_below): New.
+	* basic-block.h (struct basic_block_def): New field dom.
+	(struct dominance_info): Type removed.
+	(calculate_dominance_info, free_dominance_info,
+	nearest_common_dominator, set_immediate_dominator,
+	get_immediate_dominator, dominated_by_p, get_dominated_by,
+	add_to_dominance_info, delete_from_dominance_info,
+	recount_dominator, redirect_immediate_dominators,
+	iterate_fix_dominators, verify_dominators): Declarations
+	changed.
+	(enum dom_state): New.
+	(dom_computed): New variable.
+	(first_dom_son, next_dom_son): Declare.
+	* dominance.c (struct dominance_info): Removed.
+	(BB_NODE, SET_BB_NODE): Removed.
+	(calculate_dominance_info, free_dominance_info,
+	nearest_common_dominator, set_immediate_dominator,
+	get_immediate_dominator, dominated_by_p, get_dominated_by,
+	add_to_dominance_info, delete_from_dominance_info,
+	recount_dominator, redirect_immediate_dominators,
+	iterate_fix_dominators, verify_dominators,
+	debug_dominance_info): Work over new datastructure.  Access
+	dominance datastructures through CFG.
+	(assign_dfs_numbers, compute_dom_fast_query, first_dom_son,
+	next_dom_son): New.
+	* bt-load.c (dom): Variable removed.
+	(augment_live_range, combine_btr_defs, migrate_btr_def,
+	migrate_btr_defs, branch_target_load_optimize): Updated for the
+	new interface for dominance information.
+	* cfg.c {exit_entry_blocks): Update initializer.
+	* cfglayout.c (copy_bbs): Removed loops argument. Updated for
+	the new interface for dominance information.
+	* cfglayout.h (copy_bbs): Declaration changed.
+	* cfgloop.c (flow_loop_pre_header_find, flow_loops_cfg_dump,
+	flow_loop_scan, canonicalize_loop_headers, flow_loops_find): Updated
+	for the new interface for dominance information.
+	(flow_loop_scan): Loops argument removed.
+	(flow_loops_free): Don't release dominators.
+	* cfgloop.h (struct cfg): Dom field removed.
+	(flow_loop_scan, loop_split_edge_with, simple_loop_p,
+	just_once_each_iteration_p, split_loop_bb): Declaration changed.
+	* cfgloopanal.c (simple_loop_exit_p, simple_increment,
+	just_once_each_iteration_p, simple_loop_p): Remove loops argument.
+	Updated for the new interface for dominance information.
+	* cfgloopmanip.c (remove_bbs, find_path, create_preheader,
+	split_loop_bb, loopify, duplicate_loop_to_header_edge,
+	force_single_succ_latches, loop_split_edge_with): Ditto.
+	* gcse.c (dominators): Variable removed.
+	(free_code_hoist_mem, compute_code_hoist_data, hoist_code):
+	Updated for the new interface for dominance information.
+	* ifcvt.c (post_dominators): Variable removed.
+	(mark_loop_exit_edges, merge_if_block, find_if_header,
+	find_cond_trap, find_if_case_1, find_if_case_2, if_convert):
+	Updated for the new interface for dominance information.
+	* loop-init.c (rtl_loop_optimizer_init,
+	rtl_loop_optimizer_finalize): Ditto.
+	* loop-unroll.c (decide_peel_simple, decide_peel_once_rolling,
+	decide_peel_completely, decide_unroll_stupid,
+	decide_unroll_constant_iterations,
+	decide_unroll_runtime_iterations): Loops argument removed.
+	Updated for the new interface for dominance information.
+	(unroll_and_peel_loops, peel_loops_completely,
+	unroll_loop_runtime_iterations): Updated for the new interface for
+	dominance information.
+	* loop-unswitch.c (may_unswitch_on_p, unswitch_loops,
+	unswitch_single_loop, unswitch_loop): Updated for the new
+	interface for dominance information.
+	* predict.c (process_note_predictions, process_note_prediction,
+	estimate_probability, note_prediction_to_br_prob): Ditto.
+	* sched-rgn.c (find_rgns, init_regions): Ditto.
+	* toplev.c (rest_of_handle_branch_prob): Free the dominators.
+
 2003-12-30  Jan Hubicka  <jh@suse.cz>
 
 	PR target/13456

gcc/Makefile.in

@@ -1322,7 +1322,7 @@ c-convert.o : c-convert.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H)
 c-pragma.o: c-pragma.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(TREE_H) \
     function.h c-pragma.h toplev.h output.h $(GGC_H) $(TM_P_H) $(C_COMMON_H) gt-c-pragma.h
 graph.o: graph.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) toplev.h flags.h output.h \
-    $(RTL_H) function.h hard-reg-set.h $(BASIC_BLOCK_H) graph.h
+    $(RTL_H) function.h langhooks.h hard-reg-set.h $(BASIC_BLOCK_H) graph.h $(TREE_H)
 sbitmap.o: sbitmap.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) flags.h \
     hard-reg-set.h $(BASIC_BLOCK_H)
 
@@ -1651,7 +1651,7 @@ web.o : web.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(REGS_H) \
    hard-reg-set.h flags.h $(BASIC_BLOCK_H) function.h output.h toplev.h df.h
 gcse.o : gcse.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(REGS_H) \
    hard-reg-set.h flags.h real.h insn-config.h $(GGC_H) $(RECOG_H) $(EXPR_H) \
-   $(BASIC_BLOCK_H) function.h output.h toplev.h $(TM_P_H) $(PARAMS_H) \
+   $(BASIC_BLOCK_H) function.h langhooks.h output.h toplev.h $(TM_P_H) $(PARAMS_H) \
    except.h gt-gcse.h $(TREE_H)
 sibcall.o : sibcall.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(REGS_H) \
    function.h hard-reg-set.h flags.h insn-config.h $(RECOG_H) $(BASIC_BLOCK_H)

gcc/basic-block.h

@@ -234,6 +234,9 @@ typedef struct basic_block_def {
   /* Outermost loop containing the block.  */
   struct loop *loop_father;
 
+  /* The dominance and postdominance information node.  */
+  struct et_node *dom[2];
+
   /* Expected number of executions: calculated in profile.c.  */
   gcov_type count;
 
@@ -373,10 +376,6 @@ extern void clear_edges (void);
 extern void mark_critical_edges (void);
 extern rtx first_insn_after_basic_block_note (basic_block);
 
-/* Dominator information for basic blocks.  */
-
-typedef struct dominance_info *dominance_info;
-
 /* Structure to group all of the information to process IF-THEN and
    IF-THEN-ELSE blocks for the conditional execution support.  This
    needs to be in a public file in case the IFCVT macros call
@@ -612,22 +611,35 @@ enum cdi_direction
   CDI_POST_DOMINATORS
 };
 
-extern dominance_info calculate_dominance_info (enum cdi_direction);
-extern void free_dominance_info (dominance_info);
-extern basic_block nearest_common_dominator (dominance_info,
+enum dom_state
+{
+  DOM_NONE,		/* Not computed at all.  */
+  DOM_CONS_OK,		/* The data is conservatively OK, i.e. if it says you that A dominates B,
+			   it indeed does.  */
+  DOM_NO_FAST_QUERY,	/* The data is OK, but the fast query data are not usable.  */
+  DOM_OK		/* Everything is ok.  */
+};
+
+extern enum dom_state dom_computed[2];
+
+extern void calculate_dominance_info (enum cdi_direction);
+extern void free_dominance_info (enum cdi_direction);
+extern basic_block nearest_common_dominator (enum cdi_direction,
 					     basic_block, basic_block);
-extern void set_immediate_dominator (dominance_info, basic_block,
+extern void set_immediate_dominator (enum cdi_direction, basic_block,
 				     basic_block);
-extern basic_block get_immediate_dominator (dominance_info, basic_block);
-extern bool dominated_by_p (dominance_info, basic_block, basic_block);
-extern int get_dominated_by (dominance_info, basic_block, basic_block **);
-extern void add_to_dominance_info (dominance_info, basic_block);
-extern void delete_from_dominance_info (dominance_info, basic_block);
-basic_block recount_dominator (dominance_info, basic_block);
-extern void redirect_immediate_dominators (dominance_info, basic_block,
+extern basic_block get_immediate_dominator (enum cdi_direction, basic_block);
+extern bool dominated_by_p (enum cdi_direction, basic_block, basic_block);
+extern int get_dominated_by (enum cdi_direction, basic_block, basic_block **);
+extern void add_to_dominance_info (enum cdi_direction, basic_block);
+extern void delete_from_dominance_info (enum cdi_direction, basic_block);
+basic_block recount_dominator (enum cdi_direction, basic_block);
+extern void redirect_immediate_dominators (enum cdi_direction, basic_block,
 					   basic_block);
-void iterate_fix_dominators (dominance_info, basic_block *, int);
-extern void verify_dominators (dominance_info);
+extern void iterate_fix_dominators (enum cdi_direction, basic_block *, int);
+extern void verify_dominators (enum cdi_direction);
+extern basic_block first_dom_son (enum cdi_direction, basic_block);
+extern basic_block next_dom_son (enum cdi_direction, basic_block);
 
 #include "cfghooks.h"
 

gcc/bt-load.c

@@ -155,9 +155,6 @@ static void note_btr_set (rtx, rtx, void *);
    migrating branch target load instructions.  */
 static struct obstack migrate_btrl_obstack;
 
-/* Basic block dominator information used when migrating PT instructions.  */
-static dominance_info dom;
-
 /* Array indexed by basic block number, giving the set of registers
    live in that block.  */
 static HARD_REG_SET *btrs_live;
@@ -840,9 +837,9 @@ augment_live_range (bitmap live_range, HARD_REG_SET *btrs_live_in_range,
 
   tos = worklist = xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
 
-  if (dominated_by_p (dom, new_bb, head_bb))
+  if (dominated_by_p (CDI_DOMINATORS, new_bb, head_bb))
     *tos++ = new_bb;
-  else if (dominated_by_p (dom, head_bb, new_bb))
+  else if (dominated_by_p (CDI_DOMINATORS, head_bb, new_bb))
     {
       edge e;
       int new_block = new_bb->index;
@@ -974,7 +971,7 @@ combine_btr_defs (btr_def def, HARD_REG_SET *btrs_live_in_range)
       if (other_def != def
 	  && other_def->uses != NULL
 	  && ! other_def->has_ambiguous_use
-	  && dominated_by_p (dom, other_def->bb, def->bb))
+	  && dominated_by_p (CDI_DOMINATORS, other_def->bb, def->bb))
 	{
 	  /* def->bb dominates the other def, so def and other_def could
 	     be combined.  */
@@ -1226,9 +1223,9 @@ migrate_btr_def (btr_def def, int min_cost)
 
   def_basic_block_freq = basic_block_freq (def->bb);
 
-  for (try = get_immediate_dominator (dom, def->bb);
+  for (try = get_immediate_dominator (CDI_DOMINATORS, def->bb);
        !give_up && try && try != ENTRY_BLOCK_PTR && def->cost >= min_cost;
-       try = get_immediate_dominator (dom, try))
+       try = get_immediate_dominator (CDI_DOMINATORS, try))
     {
       /* Try to move the instruction that sets the target register into
 	 basic block TRY.  */
@@ -1299,7 +1296,7 @@ migrate_btr_defs (enum reg_class btr_class, int allow_callee_save)
 	    "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC
 	    " loop-depth = %d idom = %d\n",
 	    i, (HOST_WIDEST_INT) bb->count, bb->loop_depth,
-	    get_immediate_dominator (dom, bb)->index);
+	    get_immediate_dominator (CDI_DOMINATORS, bb)->index);
 	}
     }
 
@@ -1367,12 +1364,12 @@ branch_target_load_optimize (rtx insns, bool after_prologue_epilogue_gen)
       life_analysis (insns, NULL, 0);
 
       /* Dominator info is also needed for migrate_btr_def.  */
-      dom = calculate_dominance_info (CDI_DOMINATORS);
+      calculate_dominance_info (CDI_DOMINATORS);
       migrate_btr_defs (class,
 		       ((*targetm.branch_target_register_callee_saved)
 			(after_prologue_epilogue_gen)));
 
-      free_dominance_info (dom);
+      free_dominance_info (CDI_DOMINATORS);
 
       update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
 			PROP_DEATH_NOTES | PROP_REG_INFO);

gcc/cfg.c

@@ -111,6 +111,7 @@ struct basic_block_def entry_exit_blocks[2]
     EXIT_BLOCK_PTR,		/* next_bb */
     0,				/* loop_depth */
     NULL,                       /* loop_father */
+    { NULL, NULL },		/* dom */
     0,				/* count */
     0,				/* frequency */
     0,				/* flags */
@@ -133,6 +134,7 @@ struct basic_block_def entry_exit_blocks[2]
     NULL,			/* next_bb */
     0,				/* loop_depth */
     NULL,                       /* loop_father */
+    { NULL, NULL },		/* dom */
     0,				/* count */
     0,				/* frequency */
     0,				/* flags */

gcc/cfglayout.c

@@ -1253,7 +1253,7 @@ end:
 void
 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
 	  edge *edges, unsigned n_edges, edge *new_edges,
-	  struct loop *base, struct loops *loops)
+	  struct loop *base)
 {
   unsigned i, j;
   basic_block bb, new_bb, dom_bb;
@@ -1268,7 +1268,7 @@ copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
       bb->rbi->duplicated = 1;
       /* Add to loop.  */
       add_bb_to_loop (new_bb, bb->loop_father->copy);
-      add_to_dominance_info (loops->cfg.dom, new_bb);
+      add_to_dominance_info (CDI_DOMINATORS, new_bb);
       /* Possibly set header.  */
       if (bb->loop_father->header == bb && bb->loop_father != base)
 	new_bb->loop_father->header = new_bb;
@@ -1283,11 +1283,11 @@ copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
       bb = bbs[i];
       new_bb = new_bbs[i];
 
-      dom_bb = get_immediate_dominator (loops->cfg.dom, bb);
+      dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
       if (dom_bb->rbi->duplicated)
 	{
 	  dom_bb = dom_bb->rbi->copy;
-	  set_immediate_dominator (loops->cfg.dom, new_bb, dom_bb);
+	  set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
 	}
     }
 

gcc/cfglayout.h

@@ -43,5 +43,5 @@ extern void insn_locators_initialize (void);
 extern void reemit_insn_block_notes (void);
 extern bool can_copy_bbs_p (basic_block *, unsigned);
 extern void copy_bbs (basic_block *, unsigned, basic_block *,
-		      edge *, unsigned, edge *, struct loop *, struct loops *);
+		      edge *, unsigned, edge *, struct loop *);
 extern void cfg_layout_initialize_rbi (basic_block);

gcc/cfgloop.c

@@ -38,7 +38,7 @@ static void flow_loop_entry_edges_find (struct loop *);
 static void flow_loop_exit_edges_find (struct loop *);
 static int flow_loop_nodes_find (basic_block, struct loop *);
 static void flow_loop_pre_header_scan (struct loop *);
-static basic_block flow_loop_pre_header_find (basic_block, dominance_info);
+static basic_block flow_loop_pre_header_find (basic_block);
 static int flow_loop_level_compute (struct loop *);
 static int flow_loops_level_compute (struct loops *);
 static void establish_preds (struct loop *);
@@ -55,7 +55,7 @@ flow_loops_cfg_dump (const struct loops *loops, FILE *file)
   int i;
   basic_block bb;
 
-  if (! loops->num || ! file || ! loops->cfg.dom)
+  if (! loops->num || ! file)
     return;
 
   FOR_EACH_BB (bb)
@@ -212,9 +212,6 @@ flow_loops_free (struct loops *loops)
       free (loops->parray);
       loops->parray = NULL;
 
-      if (loops->cfg.dom)
-	free_dominance_info (loops->cfg.dom);
-
       if (loops->cfg.dfs_order)
 	free (loops->cfg.dfs_order);
       if (loops->cfg.rc_order)
@@ -391,11 +388,10 @@ flow_loop_pre_header_scan (struct loop *loop)
 }
 
 /* Return the block for the pre-header of the loop with header
-   HEADER where DOM specifies the dominator information.  Return NULL if
-   there is no pre-header.  */
+   HEADER.  Return NULL if there is no pre-header.  */
 
 static basic_block
-flow_loop_pre_header_find (basic_block header, dominance_info dom)
+flow_loop_pre_header_find (basic_block header)
 {
   basic_block pre_header;
   edge e;
@@ -408,7 +404,7 @@ flow_loop_pre_header_find (basic_block header, dominance_info dom)
       basic_block node = e->src;
 
       if (node != ENTRY_BLOCK_PTR
-	  && ! dominated_by_p (dom, node, header))
+	  && ! dominated_by_p (CDI_DOMINATORS, node, header))
 	{
 	  if (pre_header == NULL)
 	    pre_header = node;
@@ -522,7 +518,7 @@ flow_loops_level_compute (struct loops *loops)
    about it specified by FLAGS.  */
 
 int
-flow_loop_scan (struct loops *loops, struct loop *loop, int flags)
+flow_loop_scan (struct loop *loop, int flags)
 {
   if (flags & LOOP_ENTRY_EDGES)
     {
@@ -541,8 +537,7 @@ flow_loop_scan (struct loops *loops, struct loop *loop, int flags)
   if (flags & LOOP_PRE_HEADER)
     {
       /* Look to see if the loop has a pre-header node.  */
-      loop->pre_header
-	= flow_loop_pre_header_find (loop->header, loops->cfg.dom);
+      loop->pre_header = flow_loop_pre_header_find (loop->header);
 
       /* Find the blocks within the extended basic block of
 	 the loop pre-header.  */
@@ -627,12 +622,11 @@ make_forwarder_block (basic_block bb, int redirect_latch, int redirect_nonlatch,
 static void
 canonicalize_loop_headers (void)
 {
-  dominance_info dom;
   basic_block header;
   edge e;
 
   /* Compute the dominators.  */
-  dom = calculate_dominance_info (CDI_DOMINATORS);
+  calculate_dominance_info (CDI_DOMINATORS);
 
   alloc_aux_for_blocks (sizeof (int));
   alloc_aux_for_edges (sizeof (int));
@@ -651,7 +645,7 @@ canonicalize_loop_headers (void)
 	    have_abnormal_edge = 1;
 
 	  if (latch != ENTRY_BLOCK_PTR
-	      && dominated_by_p (dom, latch, header))
+	      && dominated_by_p (CDI_DOMINATORS, latch, header))
 	    {
 	      num_latches++;
 	      LATCH_EDGE (e) = 1;
@@ -663,6 +657,8 @@ canonicalize_loop_headers (void)
 	HEADER_BLOCK (header) = num_latches;
     }
 
+  free_dominance_info (CDI_DOMINATORS);
+
   if (HEADER_BLOCK (ENTRY_BLOCK_PTR->succ->dest))
     {
       basic_block bb;
@@ -728,7 +724,6 @@ canonicalize_loop_headers (void)
 
   free_aux_for_blocks ();
   free_aux_for_edges ();
-  free_dominance_info (dom);
 }
 
 /* Find all the natural loops in the function and save in LOOPS structure and
@@ -744,7 +739,6 @@ flow_loops_find (struct loops *loops, int flags)
   int num_loops;
   edge e;
   sbitmap headers;
-  dominance_info dom;
   int *dfs_order;
   int *rc_order;
   basic_block header;
@@ -770,7 +764,7 @@ flow_loops_find (struct loops *loops, int flags)
   canonicalize_loop_headers ();
 
   /* Compute the dominators.  */
-  dom = loops->cfg.dom = calculate_dominance_info (CDI_DOMINATORS);
+  calculate_dominance_info (CDI_DOMINATORS);
 
   /* Count the number of loop headers.  This should be the
      same as the number of natural loops.  */
@@ -804,7 +798,8 @@ flow_loops_find (struct loops *loops, int flags)
 	     node (header) that dominates all the nodes in the
 	     loop.  It also has single back edge to the header
 	     from a latch node.  */
-	  if (latch != ENTRY_BLOCK_PTR && dominated_by_p (dom, latch, header))
+	  if (latch != ENTRY_BLOCK_PTR
+	      && dominated_by_p (CDI_DOMINATORS, latch, header))
 	    {
 	      /* Shared headers should be eliminated by now.  */
 	      if (more_latches)
@@ -849,7 +844,6 @@ flow_loops_find (struct loops *loops, int flags)
       flow_depth_first_order_compute (dfs_order, rc_order);
 
       /* Save CFG derived information to avoid recomputing it.  */
-      loops->cfg.dom = dom;
       loops->cfg.dfs_order = dfs_order;
       loops->cfg.rc_order = rc_order;
 
@@ -878,7 +872,7 @@ flow_loops_find (struct loops *loops, int flags)
 	      basic_block latch = e->src;
 
 	      if (latch != ENTRY_BLOCK_PTR
-		  && dominated_by_p (dom, latch, header))
+		  && dominated_by_p (CDI_DOMINATORS, latch, header))
 		{
 		  loop->latch = latch;
 		  break;
@@ -897,14 +891,13 @@ flow_loops_find (struct loops *loops, int flags)
 
       /* Scan the loops.  */
       for (i = 1; i < num_loops; i++)
-	flow_loop_scan (loops, loops->parray[i], flags);
+	flow_loop_scan (loops->parray[i], flags);
 
       loops->num = num_loops;
     }
   else
     {
-      loops->cfg.dom = NULL;
-      free_dominance_info (dom);
+      free_dominance_info (CDI_DOMINATORS);
     }
 
   loops->state = 0;

gcc/cfgloop.h

@@ -230,9 +230,6 @@ struct loops
   /* Information derived from the CFG.  */
   struct cfg
   {
-    /* The bitmap vector of dominators or NULL if not computed.  */
-    dominance_info dom;
-
     /* The ordering of the basic blocks in a depth first search.  */
     int *dfs_order;
 
@@ -265,7 +262,7 @@ extern void flow_loops_dump (const struct loops *, FILE *,
 			     void (*)(const struct loop *, FILE *, int), int);
 extern void flow_loop_dump (const struct loop *, FILE *,
 			    void (*)(const struct loop *, FILE *, int), int);
-extern int flow_loop_scan (struct loops *, struct loop *, int);
+extern int flow_loop_scan (struct loop *, int);
 extern void flow_loop_free (struct loop *);
 void mark_irreducible_loops (struct loops *);
 
@@ -292,7 +289,7 @@ extern void remove_bb_from_loops (basic_block);
 extern void cancel_loop (struct loops *, struct loop *);
 extern void cancel_loop_tree (struct loops *, struct loop *);
 
-extern basic_block loop_split_edge_with (edge, rtx, struct loops *);
+extern basic_block loop_split_edge_with (edge, rtx);
 extern int fix_loop_placement (struct loop *);
 
 enum
@@ -306,10 +303,9 @@ extern void force_single_succ_latches (struct loops *);
 extern void verify_loop_structure (struct loops *);
 
 /* Loop analysis.  */
-extern bool simple_loop_p (struct loops *, struct loop *, struct loop_desc *);
+extern bool simple_loop_p (struct loop *, struct loop_desc *);
 extern rtx count_loop_iterations (struct loop_desc *, rtx, rtx);
-extern bool just_once_each_iteration_p (struct loops *,struct loop *,
-					basic_block);
+extern bool just_once_each_iteration_p (struct loop *, basic_block);
 extern unsigned expected_loop_iterations (const struct loop *);
 
 /* Loop manipulation.  */
@@ -324,7 +320,7 @@ extern int duplicate_loop_to_header_edge (struct loop *, edge, struct loops *,
 extern struct loop *loopify (struct loops *, edge, edge, basic_block);
 extern void unloop (struct loops *, struct loop *);
 extern bool remove_path (struct loops *, edge);
-extern edge split_loop_bb (struct loops *, basic_block, rtx);
+extern edge split_loop_bb (basic_block, rtx);
 
 /* Loop optimizer initialization.  */
 extern struct loops *loop_optimizer_init (FILE *);

gcc/cfgloopanal.c

@@ -39,14 +39,13 @@ static bool invariant_rtx_wrto_regs_p (rtx, regset);
 static rtx test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT);
 static bool constant_iterations (struct loop_desc *, unsigned HOST_WIDE_INT *,
 				 bool *);
-static bool simple_loop_exit_p (struct loops *, struct loop *, edge, regset,
+static bool simple_loop_exit_p (struct loop *, edge, regset,
 				rtx *, struct loop_desc *);
 static rtx variable_initial_value (rtx, regset, rtx, rtx *, enum machine_mode);
 static rtx variable_initial_values (edge, rtx, enum machine_mode);
 static bool simple_condition_p (struct loop *, rtx, regset,
 				struct loop_desc *);
-static basic_block simple_increment (struct loops *, struct loop *, rtx *,
-				     struct loop_desc *);
+static basic_block simple_increment (struct loop *, rtx *, struct loop_desc *);
 static rtx count_strange_loop_iterations (rtx, rtx, enum rtx_code,
 					  int, rtx, enum machine_mode,
 					  enum machine_mode);
@@ -73,10 +72,10 @@ inverse (unsigned HOST_WIDEST_INT x, int mod)
 
 /* Checks whether BB is executed exactly once in each LOOP iteration.  */
 bool
-just_once_each_iteration_p (struct loops *loops, struct loop *loop, basic_block bb)
+just_once_each_iteration_p (struct loop *loop, basic_block bb)
 {
   /* It must be executed at least once each iteration.  */
-  if (!dominated_by_p (loops->cfg.dom, loop->latch, bb))
+  if (!dominated_by_p (CDI_DOMINATORS, loop->latch, bb))
     return false;
 
   /* And just once.  */
@@ -295,8 +294,8 @@ simple_condition_p (struct loop *loop ATTRIBUTE_UNUSED, rtx condition,
    iteration.  Fills in DESC->stride and returns block in that DESC->var is
    modified.  */
 static basic_block
-simple_increment (struct loops *loops, struct loop *loop,
-		  rtx *simple_increment_regs, struct loop_desc *desc)
+simple_increment (struct loop *loop, rtx *simple_increment_regs,
+		  struct loop_desc *desc)
 {
   rtx mod_insn, mod_insn1, set, set_src, set_add;
   basic_block mod_bb, mod_bb1;
@@ -308,7 +307,7 @@ simple_increment (struct loops *loops, struct loop *loop,
   mod_bb = BLOCK_FOR_INSN (mod_insn);
 
   /* Check that it is executed exactly once each iteration.  */
-  if (!just_once_each_iteration_p (loops, loop, mod_bb))
+  if (!just_once_each_iteration_p (loop, mod_bb))
     return NULL;
 
   /* mod_insn must be a simple increment/decrement.  */
@@ -355,7 +354,7 @@ simple_increment (struct loops *loops, struct loop *loop,
 	return NULL;
 
       mod_bb1 = BLOCK_FOR_INSN (mod_insn1);
-      if (!dominated_by_p (loops->cfg.dom, mod_bb, mod_bb1))
+      if (!dominated_by_p (CDI_DOMINATORS, mod_bb, mod_bb1))
 	return NULL;
       if (mod_bb1 == mod_bb)
 	{
@@ -962,7 +961,7 @@ test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT iter)
    description joined to it in in DESC.  INVARIANT_REGS and SINGLE_SET_REGS
    are results of blocks_{invariant,single_set}_regs over BODY.  */
 static bool
-simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
+simple_loop_exit_p (struct loop *loop, edge exit_edge,
 		    regset invariant_regs, rtx *single_set_regs,
 		    struct loop_desc *desc)
 {
@@ -979,7 +978,7 @@ simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
     return false;
 
   /* It must be tested (at least) once during any iteration.  */
-  if (!dominated_by_p (loops->cfg.dom, loop->latch, exit_bb))
+  if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit_bb))
     return false;
 
   /* It must end in a simple conditional jump.  */
@@ -1003,11 +1002,11 @@ simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
 
   /*  Var must be simply incremented or decremented in exactly one insn that
      is executed just once every iteration.  */
-  if (!(mod_bb = simple_increment (loops, loop, single_set_regs, desc)))
+  if (!(mod_bb = simple_increment (loop, single_set_regs, desc)))
     return false;
 
   /* OK, it is simple loop.  Now just fill in remaining info.  */
-  desc->postincr = !dominated_by_p (loops->cfg.dom, exit_bb, mod_bb);
+  desc->postincr = !dominated_by_p (CDI_DOMINATORS, exit_bb, mod_bb);
   desc->neg = !fallthru_out;
 
   /* Find initial value of var and alternative values for lim.  */
@@ -1026,7 +1025,7 @@ simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
 /* Tests whether LOOP is simple for loop.  Returns simple loop description
    in DESC.  */
 bool
-simple_loop_p (struct loops *loops, struct loop *loop, struct loop_desc *desc)
+simple_loop_p (struct loop *loop, struct loop_desc *desc)
 {
   unsigned i;
   basic_block *body;
@@ -1051,7 +1050,7 @@ simple_loop_p (struct loops *loops, struct loop *loop, struct loop_desc *desc)
     {
       for (e = body[i]->succ; e; e = e->succ_next)
 	if (!flow_bb_inside_loop_p (loop, e->dest)
-	    && simple_loop_exit_p (loops, loop, e,
+	    && simple_loop_exit_p (loop, e,
 		   invariant_regs, single_set_regs, &act))
 	  {
 	    /* Prefer constant iterations; the less the better.  */

gcc/cfgloopmanip.c

@@ -36,9 +36,9 @@ static void copy_loops_to (struct loops *, struct loop **, int,
 			   struct loop *);
 static void loop_redirect_edge (edge, basic_block);
 static bool loop_delete_branch_edge (edge, int);
-static void remove_bbs (dominance_info, basic_block *, int);
+static void remove_bbs (basic_block *, int);
 static bool rpe_enum_p (basic_block, void *);
-static int find_path (edge, dominance_info, basic_block **);
+static int find_path (edge, basic_block **);
 static bool alp_enum_p (basic_block, void *);
 static void add_loop (struct loops *, struct loop *);
 static void fix_loop_placements (struct loop *);
@@ -47,17 +47,15 @@ static void fix_bb_placements (struct loops *, basic_block);
 static void place_new_loop (struct loops *, struct loop *);
 static void scale_loop_frequencies (struct loop *, int, int);
 static void scale_bbs_frequencies (basic_block *, int, int, int);
-static basic_block create_preheader (struct loop *, dominance_info, int);
+static basic_block create_preheader (struct loop *, int);
 static void fix_irreducible_loops (basic_block);
 
 /* Splits basic block BB after INSN, returns created edge.  Updates loops
    and dominators.  */
 edge
-split_loop_bb (struct loops *loops, basic_block bb, rtx insn)
+split_loop_bb (basic_block bb, rtx insn)
 {
   edge e;
-  basic_block *dom_bbs;
-  int n_dom_bbs, i;
 
   /* Split the block.  */
   e = split_block (bb, insn);
@@ -66,42 +64,31 @@ split_loop_bb (struct loops *loops, basic_block bb, rtx insn)
   add_bb_to_loop (e->dest, e->src->loop_father);
 
   /* Fix dominators.  */
-  add_to_dominance_info (loops->cfg.dom, e->dest);
-  n_dom_bbs = get_dominated_by (loops->cfg.dom, e->src, &dom_bbs);
-  for (i = 0; i < n_dom_bbs; i++)
-    set_immediate_dominator (loops->cfg.dom, dom_bbs[i], e->dest);
-  free (dom_bbs);
-  set_immediate_dominator (loops->cfg.dom, e->dest, e->src);
+  add_to_dominance_info (CDI_DOMINATORS, e->dest);
+  redirect_immediate_dominators (CDI_DOMINATORS, e->src, e->dest);
+  set_immediate_dominator (CDI_DOMINATORS, e->dest, e->src);
 
   return e;
 }
 
-/* Checks whether basic block BB is dominated by RPE->DOM, where
-   RPE is passed through DATA.  */
-struct rpe_data
- {
-   basic_block dom;
-   dominance_info doms;
- };
-
+/* Checks whether basic block BB is dominated by DATA.  */
 static bool
 rpe_enum_p (basic_block bb, void *data)
 {
-  struct rpe_data *rpe = data;
-  return dominated_by_p (rpe->doms, bb, rpe->dom);
+  return dominated_by_p (CDI_DOMINATORS, bb, data);
 }
 
 /* Remove basic blocks BBS from loop structure and dominance info,
    and delete them afterwards.  */
 static void
-remove_bbs (dominance_info dom, basic_block *bbs, int nbbs)
+remove_bbs (basic_block *bbs, int nbbs)
 {
   int i;
 
   for (i = 0; i < nbbs; i++)
     {
       remove_bb_from_loops (bbs[i]);
-      delete_from_dominance_info (dom, bbs[i]);
+      delete_from_dominance_info (CDI_DOMINATORS, bbs[i]);
       delete_block (bbs[i]);
     }
 }
@@ -113,19 +100,15 @@ remove_bbs (dominance_info dom, basic_block *bbs, int nbbs)
    alter anything by this function).  The number of basic blocks in the
    path is returned.  */
 static int
-find_path (edge e, dominance_info doms, basic_block **bbs)
+find_path (edge e, basic_block **bbs)
 {
-  struct rpe_data rpe;
-
   if (e->dest->pred->pred_next)
     abort ();
 
   /* Find bbs in the path.  */
-  rpe.dom = e->dest;
-  rpe.doms = doms;
   *bbs = xcalloc (n_basic_blocks, sizeof (basic_block));
   return dfs_enumerate_from (e->dest, 0, rpe_enum_p, *bbs,
-			     n_basic_blocks, &rpe);
+			     n_basic_blocks, e->dest);
 }
 
 /* Fix placement of basic block BB inside loop hierarchy stored in LOOPS --
@@ -353,19 +336,19 @@ remove_path (struct loops *loops, edge e)
      fix -- when e->dest has exactly one predecessor, this corresponds
      to blocks dominated by e->dest, if not, split the edge.  */
   if (e->dest->pred->pred_next)
-    e = loop_split_edge_with (e, NULL_RTX, loops)->pred;
+    e = loop_split_edge_with (e, NULL_RTX)->pred;
 
   /* It may happen that by removing path we remove one or more loops
      we belong to.  In this case first unloop the loops, then proceed
      normally.   We may assume that e->dest is not a header of any loop,
      as it now has exactly one predecessor.  */
   while (e->src->loop_father->outer
-	 && dominated_by_p (loops->cfg.dom,
+	 && dominated_by_p (CDI_DOMINATORS,
 			    e->src->loop_father->latch, e->dest))
     unloop (loops, e->src->loop_father);
 
   /* Identify the path.  */
-  nrem = find_path (e, loops->cfg.dom, &rem_bbs);
+  nrem = find_path (e, &rem_bbs);
 
   n_bord_bbs = 0;
   bord_bbs = xcalloc (n_basic_blocks, sizeof (basic_block));
@@ -397,7 +380,7 @@ remove_path (struct loops *loops, edge e)
     if (rem_bbs[i]->loop_father->header == rem_bbs[i])
       cancel_loop_tree (loops, rem_bbs[i]->loop_father);
 
-  remove_bbs (loops->cfg.dom, rem_bbs, nrem);
+  remove_bbs (rem_bbs, nrem);
   free (rem_bbs);
 
   /* Find blocks whose dominators may be affected.  */
@@ -405,25 +388,24 @@ remove_path (struct loops *loops, edge e)
   sbitmap_zero (seen);
   for (i = 0; i < n_bord_bbs; i++)
     {
-      int j, nldom;
-      basic_block *ldom;
+      basic_block ldom;
 
-      bb = get_immediate_dominator (loops->cfg.dom, bord_bbs[i]);
+      bb = get_immediate_dominator (CDI_DOMINATORS, bord_bbs[i]);
       if (TEST_BIT (seen, bb->index))
 	continue;
       SET_BIT (seen, bb->index);
 
-      nldom = get_dominated_by (loops->cfg.dom, bb, &ldom);
-      for (j = 0; j < nldom; j++)
-	if (!dominated_by_p (loops->cfg.dom, from, ldom[j]))
-	  dom_bbs[n_dom_bbs++] = ldom[j];
-      free(ldom);
+      for (ldom = first_dom_son (CDI_DOMINATORS, bb);
+	   ldom;
+	   ldom = next_dom_son (CDI_DOMINATORS, ldom))
+	if (!dominated_by_p (CDI_DOMINATORS, from, ldom))
+	  dom_bbs[n_dom_bbs++] = ldom;
     }
 
   free (seen);
 
   /* Recount dominators.  */
-  iterate_fix_dominators (loops->cfg.dom, dom_bbs, n_dom_bbs);
+  iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, n_dom_bbs);
   free (dom_bbs);
 
   /* These blocks have lost some predecessor(s), thus their irreducible
@@ -513,7 +495,7 @@ loopify (struct loops *loops, edge latch_edge, edge header_edge, basic_block swi
   basic_block succ_bb = latch_edge->dest;
   basic_block pred_bb = header_edge->src;
   basic_block *dom_bbs, *body;
-  unsigned n_dom_bbs, i, j;
+  unsigned n_dom_bbs, i;
   sbitmap seen;
   struct loop *loop = xcalloc (1, sizeof (struct loop));
   struct loop *outer = succ_bb->loop_father->outer;
@@ -538,9 +520,9 @@ loopify (struct loops *loops, edge latch_edge, edge header_edge, basic_block swi
   loop_redirect_edge (switch_bb->succ, succ_bb);
 
   /* Update dominators.  */
-  set_immediate_dominator (loops->cfg.dom, switch_bb, pred_bb);
-  set_immediate_dominator (loops->cfg.dom, loop->header, switch_bb);
-  set_immediate_dominator (loops->cfg.dom, succ_bb, switch_bb);
+  set_immediate_dominator (CDI_DOMINATORS, switch_bb, pred_bb);
+  set_immediate_dominator (CDI_DOMINATORS, loop->header, switch_bb);
+  set_immediate_dominator (CDI_DOMINATORS, succ_bb, switch_bb);
 
   /* Compute new loop.  */
   add_loop (loops, loop);
@@ -569,20 +551,19 @@ loopify (struct loops *loops, edge latch_edge, edge header_edge, basic_block swi
 
   for (i = 0; i < loop->num_nodes; i++)
     {
-      unsigned nldom;
-      basic_block *ldom;
+      basic_block ldom;
 
-      nldom = get_dominated_by (loops->cfg.dom, body[i], &ldom);
-      for (j = 0; j < nldom; j++)
-	if (!TEST_BIT (seen, ldom[j]->index))
+      for (ldom = first_dom_son (CDI_DOMINATORS, body[i]);
+	   ldom;
+	   ldom = next_dom_son (CDI_DOMINATORS, ldom))
+	if (!TEST_BIT (seen, ldom->index))
 	  {
-	    SET_BIT (seen, ldom[j]->index);
-	    dom_bbs[n_dom_bbs++] = ldom[j];
+	    SET_BIT (seen, ldom->index);
+	    dom_bbs[n_dom_bbs++] = ldom;
 	  }
-      free (ldom);
     }
 
-  iterate_fix_dominators (loops->cfg.dom, dom_bbs, n_dom_bbs);
+  iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, n_dom_bbs);
 
   free (body);
   free (seen);
@@ -990,7 +971,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
       copy_loops_to (loops, orig_loops, n_orig_loops, target);
 
       /* Copy bbs.  */
-      copy_bbs (bbs, n, new_bbs, spec_edges, 2, new_spec_edges, loop, loops);
+      copy_bbs (bbs, n, new_bbs, spec_edges, 2, new_spec_edges, loop);
 
       /* Note whether the blocks and edges belong to an irreducible loop.  */
       if (add_irreducible_flag)
@@ -1019,7 +1000,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
 	  redirect_edge_and_branch_force (latch_edge, new_bbs[0]);
 	  redirect_edge_and_branch_force (new_spec_edges[SE_LATCH],
 					  loop->header);
-	  set_immediate_dominator (loops->cfg.dom, new_bbs[0], latch);
+	  set_immediate_dominator (CDI_DOMINATORS, new_bbs[0], latch);
 	  latch = loop->latch = new_bbs[1];
 	  e = latch_edge = new_spec_edges[SE_LATCH];
 	}
@@ -1028,7 +1009,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
 	  redirect_edge_and_branch_force (new_spec_edges[SE_LATCH],
 					  loop->header);
 	  redirect_edge_and_branch_force (e, new_bbs[0]);
-	  set_immediate_dominator (loops->cfg.dom, new_bbs[0], e->src);
+	  set_immediate_dominator (CDI_DOMINATORS, new_bbs[0], e->src);
 	  e = new_spec_edges[SE_LATCH];
 	}
 
@@ -1056,7 +1037,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
   
   /* Update the original loop.  */
   if (!is_latch)
-    set_immediate_dominator (loops->cfg.dom, e->dest, e->src);
+    set_immediate_dominator (CDI_DOMINATORS, e->dest, e->src);
   if (flags & DLTHE_FLAG_UPDATE_FREQ)
     {
       scale_bbs_frequencies (bbs, n, scale_main, REG_BR_PROB_BASE);
@@ -1070,15 +1051,15 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
       int n_dom_bbs,j;
 
       bb = bbs[i];
-      n_dom_bbs = get_dominated_by (loops->cfg.dom, bb, &dom_bbs);
+      n_dom_bbs = get_dominated_by (CDI_DOMINATORS, bb, &dom_bbs);
       for (j = 0; j < n_dom_bbs; j++)
 	{
 	  dominated = dom_bbs[j];
 	  if (flow_bb_inside_loop_p (loop, dominated))
 	    continue;
 	  dom_bb = nearest_common_dominator (
-			loops->cfg.dom, first_active[i], first_active_latch);
-          set_immediate_dominator (loops->cfg.dom, dominated, dom_bb);
+			CDI_DOMINATORS, first_active[i], first_active_latch);
+          set_immediate_dominator (CDI_DOMINATORS, dominated, dom_bb);
 	}
       free (dom_bbs);
     }
@@ -1094,7 +1075,7 @@ duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
    entry; otherwise we also force preheader block to have only one successor.
    The function also updates dominators stored in DOM.  */
 static basic_block
-create_preheader (struct loop *loop, dominance_info dom, int flags)
+create_preheader (struct loop *loop, int flags)
 {
   edge e, fallthru;
   basic_block dummy;
@@ -1141,7 +1122,7 @@ create_preheader (struct loop *loop, dominance_info dom, int flags)
     if (ploop->latch == dummy)
       ploop->latch = fallthru->dest;
 
-  add_to_dominance_info (dom, fallthru->dest);
+  add_to_dominance_info (CDI_DOMINATORS, fallthru->dest);
 
   /* Redirect edges.  */
   for (e = dummy->pred; e; e = e->pred_next)
@@ -1159,15 +1140,15 @@ create_preheader (struct loop *loop, dominance_info dom, int flags)
   jump = redirect_edge_and_branch_force (e, loop->header);
   if (jump)
     {
-      add_to_dominance_info (dom, jump);
-      set_immediate_dominator (dom, jump, src);
+      add_to_dominance_info (CDI_DOMINATORS, jump);
+      set_immediate_dominator (CDI_DOMINATORS, jump, src);
       add_bb_to_loop (jump, loop);
       loop->latch = jump;
     }
 
   /* Update structures.  */
-  redirect_immediate_dominators (dom, dummy, loop->header);
-  set_immediate_dominator (dom, loop->header, dummy);
+  redirect_immediate_dominators (CDI_DOMINATORS, dummy, loop->header);
+  set_immediate_dominator (CDI_DOMINATORS, loop->header, dummy);
   loop->header->loop_father = loop;
   add_bb_to_loop (dummy, cloop);
   if (rtl_dump_file)
@@ -1184,7 +1165,7 @@ create_preheaders (struct loops *loops, int flags)
 {
   unsigned i;
   for (i = 1; i < loops->num; i++)
-    create_preheader (loops->parray[i], loops->cfg.dom, flags);
+    create_preheader (loops->parray[i], flags);
   loops->state |= LOOPS_HAVE_PREHEADERS;
 }
 
@@ -1207,7 +1188,7 @@ force_single_succ_latches (struct loops *loops)
       for (e = loop->header->pred; e->src != loop->latch; e = e->pred_next)
 	continue;
 
-      loop_split_edge_with (e, NULL_RTX, loops);
+      loop_split_edge_with (e, NULL_RTX);
     }
   loops->state |= LOOPS_HAVE_SIMPLE_LATCHES;
 }
@@ -1217,7 +1198,7 @@ force_single_succ_latches (struct loops *loops)
    be ok after this function.  The created block is placed on correct place
    in LOOPS structure and its dominator is set.  */
 basic_block
-loop_split_edge_with (edge e, rtx insns, struct loops *loops)
+loop_split_edge_with (edge e, rtx insns)
 {
   basic_block src, dest, new_bb;
   struct loop *loop_c;
@@ -1231,7 +1212,7 @@ loop_split_edge_with (edge e, rtx insns, struct loops *loops)
   /* Create basic block for it.  */
 
   new_bb = split_edge (e);
-  add_to_dominance_info (loops->cfg.dom, new_bb);
+  add_to_dominance_info (CDI_DOMINATORS, new_bb);
   add_bb_to_loop (new_bb, loop_c);
   new_bb->flags = insns ? BB_SUPERBLOCK : 0;
 
@@ -1245,9 +1226,9 @@ loop_split_edge_with (edge e, rtx insns, struct loops *loops)
   if (insns)
     emit_insn_after (insns, BB_END (new_bb));
 
-  set_immediate_dominator (loops->cfg.dom, new_bb, src);
-  set_immediate_dominator (loops->cfg.dom, dest,
-    recount_dominator (loops->cfg.dom, dest));
+  set_immediate_dominator (CDI_DOMINATORS, new_bb, src);
+  set_immediate_dominator (CDI_DOMINATORS, dest,
+			   recount_dominator (CDI_DOMINATORS, dest));
 
   if (dest->loop_father->latch == src)
     dest->loop_father->latch = new_bb;

gcc/dominance.c

@@ -43,16 +43,8 @@
 #include "errors.h"
 #include "et-forest.h"
 
-struct dominance_info
-{
-  et_forest_t forest;
-  varray_type varray;
-};
-
-#define BB_NODE(info, bb) \
-  ((et_forest_node_t)VARRAY_GENERIC_PTR ((info)->varray, (bb)->index + 2))
-#define SET_BB_NODE(info, bb, node) \
-  (VARRAY_GENERIC_PTR ((info)->varray, (bb)->index + 2) = (node))
+/* Whether the dominators and the postdominators are available.  */
+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
@@ -124,7 +116,7 @@ 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);
-void debug_dominance_info (dominance_info);
+void debug_dominance_info (enum cdi_direction);
 
 /* Helper macro for allocating and initializing an array,
    for aesthetic reasons.  */
@@ -526,172 +518,250 @@ calc_idoms (struct dom_info *di, enum cdi_direction reverse)
       di->dom[v] = di->dom[di->dom[v]];
 }
 
-/* The main entry point into this module.  IDOM is an integer array with room
-   for last_basic_block integers, DOMS is a preallocated sbitmap array having
-   room for last_basic_block^2 bits, and POST is true if the caller wants to
-   know post-dominators.
+/* Assign dfs numbers starting from NUM to NODE and its sons.  */
+
+static void
+assign_dfs_numbers (struct et_node *node, int *num)
+{
+  struct et_node *son;
+
+  node->dfs_num_in = (*num)++;
+
+  if (node->son)
+    {
+      assign_dfs_numbers (node->son, num);
+      for (son = node->son->right; son != node->son; son = son->right)
+      assign_dfs_numbers (son, num);
+    }
 
-   On return IDOM[i] will be the BB->index of the immediate (post) dominator
-   of basic block i, and DOMS[i] will have set bit j if basic block j is a
-   (post)dominator for block i.
+  node->dfs_num_out = (*num)++;
+}
 
-   Either IDOM or DOMS may be NULL (meaning the caller is not interested in
-   immediate resp. all dominators).  */
+/* Compute the data neccesary for fast resolving of dominator queries in a
+   static dominator tree.  */
 
-dominance_info
-calculate_dominance_info (enum cdi_direction reverse)
+static void
+compute_dom_fast_query (enum cdi_direction dir)
+{
+  int num = 0;
+  basic_block bb;
+
+  if (dom_computed[dir] < DOM_NO_FAST_QUERY)
+    abort ();
+
+  if (dom_computed[dir] == DOM_OK)
+    return;
+
+  FOR_ALL_BB (bb)
+    {
+      if (!bb->dom[dir]->father)
+      assign_dfs_numbers (bb->dom[dir], &num);
+    }
+
+  dom_computed[dir] = DOM_OK;
+}
+
+/* The main entry point into this module.  DIR is set depending on whether
+   we want to compute dominators or postdominators.  */
+
+void
+calculate_dominance_info (enum cdi_direction dir)
 {
   struct dom_info di;
-  dominance_info info;
   basic_block b;
 
-  /* Allocate structure for dominance information.  */
-  info = xmalloc (sizeof (struct dominance_info));
-  info->forest = et_forest_create ();
-  VARRAY_GENERIC_PTR_INIT (info->varray, last_basic_block + 3, "dominance info");
+  if (dom_computed[dir] == DOM_OK)
+    return;
 
-  /* Add the two well-known basic blocks.  */
-  SET_BB_NODE (info, ENTRY_BLOCK_PTR, et_forest_add_node (info->forest,
-							  ENTRY_BLOCK_PTR));
-  SET_BB_NODE (info, EXIT_BLOCK_PTR, et_forest_add_node (info->forest,
-							 EXIT_BLOCK_PTR));
-  FOR_EACH_BB (b)
-    SET_BB_NODE (info, b, et_forest_add_node (info->forest, b));
+  if (dom_computed[dir] != DOM_NO_FAST_QUERY)
+    {
+      if (dom_computed[dir] != DOM_NONE)
+      free_dominance_info (dir);
 
-  init_dom_info (&di);
-  calc_dfs_tree (&di, reverse);
-  calc_idoms (&di, reverse);
+      FOR_ALL_BB (b)
+	{
+	  b->dom[dir] = et_new_tree (b);
+	}
 
+      init_dom_info (&di);
+      calc_dfs_tree (&di, dir);
+      calc_idoms (&di, dir);
 
       FOR_EACH_BB (b)
 	{
 	  TBB d = di.dom[di.dfs_order[b->index]];
 
 	  if (di.dfs_to_bb[d])
-        et_forest_add_edge (info->forest, BB_NODE (info, di.dfs_to_bb[d]), BB_NODE (info, b));
+	    et_set_father (b->dom[dir], di.dfs_to_bb[d]->dom[dir]);
 	}
 
       free_dom_info (&di);
-  return info;
+      dom_computed[dir] = DOM_NO_FAST_QUERY;
+    }
+
+  compute_dom_fast_query (dir);
 }
 
-/* Free dominance information.  */
+/* Free dominance information for direction DIR.  */
 void
-free_dominance_info (dominance_info info)
+free_dominance_info (enum cdi_direction dir)
 {
   basic_block bb;
 
-  /* Allow users to create new basic block without setting up the dominance
-     information for them.  */
-  FOR_EACH_BB (bb)
-    if (bb->index < (int)(info->varray->num_elements - 2)
-	&& BB_NODE (info, bb))
-      delete_from_dominance_info (info, bb);
-  delete_from_dominance_info (info, ENTRY_BLOCK_PTR);
-  delete_from_dominance_info (info, EXIT_BLOCK_PTR);
-  et_forest_delete (info->forest);
-  VARRAY_GROW (info->varray, 0);
-  free (info);
+  if (!dom_computed[dir])
+    return;
+
+  FOR_ALL_BB (bb)
+    {
+      delete_from_dominance_info (dir, bb);
+    }
+
+  dom_computed[dir] = DOM_NONE;
 }
 
 /* Return the immediate dominator of basic block BB.  */
 basic_block
-get_immediate_dominator (dominance_info dom, basic_block bb)
+get_immediate_dominator (enum cdi_direction dir, basic_block bb)
 {
-  return et_forest_node_value (dom->forest,
-			       et_forest_parent (dom->forest,
-						 BB_NODE (dom, bb)));
+  struct et_node *node = bb->dom[dir];
+
+  if (!dom_computed[dir])
+    abort ();
+
+  if (!node->father)
+    return NULL;
+
+  return node->father->data; 
 }
 
 /* Set the immediate dominator of the block possibly removing
    existing edge.  NULL can be used to remove any edge.  */
 inline void
-set_immediate_dominator (dominance_info dom, basic_block bb, basic_block dominated_by)
+set_immediate_dominator (enum cdi_direction dir, basic_block bb,
+			 basic_block dominated_by)
 {
-  void *aux_bb_node;
-  et_forest_node_t bb_node = BB_NODE (dom, bb);
+  struct et_node *node = bb->dom[dir];
 
-  aux_bb_node = et_forest_parent (dom->forest, bb_node);
-  if (aux_bb_node)
-    et_forest_remove_edge (dom->forest, aux_bb_node, bb_node);
-  if (dominated_by != NULL)
-    {
-      if (bb == dominated_by)
-	abort ();
-      if (!et_forest_add_edge (dom->forest, BB_NODE (dom, dominated_by), bb_node))
+  if (!dom_computed[dir])
     abort ();
+
+  if (node->father)
+    {
+      if (node->father->data == dominated_by)
+      return;
+      et_split (node);
     }
+
+  if (dominated_by)
+    et_set_father (node, dominated_by->dom[dir]);
+
+  if (dom_computed[dir] == DOM_OK)
+    dom_computed[dir] = DOM_NO_FAST_QUERY;
 }
 
-/* Store all basic blocks dominated by BB into BBS and return their number.  */
+/* Store all basic blocks immediatelly dominated by BB into BBS and return
+   their number.  */
 int
-get_dominated_by (dominance_info dom, basic_block bb, basic_block **bbs)
+get_dominated_by (enum cdi_direction dir, basic_block bb, basic_block **bbs)
 {
-  int n, i;
+  int n;
+  struct et_node *node = bb->dom[dir], *son = node->son, *ason;
+
+  if (!dom_computed[dir])
+    abort ();
+
+  if (!son)
+    {
+      *bbs = NULL;
+      return 0;
+    }
+
+  for (ason = son->right, n = 1; ason != son; ason = ason->right)
+    n++;
+
+  *bbs = xmalloc (n * sizeof (basic_block));
+  (*bbs)[0] = son->data;
+  for (ason = son->right, n = 1; ason != son; ason = ason->right)
+    (*bbs)[n++] = ason->data;
 
-  *bbs = xmalloc (n_basic_blocks * sizeof (basic_block));
-  n = et_forest_enumerate_sons (dom->forest, BB_NODE (dom, bb), (et_forest_node_t *)*bbs);
-  for (i = 0; i < n; i++)
-   (*bbs)[i] = et_forest_node_value (dom->forest, (et_forest_node_t)(*bbs)[i]);
   return n;
 }
 
 /* Redirect all edges pointing to BB to TO.  */
 void
-redirect_immediate_dominators (dominance_info dom, basic_block bb, basic_block to)
+redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
+			       basic_block to)
 {
-  et_forest_node_t *bbs = xmalloc (n_basic_blocks * sizeof (basic_block));
-  et_forest_node_t node = BB_NODE (dom, bb);
-  et_forest_node_t node2 = BB_NODE (dom, to);
-  int n = et_forest_enumerate_sons (dom->forest, node, bbs);
-  int i;
+  struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
 
-  for (i = 0; i < n; i++)
+  if (!dom_computed[dir])
+    abort ();
+
+  if (!bb_node->son)
+    return;
+
+  while (bb_node->son)
     {
-      et_forest_remove_edge (dom->forest, node, bbs[i]);
-      et_forest_add_edge (dom->forest, node2, bbs[i]);
+      son = bb_node->son;
+
+      et_split (son);
+      et_set_father (son, to_node);
     }
-  free (bbs);
+
+  if (dom_computed[dir] == DOM_OK)
+    dom_computed[dir] = DOM_NO_FAST_QUERY;
 }
 
 /* Find first basic block in the tree dominating both BB1 and BB2.  */
 basic_block
-nearest_common_dominator (dominance_info dom, basic_block bb1, basic_block bb2)
+nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 {
+  if (!dom_computed[dir])
+    abort ();
+
   if (!bb1)
     return bb2;
   if (!bb2)
     return bb1;
-  return et_forest_node_value (dom->forest,
-			       et_forest_common_ancestor (dom->forest,
-							  BB_NODE (dom, bb1),
-							  BB_NODE (dom,
-								   bb2)));
+
+  return et_nca (bb1->dom[dir], bb2->dom[dir])->data;
 }
 
 /* Return TRUE in case BB1 is dominated by BB2.  */
 bool
-dominated_by_p (dominance_info dom, basic_block bb1, basic_block bb2)
+dominated_by_p (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 {
-  return nearest_common_dominator (dom, bb1, bb2) == bb2;
+  struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
+
+  if (!dom_computed[dir])
+    abort ();
+
+  if (dom_computed[dir] == DOM_OK)
+    return (n1->dfs_num_in >= n2->dfs_num_in
+	    && n1->dfs_num_out <= n2->dfs_num_out);
+
+  return et_below (n1, n2);
 }
 
 /* Verify invariants of dominator structure.  */
 void
-verify_dominators (dominance_info dom)
+verify_dominators (enum cdi_direction dir)
 {
   int err = 0;
   basic_block bb;
 
+  if (!dom_computed[dir])
+    abort ();
+
   FOR_EACH_BB (bb)
     {
       basic_block dom_bb;
 
-      dom_bb = recount_dominator (dom, bb);
-      if (dom_bb != get_immediate_dominator (dom, bb))
+      dom_bb = recount_dominator (dir, bb);
+      if (dom_bb != get_immediate_dominator (dir, bb))
 	{
 	  error ("dominator of %d should be %d, not %d",
-	   bb->index, dom_bb->index, get_immediate_dominator(dom, bb)->index);
+	   bb->index, dom_bb->index, get_immediate_dominator(dir, bb)->index);
 	  err = 1;
 	}
     }
@@ -701,15 +771,18 @@ verify_dominators (dominance_info dom)
 
 /* Recount dominator of BB.  */
 basic_block
-recount_dominator (dominance_info dom, basic_block bb)
+recount_dominator (enum cdi_direction dir, basic_block bb)
 {
    basic_block dom_bb = NULL;
    edge e;
 
+  if (!dom_computed[dir])
+    abort ();
+
    for (e = bb->pred; e; e = e->pred_next)
      {
-       if (!dominated_by_p (dom, e->src, bb))
-         dom_bb = nearest_common_dominator (dom, dom_bb, e->src);
+       if (!dominated_by_p (dir, e->src, bb))
+         dom_bb = nearest_common_dominator (dir, dom_bb, e->src);
      }
 
    return dom_bb;
@@ -718,50 +791,85 @@ recount_dominator (dominance_info dom, basic_block bb)
 /* Iteratively recount dominators of BBS. The change is supposed to be local
    and not to grow further.  */
 void
-iterate_fix_dominators (dominance_info dom, basic_block *bbs, int n)
+iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
 {
   int i, changed = 1;
   basic_block old_dom, new_dom;
 
+  if (!dom_computed[dir])
+    abort ();
+
   while (changed)
     {
       changed = 0;
       for (i = 0; i < n; i++)
 	{
-	  old_dom = get_immediate_dominator (dom, bbs[i]);
-	  new_dom = recount_dominator (dom, bbs[i]);
+	  old_dom = get_immediate_dominator (dir, bbs[i]);
+	  new_dom = recount_dominator (dir, bbs[i]);
 	  if (old_dom != new_dom)
 	    {
 	      changed = 1;
-	      set_immediate_dominator (dom, bbs[i], new_dom);
+	      set_immediate_dominator (dir, bbs[i], new_dom);
 	    }
 	}
     }
 }
 
 void
-add_to_dominance_info (dominance_info dom, basic_block bb)
+add_to_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  VARRAY_GROW (dom->varray, last_basic_block + 3);
-#ifdef ENABLE_CHECKING
-  if (BB_NODE (dom, bb))
+  if (!dom_computed[dir])
+    abort ();
+
+  if (bb->dom[dir])
     abort ();
-#endif
-  SET_BB_NODE (dom, bb, et_forest_add_node (dom->forest, bb));
+
+  bb->dom[dir] = et_new_tree (bb);
+
+  if (dom_computed[dir] == DOM_OK)
+    dom_computed[dir] = DOM_NO_FAST_QUERY;
 }
 
 void
-delete_from_dominance_info (dominance_info dom, basic_block bb)
+delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  et_forest_remove_node (dom->forest, BB_NODE (dom, bb));
-  SET_BB_NODE (dom, bb, NULL);
+  if (!dom_computed[dir])
+    abort ();
+
+  et_free_tree (bb->dom[dir]);
+  bb->dom[dir] = NULL;
+
+  if (dom_computed[dir] == DOM_OK)
+    dom_computed[dir] = DOM_NO_FAST_QUERY;
+}
+
+/* Returns the first son of BB in the dominator or postdominator tree
+   as determined by DIR.  */
+
+basic_block
+first_dom_son (enum cdi_direction dir, basic_block bb)
+{
+  struct et_node *son = bb->dom[dir]->son;
+
+  return son ? son->data : NULL;
+}
+
+/* Returns the next dominance son after BB in the dominator or postdominator
+   tree as determined by DIR, or NULL if it was the last one.  */
+
+basic_block
+next_dom_son (enum cdi_direction dir, basic_block bb)
+{
+  struct et_node *next = bb->dom[dir]->right;
+
+  return next->father->son == next ? NULL : next->data;
 }
 
 void
-debug_dominance_info (dominance_info dom)
+debug_dominance_info (enum cdi_direction dir)
 {
   basic_block bb, bb2;
   FOR_EACH_BB (bb)
-    if ((bb2 = get_immediate_dominator (dom, bb)))
+    if ((bb2 = get_immediate_dominator (dir, bb)))
       fprintf (stderr, "%i %i\n", bb->index, bb2->index);
 }

gcc/et-forest.c

@@ -30,638 +30,714 @@ Boston, MA 02111-1307, USA.
 #include "et-forest.h"
 #include "alloc-pool.h"
 
-struct et_forest_occurrence;
-typedef struct et_forest_occurrence* et_forest_occurrence_t;
+/* We do not enable this with ENABLE_CHECKING, since it is awfully slow.  */
+#undef DEBUG_ET
 
-/* The ET-forest type.  */
-struct et_forest
-{
-  /* Linked list of nodes is used to destroy the structure.  */
-  int nnodes;
-  alloc_pool node_pool;
-  alloc_pool occur_pool;
-};
+#ifdef DEBUG_ET
+#include "basic-block.h"
+#endif
 
-/* Single occurrence of node in ET-forest.
-   A single node may have multiple occurrences.
- */
-struct et_forest_occurrence
+/* The occurence of a node in the et tree.  */
+struct et_occ
 {
-  /* Parent in the splay-tree.  */
-  et_forest_occurrence_t parent;
-
-  /* Children in the splay-tree.  */
-  et_forest_occurrence_t left, right;
-
-  /* Counts of vertices in the two splay-subtrees.  */
-  int count_left, count_right;
-
-  /* Next occurrence of this node in the sequence.  */
-  et_forest_occurrence_t next;
-
-  /* The node, which this occurrence is of.  */
-  et_forest_node_t node;
+  struct et_node *of;		/* The node.  */
+
+  struct et_occ *parent;	/* Parent in the splay-tree.  */
+  struct et_occ *prev;		/* Left son in the splay-tree.  */
+  struct et_occ *next;		/* Right son in the splay-tree.  */
+
+  int depth;			/* The depth of the node is the sum of depth
+				   fields on the path to the root.  */
+  int min;			/* The minimum value of the depth in the subtree
+				   is obtained by adding sum of depth fields
+				   on the path to the root.  */
+  struct et_occ *min_occ;	/* The occurence in the subtree with the minimal
+				   depth.  */
 };
 
+static alloc_pool et_nodes;
+static alloc_pool et_occurences;
 
-/* ET-forest node.  */
-struct et_forest_node
-{
-  et_forest_t forest;
-  void *value;
+/* Changes depth of OCC to D.  */
 
-  /* First and last occurrence of this node in the sequence.  */
-  et_forest_occurrence_t first, last;
-};
+static inline void
+set_depth (struct et_occ *occ, int d)
+{
+  if (!occ)
+    return;
 
+  occ->min += d - occ->depth;
+  occ->depth = d;
+}
 
-static et_forest_occurrence_t splay (et_forest_occurrence_t);
-static void remove_all_occurrences (et_forest_t, et_forest_node_t);
-static inline et_forest_occurrence_t find_leftmost_node
-  (et_forest_occurrence_t);
-static inline et_forest_occurrence_t find_rightmost_node
-  (et_forest_occurrence_t);
-static int calculate_value (et_forest_occurrence_t);
+/* Adds D to the depth of OCC.  */
 
-/* Return leftmost node present in the tree roted by OCC.  */
-static inline et_forest_occurrence_t
-find_leftmost_node (et_forest_occurrence_t occ)
+static inline void
+set_depth_add (struct et_occ *occ, int d)
 {
-  while (occ->left)
-    occ = occ->left;
+  if (!occ)
+    return;
 
-  return occ;
+  occ->min += d;
+  occ->depth += d;
 }
 
-/* Return rightmost node present in the tree roted by OCC.  */
-static inline et_forest_occurrence_t
-find_rightmost_node (et_forest_occurrence_t occ)
+/* Sets prev field of OCC to P.  */
+
+static inline void
+set_prev (struct et_occ *occ, struct et_occ *t)
 {
-  while (occ->right)
-    occ = occ->right;
-  return occ;
+#ifdef DEBUG_ET
+  if (occ == t)
+    abort ();
+#endif
+
+  occ->prev = t;
+  if (t)
+    t->parent = occ;
 }
 
+/* Sets next field of OCC to P.  */
 
-/* Operation splay for splay tree structure representing occurrences.  */
-static et_forest_occurrence_t
-splay (et_forest_occurrence_t node)
+static inline void
+set_next (struct et_occ *occ, struct et_occ *t)
 {
-  et_forest_occurrence_t parent;
-  et_forest_occurrence_t grandparent;
-
-  while (1)
-    {
-      parent = node->parent;
+#ifdef DEBUG_ET
+  if (occ == t)
+    abort ();
+#endif
 
-      if (! parent)
-	return node;  /* node == root.  */
+  occ->next = t;
+  if (t)
+    t->parent = occ;
+}
 
-      grandparent = parent->parent;
+/* Recompute minimum for occurence OCC.  */
 
-      if (! grandparent)
-	break;
+static inline void
+et_recomp_min (struct et_occ *occ)
+{
+  struct et_occ *mson = occ->prev;
 
-      /* Now there are four possible combinations:  */
+  if (!mson
+      || (occ->next
+	  && mson->min > occ->next->min))
+      mson = occ->next;
 
-      if (node == parent->left)
-	{
-	  if (parent == grandparent->left)
+  if (mson && mson->min < 0)
     {
-	      et_forest_occurrence_t node1, node2;
-	      int count1, count2;
-
-	      node1 = node->right;
-	      count1 = node->count_right;
-	      node2 = parent->right;
-	      count2 = parent->count_right;
-
-	      grandparent->left = node2;
-	      grandparent->count_left = count2;
-	      if (node2)
-		node2->parent = grandparent;
-	      parent->left = node1;
-	      parent->count_left = count1;
-	      if (node1)
-		node1->parent = parent;
-	      parent->right = grandparent;
-	      parent->count_right = count2 + grandparent->count_right + 1;
-	      node->right = parent;
-	      node->count_right = count1 + parent->count_right + 1;
-
-	      node->parent = grandparent->parent;
-	      parent->parent = node;
-	      grandparent->parent = parent;
-
-	      if (node->parent)
-		{
-		  if (node->parent->left == grandparent)
-		    node->parent->left = node;
-		  else
-		    node->parent->right = node;
-		}
+      occ->min = mson->min + occ->depth;
+      occ->min_occ = mson->min_occ;
     }
   else
     {
-	      /* parent == grandparent->right && node == parent->left*/
-	      et_forest_occurrence_t node1, node2;
-	      int count1, count2;
-
-	      node1 = node->left;
-	      count1 = node->count_left;
-	      node2 = node->right;
-	      count2 = node->count_right;
-
-	      grandparent->right = node1;
-	      grandparent->count_right = count1;
-	      if (node1)
-		node1->parent = grandparent;
-	      parent->left = node2;
-	      parent->count_left = count2;
-	      if (node2)
-		node2->parent = parent;
-	      node->left = grandparent;
-	      node->count_left = grandparent->count_left + count1 + 1;
-	      node->right = parent;
-	      node->count_right = parent->count_right + count2 + 1;
-
-	      node->parent = grandparent->parent;
-	      parent->parent = node;
-	      grandparent->parent = node;
-
-	      if (node->parent)
-		{
-		  if (node->parent->left == grandparent)
-		    node->parent->left = node;
-		  else
-		    node->parent->right = node;
-		}
+      occ->min = occ->depth;
+      occ->min_occ = occ;
     }
-	}
-      else
-	{
-	  /* node == parent->right.  */
-	  if (parent == grandparent->left)
-	    {
-	      et_forest_occurrence_t node1, node2;
-	      int count1, count2;
-
-	      node1 = node->left;
-	      count1 = node->count_left;
-	      node2 = node->right;
-	      count2 = node->count_right;
-
-	      parent->right = node1;
-	      parent->count_right = count1;
-	      if (node1)
-		node1->parent = parent;
-	      grandparent->left = node2;
-	      grandparent->count_left = count2;
-	      if (node2)
-		node2->parent = grandparent;
-	      node->left = parent;
-	      node->count_left = parent->count_left + count1 + 1;
-	      node->right = grandparent;
-	      node->count_right = grandparent->count_right + count2 + 1;
-
-	      node->parent = grandparent->parent;
-	      parent->parent = node;
-	      grandparent->parent = node;
-
-	      if (node->parent)
+}
+
+#ifdef DEBUG_ET
+/* Checks whether neighbourhood of OCC seems sane.  */
+
+static void
+et_check_occ_sanity (struct et_occ *occ)
+{
+  if (!occ)
+    return;
+
+  if (occ->parent == occ)
+    abort ();
+
+  if (occ->prev == occ)
+    abort ();
+
+  if (occ->next == occ)
+    abort ();
+
+  if (occ->next && occ->next == occ->prev)
+    abort ();
+
+  if (occ->next)
     {
-		  if (node->parent->left == grandparent)
-		    node->parent->left = node;
-		  else
-		    node->parent->right = node;
-		}
+      if (occ->next == occ->parent)
+	abort ();
+
+      if (occ->next->parent != occ)
+	abort ();
     }
-	  else
-	    {
-	      /* parent == grandparent->right && node == parent->right*/
-	      et_forest_occurrence_t node1, node2;
-	      int count1, count2;
-
-	      node1 = node->left;
-	      count1 = node->count_left;
-	      node2 = parent->left;
-	      count2 = parent->count_left;
-
-	      grandparent->right = node2;
-	      grandparent->count_right = count2;
-	      if (node2)
-		node2->parent = grandparent;
-	      parent->right = node1;
-	      parent->count_right = count1;
-	      if (node1)
-		node1->parent = parent;
-	      parent->left = grandparent;
-	      parent->count_left = count2 + grandparent->count_left + 1;
-	      node->left = parent;
-	      node->count_left = count1 + parent->count_left + 1;
-
-	      node->parent = grandparent->parent;
-	      parent->parent = node;
-	      grandparent->parent = parent;
-
-	      if (node->parent)
+
+  if (occ->prev)
     {
-		  if (node->parent->left == grandparent)
-		    node->parent->left = node;
-		  else
-		    node->parent->right = node;
-		}
-	    }
-	}
+      if (occ->prev == occ->parent)
+	abort ();
 
+      if (occ->prev->parent != occ)
+	abort ();
     }
 
-  /* parent == root.  */
-  /* There are two possible combinations:  */
+  if (occ->parent
+      && occ->parent->prev != occ
+      && occ->parent->next != occ)
+    abort ();
+}
+
+/* Checks whether tree rooted at OCC is sane.  */
 
-  if (node == parent->left)
-    {
-      et_forest_occurrence_t node1;
-      int count1;
-
-      node1 = node->right;
-      count1 = node->count_right;
-
-      parent->left = node1;
-      parent->count_left = count1;
-      if (node1)
-	node1->parent = parent;
-      node->right = parent;
-      node->count_right = parent->count_right + 1 + count1;
-      node->parent = parent->parent;  /* the same as = 0;  */
-      parent->parent = node;
-
-      if (node->parent)
+static void
+et_check_sanity (struct et_occ *occ)
+{
+  et_check_occ_sanity (occ);
+  if (occ->prev)
+    et_check_sanity (occ->prev);
+  if (occ->next)
+    et_check_sanity (occ->next);
+}
+
+/* Checks whether tree containing OCC is sane.  */
+
+static void
+et_check_tree_sanity (struct et_occ *occ)
+{
+  while (occ->parent)
+    occ = occ->parent;
+
+  et_check_sanity (occ);
+}
+
+/* For recording the paths.  */
+
+static int len;
+static void *datas[100000];
+static int depths[100000];
+
+/* Records the path represented by OCC, with depth incremented by DEPTH.  */
+
+static int
+record_path_before_1 (struct et_occ *occ, int depth)
+{
+  int mn, m;
+
+  depth += occ->depth;
+  mn = depth;
+
+  if (occ->prev)
     {
-	  if (node->parent->left == parent)
-	    node->parent->left = node;
-	  else
-	    node->parent->right = node;
-	}
+      m = record_path_before_1 (occ->prev, depth); 
+      if (m < mn)
+	mn = m;
     }
-  else
-    {
-      /* node == parent->right.  */
-      et_forest_occurrence_t node1;
-      int count1;
-
-      node1 = node->left;
-      count1 = node->count_left;
-
-      parent->right = node1;
-      parent->count_right = count1;
-      if (node1)
-	node1->parent = parent;
-      node->left = parent;
-      node->count_left = parent->count_left + 1 + count1;
-      node->parent = parent->parent;  /* the same as = 0;  */
-      parent->parent = node;
-
-      if (node->parent)
+
+  fprintf (stderr, "%d (%d); ", ((basic_block) occ->of->data)->index, depth);
+  depths[len] = depth;
+  datas[len] = occ->of;
+  len++;
+
+  if (occ->next)
     {
-	  if (node->parent->left == parent)
-	    node->parent->left = node;
-	  else
-	    node->parent->right = node;
-	}
+      m = record_path_before_1 (occ->next, depth);
+      if (m < mn)
+	mn = m;
     }
 
-  return node;
+  if (mn != occ->min + depth - occ->depth)
+    abort ();
+
+  return mn;
 }
 
-/* Remove all occurrences of the given node before destroying the node.  */
+/* Records the path represented by a tree containing OCC.  */
+
 static void
-remove_all_occurrences (et_forest_t forest, et_forest_node_t forest_node)
+record_path_before (struct et_occ *occ)
 {
-  et_forest_occurrence_t first = forest_node->first;
-  et_forest_occurrence_t last = forest_node->last;
-  et_forest_occurrence_t node;
+  while (occ->parent)
+    occ = occ->parent;
+
+  len = 0;
+  record_path_before_1 (occ, 0);
+  fprintf (stderr, "\n");
+}
 
-  splay (first);
+/* Checks whether the path represented by OCC, with depth incremented by DEPTH,
+   was not changed since the last recording.  */
 
-  if (first->left)
-    first->left->parent = 0;
-  if (first->right)
-    first->right->parent = 0;
+static int
+check_path_after_1 (struct et_occ *occ, int depth)
+{
+  int mn, m;
 
-  if (last != first)
-    {
-      splay (last);
+  depth += occ->depth;
+  mn = depth;
 
-      if (last->left)
-	last->left->parent = 0;
-      if (last->right)
-	last->right->parent = 0;
+  if (occ->next)
+    {
+      m = check_path_after_1 (occ->next, depth); 
+      if (m < mn)
+	mn =  m;
     }
 
-  if (last->right && first->left) /* actually, first->left would suffice.  */
+  len--;
+  if (depths[len] != depth
+      || datas[len] != occ->of)
+    abort ();
+
+  if (occ->prev)
     {
-      /* Need to join them.  */
-      et_forest_occurrence_t prev_node, next_node;
-
-      prev_node = splay (find_rightmost_node (first->left));
-      next_node = splay (find_leftmost_node (last->right));
-      /* prev_node and next_node are consecutive occurrences
-	 of the same node.  */
-      if (prev_node->next != next_node)
+      m = check_path_after_1 (occ->prev, depth);
+      if (m < mn)
+	mn =  m;
+    }
+
+  if (mn != occ->min + depth - occ->depth)
+    abort ();
+
+  return mn;
+}
+
+/* Checks whether the path represented by a tree containing OCC was
+   not changed since the last recording.  */
+
+static void
+check_path_after (struct et_occ *occ)
+{
+  while (occ->parent)
+    occ = occ->parent;
+
+  check_path_after_1 (occ, 0);
+  if (len != 0)
     abort ();
+}
 
-      prev_node->right = next_node->right;
-      prev_node->count_right = next_node->count_right;
-      prev_node->next = next_node->next;
-      if (prev_node->right)
-	prev_node->right->parent = prev_node;
+#endif
 
-      if (prev_node->node->last == next_node)
-	prev_node->node->last = prev_node;
+/* Splay the occurence OCC to the root of the tree.  */
 
-      pool_free (forest->occur_pool, next_node);
-    }
+static inline void
+et_splay (struct et_occ *occ)
+{
+  struct et_occ *f, *gf, *ggf;
+  int occ_depth, f_depth, gf_depth;
 
-  if (first != last)
-    {
-      node = first->next;
+#ifdef DEBUG_ET
+  record_path_before (occ);
+  et_check_tree_sanity (occ);
+#endif
  
-      while (node != last)
+  while (occ->parent)
     {
-	  et_forest_occurrence_t next_node;
+      occ_depth = occ->depth;
+
+      f = occ->parent;
+      f_depth = f->depth;
 
-	  splay (node);
+      gf = f->parent;
 
-	  if (node->left)
-	    node->left->parent = 0;
-	  if (node->right)
-	    node->right->parent = 0;
+      if (!gf)
+	{
+	  set_depth_add (occ, f_depth);
+	  occ->min_occ = f->min_occ;
+	  occ->min = f->min;
 
-	  next_node = node->next;
-	  pool_free (forest->occur_pool, node);
-	  node = next_node;
+	  if (f->prev == occ)
+	    {
+	      /* zig */
+	      set_prev (f, occ->next);
+	      set_next (occ, f);
+	      set_depth_add (f->prev, occ_depth);
+	    }
+	  else
+	    {
+	      /* zag */
+	      set_next (f, occ->prev);
+	      set_prev (occ, f);
+	      set_depth_add (f->next, occ_depth);
 	    }
+	  set_depth (f, -occ_depth);
+	  occ->parent = NULL;
+
+	  et_recomp_min (f);
+#ifdef DEBUG_ET
+	  et_check_tree_sanity (occ);
+	  check_path_after (occ);
+#endif
+	  return;
 	}
 
-  pool_free (forest->occur_pool, first);
-  if (first != last)
-    pool_free (forest->occur_pool, last);
-}
+      gf_depth = gf->depth;
 
-/* Calculate ET value of the given node.  */
-static inline int
-calculate_value (et_forest_occurrence_t node)
-{
-  int value = node->count_left;
+      set_depth_add (occ, f_depth + gf_depth);
+      occ->min_occ = gf->min_occ;
+      occ->min = gf->min;
 
-  while (node->parent)
-    {
-      if (node == node->parent->right)
-	value += node->parent->count_left + 1;
+      ggf = gf->parent;
 
-      node = node->parent;
+      if (gf->prev == f)
+	{
+	  if (f->prev == occ)
+	    {
+	      /* zig zig */
+	      set_prev (gf, f->next);
+	      set_prev (f, occ->next);
+	      set_next (occ, f);
+	      set_next (f, gf);
+
+	      set_depth (f, -occ_depth);
+	      set_depth_add (f->prev, occ_depth);
+	      set_depth (gf, -f_depth);
+	      set_depth_add (gf->prev, f_depth);
+	    }
+	  else
+	    {
+	      /* zag zig */
+	      set_prev (gf, occ->next);
+	      set_next (f, occ->prev);
+	      set_prev (occ, f);
+	      set_next (occ, gf);
+
+	      set_depth (f, -occ_depth);
+	      set_depth_add (f->next, occ_depth);
+	      set_depth (gf, -occ_depth - f_depth);
+	      set_depth_add (gf->prev, occ_depth + f_depth);
+	    }
+	}
+      else
+	{
+	  if (f->prev == occ)
+	    {
+	      /* zig zag */
+	      set_next (gf, occ->prev);
+	      set_prev (f, occ->next);
+	      set_prev (occ, gf);
+	      set_next (occ, f);
+
+	      set_depth (f, -occ_depth);
+	      set_depth_add (f->prev, occ_depth);
+	      set_depth (gf, -occ_depth - f_depth);
+	      set_depth_add (gf->next, occ_depth + f_depth);
+	    }
+	  else
+	    {
+	      /* zag zag */
+	      set_next (gf, f->prev);
+	      set_next (f, occ->prev);
+	      set_prev (occ, f);
+	      set_prev (f, gf);
+
+	      set_depth (f, -occ_depth);
+	      set_depth_add (f->next, occ_depth);
+	      set_depth (gf, -f_depth);
+	      set_depth_add (gf->next, f_depth);
+	    }
 	}
 
-  return value;
-}
+      occ->parent = ggf;
+      if (ggf)
+	{
+	  if (ggf->prev == gf)
+	    ggf->prev = occ;
+	  else
+	    ggf->next = occ;
+	}
 
+      et_recomp_min (gf);
+      et_recomp_min (f);
+#ifdef DEBUG_ET
+      et_check_tree_sanity (occ);
+#endif
+    }
 
+#ifdef DEBUG_ET
+  et_check_sanity (occ);
+  check_path_after (occ);
+#endif
+}
 
+/* Create a new et tree occurence of NODE.  */
 
-/* Create ET-forest structure.  */
-et_forest_t
-et_forest_create (void)
+static struct et_occ *
+et_new_occ (struct et_node *node)
 {
-  et_forest_t forest = xmalloc (sizeof (struct et_forest));
+  struct et_occ *nw;
   
-  forest->nnodes = 0;
-  forest->occur_pool = create_alloc_pool ("et_forest_occurrence pool", sizeof (struct et_forest_occurrence), 300);
-  forest->node_pool = create_alloc_pool ("et_forest_node pool", sizeof (struct et_forest_node), 300);
-  return forest;
-}
+  if (!et_occurences)
+    et_occurences = create_alloc_pool ("et_occ pool", sizeof (struct et_occ), 300);
+  nw = pool_alloc (et_occurences);
 
+  nw->of = node;
+  nw->parent = NULL;
+  nw->prev = NULL;
+  nw->next = NULL;
 
+  nw->depth = 0;
+  nw->min_occ = nw;
+  nw->min = 0;
 
-/* Deallocate the structure.  */
-void
-et_forest_delete (et_forest_t forest)
-{
-  if (forest->nnodes)
-    abort ();
-  free_alloc_pool (forest->occur_pool);
-  free_alloc_pool (forest->node_pool);
-  free (forest);
+  return nw;
 }
 
-/* Create new node with VALUE and return the edge.
-   Return NULL when memory allocation failed.  */
-et_forest_node_t
-et_forest_add_node (et_forest_t forest, void *value)
-{
-  /* Create node with one occurrence.  */
-  et_forest_node_t node;
-  et_forest_occurrence_t occ;
-
-  node = pool_alloc (forest->node_pool);
-  occ = pool_alloc (forest->occur_pool);
-
-  node->first = node->last = occ;
-  node->value = value;
-  forest->nnodes++;
-
-  occ->node = node;
-  occ->left = occ->right = occ->parent = 0;
-  occ->next = 0;
-  occ->count_left = occ->count_right = 0;
-  return node;
-}
+/* Create a new et tree containing DATA.  */
 
-/* Add new edge to the tree, return 1 if successful.
-   0 indicates that creation of the edge will close the cycle in graph.  */
-int
-et_forest_add_edge (et_forest_t forest ATTRIBUTE_UNUSED,
-		    et_forest_node_t parent_node, et_forest_node_t child_node)
+struct et_node *
+et_new_tree (void *data)
 {
-  et_forest_occurrence_t new_occ, parent_occ, child_occ;
+  struct et_node *nw;
   
-  if (! parent_node || ! child_node)
-    abort ();
+  if (!et_nodes)
+    et_nodes = create_alloc_pool ("et_node pool", sizeof (struct et_node), 300);
+  nw = pool_alloc (et_nodes);
+
+  nw->data = data;
+  nw->father = NULL;
+  nw->left = NULL;
+  nw->right = NULL;
+  nw->son = NULL;
+
+  nw->rightmost_occ = et_new_occ (nw);
+  nw->parent_occ = NULL;
 
-  parent_occ = parent_node->first;
-  child_occ = child_node->first;
-
-  splay (parent_occ);
-  splay (child_occ);
-
-  if (parent_occ->parent)
-    return 0; /* Both child and parent are in the same tree.  */
-
-  if (child_occ->left)
-    abort ();  /* child must be root of its containing tree.  */
-
-  new_occ = pool_alloc (forest->occur_pool);
-
-  new_occ->node = parent_node;
-  new_occ->left = child_occ;
-  new_occ->count_left = child_occ->count_right + 1; /* count_left is 0.  */
-  new_occ->right = parent_occ->right;
-  new_occ->count_right = parent_occ->count_right;
-  new_occ->parent = parent_occ;
-  new_occ->next = parent_occ->next;
-  child_occ->parent = new_occ;
-  parent_occ->right = new_occ;
-  parent_occ->count_right = new_occ->count_left + new_occ->count_right + 1;
-  parent_occ->next = new_occ;
-  if (new_occ->right)
-    new_occ->right->parent = new_occ;
-
-  if (parent_node->last == parent_occ)
-    parent_node->last = new_occ;
-  return 1;
+  return nw;
 }
 
-/* Remove NODE from the tree and all connected edges.  */
+/* Releases et tree T.  */
+
 void
-et_forest_remove_node (et_forest_t forest, et_forest_node_t node)
+et_free_tree (struct et_node *t)
 {
-  remove_all_occurrences (forest, node);
-  forest->nnodes--;
+  while (t->son)
+    et_split (t->son);
+
+  if (t->father)
+    et_split (t);
 
-  pool_free (forest->node_pool, node);
+  pool_free (et_occurences, t->rightmost_occ);
+  pool_free (et_nodes, t);
 }
 
-/* Remove edge from the tree, return 1 if successful,
-   0 indicates nonexisting edge.  */
-int
-et_forest_remove_edge (et_forest_t forest ATTRIBUTE_UNUSED,
-		       et_forest_node_t parent_node,
-		       et_forest_node_t child_node)
+/* Sets father of et tree T to FATHER.  */
+
+void
+et_set_father (struct et_node *t, struct et_node *father)
 {
-  et_forest_occurrence_t parent_pre_occ, parent_post_occ;
+  struct et_node *left, *right;
+  struct et_occ *rmost, *left_part, *new_f_occ, *p;
 
-  splay (child_node->first);
+  /* Update the path represented in the splay tree.  */
+  new_f_occ = et_new_occ (father);
 
-  if (! child_node->first->left)
-    return 0;
+  rmost = father->rightmost_occ;
+  et_splay (rmost);
 
-  parent_pre_occ = find_rightmost_node (child_node->first->left);
-  if (parent_pre_occ->node != parent_node)
-    abort ();
+  left_part = rmost->prev;
 
-  splay (parent_pre_occ);
-  parent_pre_occ->right->parent = 0;
+  p = t->rightmost_occ;
+  et_splay (p);
 
-  parent_post_occ = parent_pre_occ->next;
-  splay (parent_post_occ);
+  set_prev (new_f_occ, left_part);
+  set_next (new_f_occ, p);
 
-  parent_post_occ->left->parent = 0;
+  p->depth++;
+  p->min++;
+  et_recomp_min (new_f_occ);
 
-  parent_pre_occ->right = parent_post_occ->right;
-  parent_pre_occ->count_right = parent_post_occ->count_right;
-  if (parent_post_occ->right)
-    parent_post_occ->right->parent = parent_pre_occ;
+  set_prev (rmost, new_f_occ);
 
-  parent_pre_occ->next = parent_post_occ->next;
+  if (new_f_occ->min + rmost->depth < rmost->min)
+    {
+      rmost->min = new_f_occ->min + rmost->depth;
+      rmost->min_occ = new_f_occ->min_occ;
+    }
 
-  if (parent_post_occ == parent_node->last)
-    parent_node->last = parent_pre_occ;
+  t->parent_occ = new_f_occ;
 
-  pool_free (forest->occur_pool, parent_post_occ);
-  return 1;
-}
+  /* Update the tree.  */
+  t->father = father;
+  right = father->son;
+  if (right)
+    left = right->left;
+  else
+    left = right = t;
 
-/* Return the parent of the NODE if any, NULL otherwise.  */
-et_forest_node_t
-et_forest_parent (et_forest_t forest ATTRIBUTE_UNUSED, et_forest_node_t node)
-{
-  splay (node->first);
+  left->right = t;
+  right->left = t;
+  t->left = left;
+  t->right = right;
 
-  if (node->first->left)
-    return find_rightmost_node (node->first->left)->node;
-  else
-    return 0;
+  father->son = t;
+
+#ifdef DEBUG_ET
+  et_check_tree_sanity (rmost);
+  record_path_before (rmost);
+#endif
 }
 
+/* Splits the edge from T to its father.  */
 
-/* Return nearest common ancestor of NODE1 and NODE2.
-   Return NULL of they are in different trees.  */
-et_forest_node_t
-et_forest_common_ancestor (et_forest_t forest ATTRIBUTE_UNUSED,
-			   et_forest_node_t node1, et_forest_node_t node2)
+void
+et_split (struct et_node *t)
 {
-  int value1, value2, max_value;
-  et_forest_node_t ancestor;
+  struct et_node *father = t->father;
+  struct et_occ *r, *l, *rmost, *p_occ;
 
-  if (node1 == node2)
-    return node1;
+  /* Update the path represented by the splay tree.  */
+  rmost = t->rightmost_occ;
+  et_splay (rmost);
 
-  if (! node1 || ! node2)
-    abort ();
+  for (r = rmost->next; r->prev; r = r->prev)
+    continue;
+  et_splay (r); 
+
+  r->prev->parent = NULL;
+  p_occ = t->parent_occ;
+  et_splay (p_occ);
+  t->parent_occ = NULL;
+
+  l = p_occ->prev;
+  p_occ->next->parent = NULL;
 
-  splay (node1->first);
-  splay (node2->first);
+  set_prev (r, l);
 
-  if (! node1->first->parent)  /* The two vertices are in different trees.  */
-    return 0;
+  et_recomp_min (r);
 
-  value2 = calculate_value (node2->first);
-  value1 = calculate_value (node1->first);
+  et_splay (rmost);
+  rmost->depth = 0;
+  rmost->min = 0;
 
-  if (value1 < value2)
+  pool_free (et_occurences, p_occ);
+
+  /* Update the tree.  */
+  if (father->son == t)
+    father->son = t->right;
+  if (father->son == t)
+    father->son = NULL;
+  else
     {
-      ancestor = node1;
-      max_value = value2;
+      t->left->right = t->right;
+      t->right->left = t->left;
+    }
+  t->left = t->right = NULL;
+  t->father = NULL;
+
+#ifdef DEBUG_ET
+  et_check_tree_sanity (rmost);
+  record_path_before (rmost);
+
+  et_check_tree_sanity (r);
+  record_path_before (r);
+#endif
+}
+
+/* Finds the nearest common ancestor of the nodes N1 and N2.  */
+
+struct et_node *
+et_nca (struct et_node *n1, struct et_node *n2)
+{
+  struct et_occ *o1 = n1->rightmost_occ, *o2 = n2->rightmost_occ, *om;
+  struct et_occ *l, *r, *ret;
+  int mn;
+
+  if (n1 == n2)
+    return n1;
+
+  et_splay (o1);
+  l = o1->prev;
+  r = o1->next;
+  if (l)
+    l->parent = NULL;
+  if (r)
+    r->parent = NULL;
+  et_splay (o2);
+
+  if (l == o2 || (l && l->parent != NULL))
+    {
+      ret = o2->next;
+
+      set_prev (o1, o2);
+      if (r)
+	r->parent = o1;
     }
   else
     {
-      ancestor = node2;
-      max_value = value1;
+      ret = o2->prev;
+
+      set_next (o1, o2);
+      if (l)
+	l->parent = o1;
     }
 
-  while (calculate_value (ancestor->last) < max_value)
+  if (0 < o2->depth)
+    {
+      om = o1;
+      mn = o1->depth;
+    }
+  else
     {
-      /* Find parent node.  */
-      splay (ancestor->first);
-      ancestor = find_rightmost_node (ancestor->first->left) ->node;
+      om = o2;
+      mn = o2->depth + o1->depth;
     }
 
-  return ancestor;
-}
+#ifdef DEBUG_ET
+  et_check_tree_sanity (o2);
+#endif
 
-/* Return the value pointer of node set during it's creation.  */
-void *
-et_forest_node_value (et_forest_t forest ATTRIBUTE_UNUSED,
-		      et_forest_node_t node)
-{
-  /* Alloc threading NULL as a special node of the forest.  */
-  if (!node)
-    return NULL;
-  return node->value;
+  if (ret && ret->min + o1->depth + o2->depth < mn)
+    return ret->min_occ->of;
+  else
+    return om->of;
 }
 
-/* Find all sons of NODE and store them into ARRAY allocated by the caller.
-   Return number of nodes found.  */
-int
-et_forest_enumerate_sons (et_forest_t forest ATTRIBUTE_UNUSED,
-			  et_forest_node_t node, et_forest_node_t *array)
+/* Checks whether the node UP is an ancestor of the node DOWN.  */
+
+bool
+et_below (struct et_node *down, struct et_node *up)
 {
-  int n = 0;
-  et_forest_occurrence_t occ = node->first, stop = node->last, occ1;
+  struct et_occ *u = up->rightmost_occ, *d = down->rightmost_occ;
+  struct et_occ *l, *r;
 
-  /* Parent is the rightmost node of the left successor.
-     Look for all occurrences having no right successor
-     and lookup the sons.  */
-  while (occ != stop)
-    {
-      splay (occ);
-      if (occ->right)
+  if (up == down)
+    return true;
+
+  et_splay (u);
+  l = u->prev;
+  r = u->next;
+
+  if (!l)
+    return false;
+
+  l->parent = NULL;
+
+  if (r)
+    r->parent = NULL;
+
+  et_splay (d);
+
+  if (l == d || l->parent != NULL)
     {
-          occ1 = find_leftmost_node (occ->right);
-	  if (occ1->node->first == occ1)
-	    array[n++] = occ1->node;
+      if (r)
+	r->parent = u;
+      set_prev (u, d);
+#ifdef DEBUG_ET
+      et_check_tree_sanity (u);
+#endif
     }
-      occ = occ->next;
+  else
+    {
+      l->parent = u;
+
+      /* In case O1 and O2 are in two different trees, we must just restore the
+	 original state.  */
+      if (r && r->parent != NULL)
+	set_next (u, d);
+      else
+	set_next (u, r);
+
+#ifdef DEBUG_ET
+      et_check_tree_sanity (u);
+#endif
+      return false;
     }
-  return n;
+
+  if (0 >= d->depth)
+    return false;
+
+  return !d->next || d->next->min + d->depth >= 0;
 }

gcc/et-forest.h

@@ -55,26 +55,28 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 extern "C" {
 #endif /* __cplusplus */
 
-typedef struct et_forest *et_forest_t;
-typedef struct et_forest_node *et_forest_node_t;
-
-extern et_forest_t et_forest_create (void);
-
-extern void et_forest_delete (et_forest_t);
-
-extern et_forest_node_t et_forest_add_node (et_forest_t, void *);
-extern int et_forest_add_edge (et_forest_t, et_forest_node_t,
-			       et_forest_node_t);
-extern void et_forest_remove_node (et_forest_t, et_forest_node_t);
-extern int et_forest_remove_edge (et_forest_t, et_forest_node_t,
-				  et_forest_node_t);
-extern et_forest_node_t et_forest_parent (et_forest_t, et_forest_node_t);
-extern et_forest_node_t et_forest_common_ancestor (et_forest_t,
-						   et_forest_node_t,
-						   et_forest_node_t);
-extern void * et_forest_node_value (et_forest_t, et_forest_node_t);
-extern int et_forest_enumerate_sons (et_forest_t, et_forest_node_t,
-				     et_forest_node_t *);
+/* The node representing the node in an et tree.  */
+struct et_node
+{
+  void *data;			/* The data represented by the node.  */
+
+  int dfs_num_in, dfs_num_out;	/* Number of the node in the dfs ordering.  */
+
+  struct et_node *father;	/* Father of the node.  */
+  struct et_node *son;		/* The first of the sons of the node.  */
+  struct et_node *left;
+  struct et_node *right;	/* The brothers of the node.  */
+
+  struct et_occ *rightmost_occ;	/* The rightmost occurence.  */
+  struct et_occ *parent_occ;	/* The occurence of the parent node.  */
+};
+
+struct et_node *et_new_tree (void *data);
+void et_free_tree (struct et_node *);
+void et_set_father (struct et_node *, struct et_node *);
+void et_split (struct et_node *);
+struct et_node *et_nca (struct et_node *, struct et_node *);
+bool et_below (struct et_node *, struct et_node *);
 
 #ifdef __cplusplus
 }

gcc/function.c

@@ -6408,8 +6408,6 @@ allocate_struct_function (tree fndecl)
   DECL_SAVED_INSNS (fndecl) = cfun;
   cfun->decl = fndecl;
 
-  current_function_name = (*lang_hooks.decl_printable_name) (fndecl, 2);
-
   result = DECL_RESULT (fndecl);
   if (aggregate_value_p (result, fndecl))
     {

gcc/function.h

@@ -183,9 +183,6 @@ struct function GTY(())
 
   /* For function.c.  */
 
-  /* Name of this function.  */
-  const char *name;
-
   /* Points to the FUNCTION_DECL of this function.  */
   tree decl;
 
@@ -534,7 +531,6 @@ extern int virtuals_instantiated;
 extern int trampolines_created;
 
 /* For backward compatibility... eventually these should all go away.  */
-#define current_function_name (cfun->name)
 #define current_function_pops_args (cfun->pops_args)
 #define current_function_returns_struct (cfun->returns_struct)
 #define current_function_returns_pcc_struct (cfun->returns_pcc_struct)

gcc/gcse.c

@@ -161,6 +161,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "basic-block.h"
 #include "output.h"
 #include "function.h"
+#include "langhooks.h"
 #include "expr.h"
 #include "except.h"
 #include "ggc.h"
@@ -855,7 +856,8 @@ gcse_main (rtx f, FILE *file)
   if (file)
     {
       fprintf (file, "GCSE of %s: %d basic blocks, ",
-	       current_function_name, n_basic_blocks);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       n_basic_blocks);
       fprintf (file, "%d pass%s, %d bytes\n\n",
 	       pass, pass > 1 ? "es" : "", max_pass_bytes);
     }
@@ -3614,7 +3616,8 @@ one_classic_gcse_pass (int pass)
     {
       fprintf (gcse_file, "\n");
       fprintf (gcse_file, "GCSE of %s, pass %d: %d bytes needed, %d substs,",
-	       current_function_name, pass, bytes_used, gcse_subst_count);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       pass, bytes_used, gcse_subst_count);
       fprintf (gcse_file, "%d insns created\n", gcse_create_count);
     }
 
@@ -4686,7 +4689,8 @@ one_cprop_pass (int pass, int cprop_jumps, int bypass_jumps)
   if (gcse_file)
     {
       fprintf (gcse_file, "CPROP of %s, pass %d: %d bytes needed, ",
-	       current_function_name, pass, bytes_used);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       pass, bytes_used);
       fprintf (gcse_file, "%d const props, %d copy props\n\n",
 	       const_prop_count, copy_prop_count);
     }
@@ -5788,7 +5792,8 @@ one_pre_gcse_pass (int pass)
   if (gcse_file)
     {
       fprintf (gcse_file, "\nPRE GCSE of %s, pass %d: %d bytes needed, ",
-	       current_function_name, pass, bytes_used);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       pass, bytes_used);
       fprintf (gcse_file, "%d substs, %d insns created\n",
 	       gcse_subst_count, gcse_create_count);
     }
@@ -6182,9 +6187,6 @@ static sbitmap *hoist_vbeout;
 /* Hoistable expressions.  */
 static sbitmap *hoist_exprs;
 
-/* Dominator bitmaps.  */
-dominance_info dominators;
-
 /* ??? We could compute post dominators and run this algorithm in
    reverse to perform tail merging, doing so would probably be
    more effective than the tail merging code in jump.c.
@@ -6221,7 +6223,7 @@ free_code_hoist_mem (void)
   sbitmap_vector_free (hoist_exprs);
   sbitmap_vector_free (transpout);
 
-  free_dominance_info (dominators);
+  free_dominance_info (CDI_DOMINATORS);
 }
 
 /* Compute the very busy expressions at entry/exit from each block.
@@ -6270,7 +6272,7 @@ compute_code_hoist_data (void)
   compute_local_properties (transp, comp, antloc, &expr_hash_table);
   compute_transpout ();
   compute_code_hoist_vbeinout ();
-  dominators = calculate_dominance_info (CDI_DOMINATORS);
+  calculate_dominance_info (CDI_DOMINATORS);
   if (gcse_file)
     fprintf (gcse_file, "\n");
 }
@@ -6362,7 +6364,7 @@ hoist_code (void)
       int found = 0;
       int insn_inserted_p;
 
-      domby_len = get_dominated_by (dominators, bb, &domby);
+      domby_len = get_dominated_by (CDI_DOMINATORS, bb, &domby);
       /* Examine each expression that is very busy at the exit of this
 	 block.  These are the potentially hoistable expressions.  */
       for (i = 0; i < hoist_vbeout[bb->index]->n_bits; i++)
@@ -8020,7 +8022,8 @@ bypass_jumps (FILE *file)
   if (file)
     {
       fprintf (file, "BYPASS of %s: %d basic blocks, ",
-	       current_function_name, n_basic_blocks);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       n_basic_blocks);
       fprintf (file, "%d bytes\n\n", bytes_used);
     }
 

gcc/graph.c

@@ -25,9 +25,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "tm.h"
 
 #include "rtl.h"
+#include "tree.h"
 #include "flags.h"
 #include "output.h"
 #include "function.h"
+#include "langhooks.h"
 #include "hard-reg-set.h"
 #include "basic-block.h"
 #include "toplev.h"
@@ -55,7 +57,8 @@ start_fct (FILE *fp)
     case vcg:
       fprintf (fp, "\
 graph: { title: \"%s\"\nfolding: 1\nhidden: 2\nnode: { title: \"%s.0\" }\n",
-	       current_function_name, current_function_name);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2));
       break;
     case no_graph:
       break;
@@ -71,7 +74,8 @@ start_bb (FILE *fp, int bb)
       fprintf (fp, "\
 graph: {\ntitle: \"%s.BB%d\"\nfolding: 1\ncolor: lightblue\n\
 label: \"basic block %d",
-	       current_function_name, bb, bb);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       bb, bb);
       break;
     case no_graph:
       break;
@@ -113,8 +117,9 @@ node_data (FILE *fp, rtx tmp_rtx)
 	case vcg:
 	  fprintf (fp, "\
 edge: { sourcename: \"%s.0\" targetname: \"%s.%d\" }\n",
-		   current_function_name,
-		   current_function_name, XINT (tmp_rtx, 0));
+		   (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+		   (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+		   XINT (tmp_rtx, 0));
 	  break;
 	case no_graph:
 	  break;
@@ -126,7 +131,8 @@ edge: { sourcename: \"%s.0\" targetname: \"%s.%d\" }\n",
     case vcg:
       fprintf (fp, "node: {\n  title: \"%s.%d\"\n  color: %s\n  \
 label: \"%s %d\n",
-	       current_function_name, XINT (tmp_rtx, 0),
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       XINT (tmp_rtx, 0),
 	       GET_CODE (tmp_rtx) == NOTE ? "lightgrey"
 	       : GET_CODE (tmp_rtx) == INSN ? "green"
 	       : GET_CODE (tmp_rtx) == JUMP_INSN ? "darkgreen"
@@ -178,8 +184,11 @@ draw_edge (FILE *fp, int from, int to, int bb_edge, int class)
 	color = "color: green ";
       fprintf (fp,
 	       "edge: { sourcename: \"%s.%d\" targetname: \"%s.%d\" %s",
-	       current_function_name, from,
-	       current_function_name, to, color);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       from,
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2),
+	       to,
+	       color);
       if (class)
 	fprintf (fp, "class: %d ", class);
       fputs ("}\n", fp);
@@ -209,7 +218,7 @@ end_fct (FILE *fp)
     {
     case vcg:
       fprintf (fp, "node: { title: \"%s.999999\" label: \"END\" }\n}\n",
-	       current_function_name);
+	       (*lang_hooks.decl_printable_name) (current_function_decl, 2));
       break;
     case no_graph:
       break;

gcc/ifcvt.c

@@ -84,9 +84,6 @@ static int cond_exec_changed_p;
 /* True if life data ok at present.  */
 static bool life_data_ok;
 
-/* The post-dominator relation on the original block numbers.  */
-static dominance_info post_dominators;
-
 /* Forward references.  */
 static int count_bb_insns (basic_block);
 static rtx first_active_insn (basic_block);
@@ -123,6 +120,7 @@ mark_loop_exit_edges (void)
   edge e;
   
   flow_loops_find (&loops, LOOP_TREE);
+  free_dominance_info (CDI_DOMINATORS);
   
   if (loops.num > 1)
     {
@@ -2105,8 +2103,8 @@ merge_if_block (struct ce_if_block * ce_info)
 	{
 	  bb = fallthru;
 	  fallthru = block_fallthru (bb);
-	  if (post_dominators)
-	    delete_from_dominance_info (post_dominators, bb);
+	  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+	    delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
 	  merge_blocks (combo_bb, bb);
 	  num_true_changes++;
 	}
@@ -2122,8 +2120,8 @@ merge_if_block (struct ce_if_block * ce_info)
       if (combo_bb->global_live_at_end)
 	COPY_REG_SET (combo_bb->global_live_at_end,
 		      then_bb->global_live_at_end);
-      if (post_dominators)
-	delete_from_dominance_info (post_dominators, then_bb);
+      if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+	delete_from_dominance_info (CDI_POST_DOMINATORS, then_bb);
       merge_blocks (combo_bb, then_bb);
       num_true_changes++;
     }
@@ -2133,8 +2131,8 @@ merge_if_block (struct ce_if_block * ce_info)
      get their addresses taken.  */
   if (else_bb)
     {
-      if (post_dominators)
-	delete_from_dominance_info (post_dominators, else_bb);
+      if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+       	delete_from_dominance_info (CDI_POST_DOMINATORS, else_bb);
       merge_blocks (combo_bb, else_bb);
       num_true_changes++;
     }
@@ -2190,8 +2188,8 @@ merge_if_block (struct ce_if_block * ce_info)
 	COPY_REG_SET (combo_bb->global_live_at_end,
 		      join_bb->global_live_at_end);
 
-      if (post_dominators)
-	delete_from_dominance_info (post_dominators, join_bb);
+      if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+	delete_from_dominance_info (CDI_POST_DOMINATORS, join_bb);
       merge_blocks (combo_bb, join_bb);
       num_true_changes++;
     }
@@ -2271,7 +2269,7 @@ find_if_header (basic_block test_bb, int pass)
       && find_cond_trap (test_bb, then_edge, else_edge))
     goto success;
 
-  if (post_dominators
+  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY
       && (! HAVE_conditional_execution || reload_completed))
     {
       if (find_if_case_1 (test_bb, then_edge, else_edge))
@@ -2646,8 +2644,8 @@ find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
   remove_edge (trap_bb == then_bb ? then_edge : else_edge);
   if (trap_bb->pred == NULL)
     {
-      if (post_dominators)
-	delete_from_dominance_info (post_dominators, trap_bb);
+      if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+	delete_from_dominance_info (CDI_POST_DOMINATORS, trap_bb);
       delete_block (trap_bb);
     }
 
@@ -2831,8 +2829,8 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
 
   new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb), else_bb);
   then_bb_index = then_bb->index;
-  if (post_dominators)
-    delete_from_dominance_info (post_dominators, then_bb);
+  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+    delete_from_dominance_info (CDI_POST_DOMINATORS, then_bb);
   delete_block (then_bb);
 
   /* Make rest of code believe that the newly created block is the THEN_BB
@@ -2841,8 +2839,8 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
     {
       new_bb->index = then_bb_index;
       BASIC_BLOCK (then_bb_index) = new_bb;
-      if (post_dominators)
-	add_to_dominance_info (post_dominators, new_bb);
+      if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+	add_to_dominance_info (CDI_POST_DOMINATORS, new_bb);
     }
   /* We've possibly created jump to next insn, cleanup_cfg will solve that
      later.  */
@@ -2884,7 +2882,7 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
   if (note && INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2)
     ;
   else if (else_succ->dest->index < 0
-	   || dominated_by_p (post_dominators, then_bb,
+	   || dominated_by_p (CDI_POST_DOMINATORS, then_bb,
 			      else_succ->dest))
     ;
   else
@@ -2911,8 +2909,8 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
 		    then_bb->global_live_at_start,
 		    else_bb->global_live_at_end, BITMAP_IOR);
 
-  if (post_dominators)
-    delete_from_dominance_info (post_dominators, else_bb);
+  if (dom_computed[CDI_POST_DOMINATORS] >= DOM_NO_FAST_QUERY)
+    delete_from_dominance_info (CDI_POST_DOMINATORS, else_bb);
   delete_block (else_bb);
 
   num_true_changes++;
@@ -3217,11 +3215,9 @@ if_convert (int x_life_data_ok)
   free_basic_block_vars (1);
 
   /* Compute postdominators if we think we'll use them.  */
-  post_dominators = NULL;
   if (HAVE_conditional_execution || life_data_ok)
-    {
-      post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
-    }
+    calculate_dominance_info (CDI_POST_DOMINATORS);
+
   if (life_data_ok)
     clear_bb_flags ();
 
@@ -3258,8 +3254,7 @@ if_convert (int x_life_data_ok)
     fprintf (rtl_dump_file, "\n\n========== no more changes\n");
 #endif
 
-  if (post_dominators)
-    free_dominance_info (post_dominators);
+  free_dominance_info (CDI_POST_DOMINATORS);
 
   if (rtl_dump_file)
     fflush (rtl_dump_file);

gcc/loop-init.c

@@ -53,7 +53,9 @@ loop_optimizer_init (FILE *dumpfile)
 
       /* No loops.  */
       flow_loops_free (loops);
+      free_dominance_info (CDI_DOMINATORS);
       free (loops);
+
       /* Make chain.  */
       FOR_EACH_BB (bb)
 	if (bb->next_bb != EXIT_BLOCK_PTR)
@@ -81,7 +83,7 @@ loop_optimizer_init (FILE *dumpfile)
   flow_loops_dump (loops, dumpfile, NULL, 1);
 
 #ifdef ENABLE_CHECKING
-  verify_dominators (loops->cfg.dom);
+  verify_dominators (CDI_DOMINATORS);
   verify_loop_structure (loops);
 #endif
 
@@ -105,6 +107,7 @@ loop_optimizer_finalize (struct loops *loops, FILE *dumpfile)
 
   /* Clean up.  */
   flow_loops_free (loops);
+  free_dominance_info (CDI_DOMINATORS);
   free (loops);
 
   /* Finalize changes.  */

gcc/loop-unroll.c

@@ -68,14 +68,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 static void decide_unrolling_and_peeling (struct loops *, int);
 static void peel_loops_completely (struct loops *, int);
-static void decide_peel_simple (struct loops *, struct loop *, int);
-static void decide_peel_once_rolling (struct loops *, struct loop *, int);
-static void decide_peel_completely (struct loops *, struct loop *, int);
-static void decide_unroll_stupid (struct loops *, struct loop *, int);
-static void decide_unroll_constant_iterations (struct loops *,
-					       struct loop *, int);
-static void decide_unroll_runtime_iterations (struct loops *, struct loop *,
-					      int);
+static void decide_peel_simple (struct loop *, int);
+static void decide_peel_once_rolling (struct loop *, int);
+static void decide_peel_completely (struct loop *, int);
+static void decide_unroll_stupid (struct loop *, int);
+static void decide_unroll_constant_iterations (struct loop *, int);
+static void decide_unroll_runtime_iterations (struct loop *, int);
 static void peel_loop_simple (struct loops *, struct loop *);
 static void peel_loop_completely (struct loops *, struct loop *);
 static void unroll_loop_stupid (struct loops *, struct loop *);
@@ -140,7 +138,7 @@ unroll_and_peel_loops (struct loops *loops, int flags)
       if (check)
 	{
 #ifdef ENABLE_CHECKING
-	  verify_dominators (loops->cfg.dom);
+	  verify_dominators (CDI_DOMINATORS);
 	  verify_loop_structure (loops);
 #endif
 	}
@@ -178,15 +176,15 @@ peel_loops_completely (struct loops *loops, int flags)
 
       loop->ninsns = num_loop_insns (loop);
 
-      decide_peel_once_rolling (loops, loop, flags);
+      decide_peel_once_rolling (loop, flags);
       if (loop->lpt_decision.decision == LPT_NONE)
-	decide_peel_completely (loops, loop, flags);
+	decide_peel_completely (loop, flags);
 
       if (loop->lpt_decision.decision == LPT_PEEL_COMPLETELY)
 	{
 	  peel_loop_completely (loops, loop);
 #ifdef ENABLE_CHECKING
-	  verify_dominators (loops->cfg.dom);
+	  verify_dominators (CDI_DOMINATORS);
 	  verify_loop_structure (loops);
 #endif
 	}
@@ -254,13 +252,13 @@ decide_unrolling_and_peeling (struct loops *loops, int flags)
       /* Try transformations one by one in decreasing order of
 	 priority.  */
 
-      decide_unroll_constant_iterations (loops, loop, flags);
+      decide_unroll_constant_iterations (loop, flags);
       if (loop->lpt_decision.decision == LPT_NONE)
-	decide_unroll_runtime_iterations (loops, loop, flags);
+	decide_unroll_runtime_iterations (loop, flags);
       if (loop->lpt_decision.decision == LPT_NONE)
-	decide_unroll_stupid (loops, loop, flags);
+	decide_unroll_stupid (loop, flags);
       if (loop->lpt_decision.decision == LPT_NONE)
-	decide_peel_simple (loops, loop, flags);
+	decide_peel_simple (loop, flags);
 
       loop = next;
     }
@@ -269,8 +267,7 @@ decide_unrolling_and_peeling (struct loops *loops, int flags)
 /* Decide whether the LOOP is once rolling and suitable for complete
    peeling.  */
 static void
-decide_peel_once_rolling (struct loops *loops, struct loop *loop,
-			  int flags ATTRIBUTE_UNUSED)
+decide_peel_once_rolling (struct loop *loop, int flags ATTRIBUTE_UNUSED)
 {
   if (rtl_dump_file)
     fprintf (rtl_dump_file, ";; Considering peeling once rolling loop\n");
@@ -284,7 +281,7 @@ decide_peel_once_rolling (struct loops *loops, struct loop *loop,
     }
 
   /* Check for simple loops.  */
-  loop->simple = simple_loop_p (loops, loop, &loop->desc);
+  loop->simple = simple_loop_p (loop, &loop->desc);
   loop->has_desc = 1;
 
   /* Check number of iterations.  */
@@ -303,8 +300,7 @@ decide_peel_once_rolling (struct loops *loops, struct loop *loop,
 
 /* Decide whether the LOOP is suitable for complete peeling.  */
 static void
-decide_peel_completely (struct loops *loops, struct loop *loop,
-			int flags ATTRIBUTE_UNUSED)
+decide_peel_completely (struct loop *loop, int flags ATTRIBUTE_UNUSED)
 {
   unsigned npeel;
 
@@ -352,7 +348,7 @@ decide_peel_completely (struct loops *loops, struct loop *loop,
   /* Check for simple loops.  */
   if (!loop->has_desc)
     {
-      loop->simple = simple_loop_p (loops, loop, &loop->desc);
+      loop->simple = simple_loop_p (loop, &loop->desc);
       loop->has_desc = 1;
     }
 
@@ -441,8 +437,7 @@ peel_loop_completely (struct loops *loops, struct loop *loop)
 
 /* Decide whether to unroll LOOP iterating constant number of times and how much.  */
 static void
-decide_unroll_constant_iterations (struct loops *loops, struct loop *loop,
-				   int flags)
+decide_unroll_constant_iterations (struct loop *loop, int flags)
 {
   unsigned nunroll, nunroll_by_av, best_copies, best_unroll = -1, n_copies, i;
 
@@ -475,7 +470,7 @@ decide_unroll_constant_iterations (struct loops *loops, struct loop *loop,
   /* Check for simple loops.  */
   if (!loop->has_desc)
     {
-      loop->simple = simple_loop_p (loops, loop, &loop->desc);
+      loop->simple = simple_loop_p (loop, &loop->desc);
       loop->has_desc = 1;
     }
 
@@ -649,8 +644,7 @@ unroll_loop_constant_iterations (struct loops *loops, struct loop *loop)
 /* Decide whether to unroll LOOP iterating runtime computable number of times
    and how much.  */
 static void
-decide_unroll_runtime_iterations (struct loops *loops, struct loop *loop,
-				  int flags)
+decide_unroll_runtime_iterations (struct loop *loop, int flags)
 {
   unsigned nunroll, nunroll_by_av, i;
 
@@ -683,7 +677,7 @@ decide_unroll_runtime_iterations (struct loops *loops, struct loop *loop,
   /* Check for simple loops.  */
   if (!loop->has_desc)
     {
-      loop->simple = simple_loop_p (loops, loop, &loop->desc);
+      loop->simple = simple_loop_p (loop, &loop->desc);
       loop->has_desc = 1;
     }
 
@@ -774,7 +768,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       unsigned nldom;
       basic_block *ldom;
 
-      nldom = get_dominated_by (loops->cfg.dom, body[i], &ldom);
+      nldom = get_dominated_by (CDI_DOMINATORS, body[i], &ldom);
       for (j = 0; j < nldom; j++)
 	if (!flow_bb_inside_loop_p (loop, ldom[j]))
 	  dom_bbs[n_dom_bbs++] = ldom[j];
@@ -821,7 +815,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
   end_sequence ();
 
   /* Precondition the loop.  */
-  loop_split_edge_with (loop_preheader_edge (loop), init_code, loops);
+  loop_split_edge_with (loop_preheader_edge (loop), init_code);
 
   remove_edges = xcalloc (max_unroll + n_peel + 1, sizeof (edge));
   n_remove_edges = 0;
@@ -844,7 +838,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
 
   /* Record the place where switch will be built for preconditioning.  */
   swtch = loop_split_edge_with (loop_preheader_edge (loop),
-				NULL_RTX, loops);
+				NULL_RTX);
 
   for (i = 0; i < n_peel; i++)
     {
@@ -862,8 +856,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       j = n_peel - i - (extra_zero_check ? 0 : 1);
       p = REG_BR_PROB_BASE / (i + 2);
 
-      preheader = loop_split_edge_with (loop_preheader_edge (loop),
-					NULL_RTX, loops);
+      preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
       label = block_label (preheader);
       start_sequence ();
       do_compare_rtx_and_jump (copy_rtx (niter), GEN_INT (j), EQ, 0,
@@ -879,8 +872,8 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       branch_code = get_insns ();
       end_sequence ();
 
-      swtch = loop_split_edge_with (swtch->pred, branch_code, loops);
-      set_immediate_dominator (loops->cfg.dom, preheader, swtch);
+      swtch = loop_split_edge_with (swtch->pred, branch_code);
+      set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
       swtch->succ->probability = REG_BR_PROB_BASE - p;
       e = make_edge (swtch, preheader,
 		     swtch->succ->flags & EDGE_IRREDUCIBLE_LOOP);
@@ -892,8 +885,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       /* Add branch for zero iterations.  */
       p = REG_BR_PROB_BASE / (max_unroll + 1);
       swtch = ezc_swtch;
-      preheader = loop_split_edge_with (loop_preheader_edge (loop),
-					NULL_RTX, loops);
+      preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
       label = block_label (preheader);
       start_sequence ();
       do_compare_rtx_and_jump (copy_rtx (niter), const0_rtx, EQ, 0,
@@ -909,8 +901,8 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
       branch_code = get_insns ();
       end_sequence ();
 
-      swtch = loop_split_edge_with (swtch->succ, branch_code, loops);
-      set_immediate_dominator (loops->cfg.dom, preheader, swtch);
+      swtch = loop_split_edge_with (swtch->succ, branch_code);
+      set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
       swtch->succ->probability = REG_BR_PROB_BASE - p;
       e = make_edge (swtch, preheader,
 		     swtch->succ->flags & EDGE_IRREDUCIBLE_LOOP);
@@ -918,7 +910,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
     }
 
   /* Recount dominators for outer blocks.  */
-  iterate_fix_dominators (loops->cfg.dom, dom_bbs, n_dom_bbs);
+  iterate_fix_dominators (CDI_DOMINATORS, dom_bbs, n_dom_bbs);
 
   /* And unroll loop.  */
 
@@ -946,7 +938,7 @@ unroll_loop_runtime_iterations (struct loops *loops, struct loop *loop)
 
 /* Decide whether to simply peel LOOP and how much.  */
 static void
-decide_peel_simple (struct loops *loops, struct loop *loop, int flags)
+decide_peel_simple (struct loop *loop, int flags)
 {
   unsigned npeel;
 
@@ -975,7 +967,7 @@ decide_peel_simple (struct loops *loops, struct loop *loop, int flags)
   /* Check for simple loops.  */
   if (!loop->has_desc)
     {
-      loop->simple = simple_loop_p (loops, loop, &loop->desc);
+      loop->simple = simple_loop_p (loop, &loop->desc);
       loop->has_desc = 1;
     }
 
@@ -1062,7 +1054,7 @@ peel_loop_simple (struct loops *loops, struct loop *loop)
 
 /* Decide whether to unroll LOOP stupidly and how much.  */
 static void
-decide_unroll_stupid (struct loops *loops, struct loop *loop, int flags)
+decide_unroll_stupid (struct loop *loop, int flags)
 {
   unsigned nunroll, nunroll_by_av, i;
 
@@ -1095,7 +1087,7 @@ decide_unroll_stupid (struct loops *loops, struct loop *loop, int flags)
   /* Check for simple loops.  */
   if (!loop->has_desc)
     {
-      loop->simple = simple_loop_p (loops, loop, &loop->desc);
+      loop->simple = simple_loop_p (loop, &loop->desc);
       loop->has_desc = 1;
     }
 

gcc/loop-unswitch.c

@@ -81,7 +81,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 static struct loop *unswitch_loop (struct loops *, struct loop *,
 				   basic_block);
 static void unswitch_single_loop (struct loops *, struct loop *, rtx, int);
-static bool may_unswitch_on_p (struct loops *, basic_block, struct loop *,
+static bool may_unswitch_on_p (basic_block, struct loop *,
 			       basic_block *);
 static rtx reversed_condition (rtx);
 
@@ -107,7 +107,7 @@ unswitch_loops (struct loops *loops)
 
       unswitch_single_loop (loops, loop, NULL_RTX, 0);
 #ifdef ENABLE_CHECKING
-      verify_dominators (loops->cfg.dom);
+      verify_dominators (CDI_DOMINATORS);
       verify_loop_structure (loops);
 #endif
     }
@@ -117,8 +117,7 @@ unswitch_loops (struct loops *loops)
    basic blocks (for what it means see comments below).  List of basic blocks
    inside LOOP is provided in BODY to save time.  */
 static bool
-may_unswitch_on_p (struct loops *loops, basic_block bb, struct loop *loop,
-		   basic_block *body)
+may_unswitch_on_p (basic_block bb, struct loop *loop, basic_block *body)
 {
   rtx test;
   unsigned i;
@@ -136,7 +135,7 @@ may_unswitch_on_p (struct loops *loops, basic_block bb, struct loop *loop,
 
   /* It must be executed just once each iteration (because otherwise we
      are unable to update dominator/irreducible loop information correctly).  */
-  if (!just_once_each_iteration_p (loops, loop, bb))
+  if (!just_once_each_iteration_p (loop, bb))
     return false;
 
   /* Condition must be invariant.  We use just a stupid test of invariantness
@@ -239,7 +238,7 @@ unswitch_single_loop (struct loops *loops, struct loop *loop,
       /* Find a bb to unswitch on.  */
       bbs = get_loop_body (loop);
       for (i = 0; i < loop->num_nodes; i++)
-	if (may_unswitch_on_p (loops, bbs[i], loop, bbs))
+	if (may_unswitch_on_p (bbs[i], loop, bbs))
 	  break;
 
       if (i == loop->num_nodes)
@@ -295,7 +294,7 @@ unswitch_single_loop (struct loops *loops, struct loop *loop,
     rconds = cond_checked;
 
   /* Separate condition in a single basic block.  */
-  bb = split_loop_bb (loops, bbs[i], PREV_INSN (split_before))->dest;
+  bb = split_loop_bb (bbs[i], PREV_INSN (split_before))->dest;
   free (bbs);
   true_first = !(bb->succ->flags & EDGE_FALLTHRU);
   if (rtl_dump_file)
@@ -335,7 +334,7 @@ unswitch_loop (struct loops *loops, struct loop *loop, basic_block unswitch_on)
   if (!unswitch_on->succ || !unswitch_on->succ->succ_next ||
       unswitch_on->succ->succ_next->succ_next)
     abort ();
-  if (!just_once_each_iteration_p (loops, loop, unswitch_on))
+  if (!just_once_each_iteration_p (loop, unswitch_on))
     abort ();
   if (loop->inner)
     abort ();
@@ -382,7 +381,7 @@ unswitch_loop (struct loops *loops, struct loop *loop, basic_block unswitch_on)
       switch_bb->succ->flags &= ~EDGE_IRREDUCIBLE_LOOP;
       switch_bb->succ->succ_next->flags &= ~EDGE_IRREDUCIBLE_LOOP;
     }
-  add_to_dominance_info (loops->cfg.dom, switch_bb);
+  add_to_dominance_info (CDI_DOMINATORS, switch_bb);
   unswitch_on->rbi->copy = unswitch_on_alt;
 
   /* Loopify from the copy of LOOP body, constructing the new loop.  */
@@ -403,8 +402,8 @@ unswitch_loop (struct loops *loops, struct loop *loop, basic_block unswitch_on)
   fix_loop_placement (nloop);
 
   /* Preserve the simple loop preheaders.  */
-  loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX, loops);
-  loop_split_edge_with (loop_preheader_edge (nloop), NULL_RTX, loops);
+  loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
+  loop_split_edge_with (loop_preheader_edge (nloop), NULL_RTX);
 
   return nloop;
 }

gcc/predict.c

@@ -72,10 +72,8 @@ static void estimate_loops_at_level (struct loop *loop);
 static void propagate_freq (struct loop *);
 static void estimate_bb_frequencies (struct loops *);
 static void counts_to_freqs (void);
-static void process_note_predictions (basic_block, int *, dominance_info,
-				      dominance_info);
-static void process_note_prediction (basic_block, int *, dominance_info,
-				     dominance_info, int, int);
+static void process_note_predictions (basic_block, int *);
+static void process_note_prediction (basic_block, int *, int, int);
 static bool last_basic_block_p (basic_block);
 static void compute_function_frequency (void);
 static void choose_function_section (void);
@@ -393,13 +391,12 @@ combine_predictions_for_insn (rtx insn, basic_block bb)
 void
 estimate_probability (struct loops *loops_info)
 {
-  dominance_info dominators, post_dominators;
   basic_block bb;
   unsigned i;
 
   connect_infinite_loops_to_exit ();
-  dominators = calculate_dominance_info (CDI_DOMINATORS);
-  post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
+  calculate_dominance_info (CDI_DOMINATORS);
+  calculate_dominance_info (CDI_POST_DOMINATORS);
 
   /* Try to predict out blocks in a loop that are not part of a
      natural loop.  */
@@ -412,11 +409,10 @@ estimate_probability (struct loops *loops_info)
       struct loop_desc desc;
       unsigned HOST_WIDE_INT niter;
 
-      flow_loop_scan (loops_info, loop, LOOP_EXIT_EDGES);
+      flow_loop_scan (loop, LOOP_EXIT_EDGES);
       exits = loop->num_exits;
 
-      if (simple_loop_p (loops_info, loop, &desc)
-	  && desc.const_iter)
+      if (simple_loop_p (loop, &desc) && desc.const_iter)
 	{
 	  int prob;
 	  niter = desc.niter + 1;
@@ -500,8 +496,8 @@ estimate_probability (struct loops *loops_info)
 	  /* Look for block we are guarding (ie we dominate it,
 	     but it doesn't postdominate us).  */
 	  if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
-	      && dominated_by_p (dominators, e->dest, e->src)
-	      && !dominated_by_p (post_dominators, e->src, e->dest))
+	      && dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
+	      && !dominated_by_p (CDI_POST_DOMINATORS, e->src, e->dest))
 	    {
 	      rtx insn;
 
@@ -618,8 +614,7 @@ estimate_probability (struct loops *loops_info)
 	&& bb->succ->succ_next != NULL)
       combine_predictions_for_insn (BB_END (bb), bb);
 
-  free_dominance_info (post_dominators);
-  free_dominance_info (dominators);
+  free_dominance_info (CDI_POST_DOMINATORS);
 
   remove_fake_edges ();
   estimate_bb_frequencies (loops_info);
@@ -719,10 +714,7 @@ last_basic_block_p (basic_block bb)
    on demand, so -1 may be there in case this was not needed yet).  */
 
 static void
-process_note_prediction (basic_block bb, int *heads,
-			 dominance_info dominators,
-			 dominance_info post_dominators, int pred,
-			 int flags)
+process_note_prediction (basic_block bb, int *heads, int pred, int flags)
 {
   edge e;
   int y;
@@ -736,18 +728,18 @@ process_note_prediction (basic_block bb, int *heads,
          find first dominator that we do not post-dominate (we are
          using already known members of heads array).  */
       basic_block ai = bb;
-      basic_block next_ai = get_immediate_dominator (dominators, bb);
+      basic_block next_ai = get_immediate_dominator (CDI_DOMINATORS, bb);
       int head;
 
       while (heads[next_ai->index] < 0)
 	{
-	  if (!dominated_by_p (post_dominators, next_ai, bb))
+	  if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb))
 	    break;
 	  heads[next_ai->index] = ai->index;
 	  ai = next_ai;
-	  next_ai = get_immediate_dominator (dominators, next_ai);
+	  next_ai = get_immediate_dominator (CDI_DOMINATORS, next_ai);
 	}
-      if (!dominated_by_p (post_dominators, next_ai, bb))
+      if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb))
 	head = next_ai->index;
       else
 	head = heads[next_ai->index];
@@ -769,7 +761,7 @@ process_note_prediction (basic_block bb, int *heads,
     return;
   for (e = BASIC_BLOCK (y)->succ; e; e = e->succ_next)
     if (e->dest->index >= 0
-	&& dominated_by_p (post_dominators, e->dest, bb))
+	&& dominated_by_p (CDI_POST_DOMINATORS, e->dest, bb))
       predict_edge_def (e, pred, taken);
 }
 
@@ -778,9 +770,7 @@ process_note_prediction (basic_block bb, int *heads,
    process_note_prediction.  */
 
 static void
-process_note_predictions (basic_block bb, int *heads,
-			  dominance_info dominators,
-			  dominance_info post_dominators)
+process_note_predictions (basic_block bb, int *heads)
 {
   rtx insn;
   edge e;
@@ -813,8 +803,6 @@ process_note_predictions (basic_block bb, int *heads,
 	  /* Process single prediction note.  */
 	  process_note_prediction (bb,
 				   heads,
-				   dominators,
-				   post_dominators,
 				   alg, (int) NOTE_PREDICTION_FLAGS (insn));
 	  delete_insn (insn);
 	}
@@ -827,10 +815,7 @@ process_note_predictions (basic_block bb, int *heads,
       /* This block ended from other reasons than because of return.
          If it is because of noreturn call, this should certainly not
          be taken.  Otherwise it is probably some error recovery.  */
-      process_note_prediction (bb,
-			       heads,
-			       dominators,
-			       post_dominators, PRED_NORETURN, NOT_TAKEN);
+      process_note_prediction (bb, heads, PRED_NORETURN, NOT_TAKEN);
     }
 }
 
@@ -841,15 +826,14 @@ void
 note_prediction_to_br_prob (void)
 {
   basic_block bb;
-  dominance_info post_dominators, dominators;
   int *heads;
 
   /* To enable handling of noreturn blocks.  */
   add_noreturn_fake_exit_edges ();
   connect_infinite_loops_to_exit ();
 
-  post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
-  dominators = calculate_dominance_info (CDI_DOMINATORS);
+  calculate_dominance_info (CDI_POST_DOMINATORS);
+  calculate_dominance_info (CDI_DOMINATORS);
 
   heads = xmalloc (sizeof (int) * last_basic_block);
   memset (heads, -1, sizeof (int) * last_basic_block);
@@ -858,10 +842,10 @@ note_prediction_to_br_prob (void)
   /* Process all prediction notes.  */
 
   FOR_EACH_BB (bb)
-    process_note_predictions (bb, heads, dominators, post_dominators);
+    process_note_predictions (bb, heads);
 
-  free_dominance_info (post_dominators);
-  free_dominance_info (dominators);
+  free_dominance_info (CDI_POST_DOMINATORS);
+  free_dominance_info (CDI_DOMINATORS);
   free (heads);
 
   remove_fake_edges ();

gcc/sched-rgn.c

@@ -155,7 +155,7 @@ static int *containing_rgn;
 
 void debug_regions (void);
 static void find_single_block_region (void);
-static void find_rgns (struct edge_list *, dominance_info);
+static void find_rgns (struct edge_list *);
 static int too_large (int, int *, int *);
 
 extern void debug_live (int, int);
@@ -613,7 +613,7 @@ too_large (int block, int *num_bbs, int *num_insns)
    of edge tables.  That would simplify it somewhat.  */
 
 static void
-find_rgns (struct edge_list *edge_list, dominance_info dom)
+find_rgns (struct edge_list *edge_list)
 {
   int *max_hdr, *dfs_nr, *stack, *degree;
   char no_loops = 1;
@@ -827,7 +827,7 @@ find_rgns (struct edge_list *edge_list, dominance_info dom)
 		    {
 		      /* Now verify that the block is dominated by the loop
 			 header.  */
-		      if (!dominated_by_p (dom, jbb, bb))
+		      if (!dominated_by_p (CDI_DOMINATORS, jbb, bb))
 			break;
 		    }
 		}
@@ -2597,7 +2597,6 @@ init_regions (void)
 	}
       else
 	{
-	  dominance_info dom;
 	  struct edge_list *edge_list;
 
 	  /* The scheduler runs after estimate_probabilities; therefore, we
@@ -2607,7 +2606,7 @@ init_regions (void)
 	  edge_list = create_edge_list ();
 
 	  /* Compute the dominators and post dominators.  */
-	  dom = calculate_dominance_info (CDI_DOMINATORS);
+	  calculate_dominance_info (CDI_DOMINATORS);
 
 	  /* build_control_flow will return nonzero if it detects unreachable
 	     blocks or any other irregularity with the cfg which prevents
@@ -2615,7 +2614,7 @@ init_regions (void)
 	  if (build_control_flow (edge_list) != 0)
 	    find_single_block_region ();
 	  else
-	    find_rgns (edge_list, dom);
+	    find_rgns (edge_list);
 
 	  if (sched_verbose >= 3)
 	    debug_regions ();
@@ -2625,7 +2624,7 @@ init_regions (void)
 
 	  /* For now.  This will move as more and more of haifa is converted
 	     to using the cfg code in flow.c.  */
-	  free_dominance_info (dom);
+	  free_dominance_info (CDI_DOMINATORS);
 	}
     }
 

gcc/toplev.c

@@ -2477,6 +2477,7 @@ rest_of_handle_branch_prob (tree decl, rtx insns)
     estimate_probability (&loops);
 
   flow_loops_free (&loops);
+  free_dominance_info (CDI_DOMINATORS);
   close_dump_file (DFI_bp, print_rtl_with_bb, insns);
   timevar_pop (TV_BRANCH_PROB);
 }
@@ -3014,8 +3015,9 @@ rest_of_handle_loop_optimize (tree decl, rtx insns)
    sooner, but we want the profile feedback to work more
    efficiently.  */
 static void
-rest_of_handle_loop2 (tree decl, rtx insns)
+rest_of_handle_loop2 (tree decl ATTRIBUTE_UNUSED, rtx insns ATTRIBUTE_UNUSED)
 {
+#if 0
   struct loops *loops;
   timevar_push (TV_LOOP);
   open_dump_file (DFI_loop2, decl);
@@ -3047,6 +3049,7 @@ rest_of_handle_loop2 (tree decl, rtx insns)
   close_dump_file (DFI_loop2, print_rtl_with_bb, get_insns ());
   timevar_pop (TV_LOOP);
   ggc_collect ();
+#endif
 }
 
 /* This is called from finish_function (within langhooks.parse_file)