used new set_irg_doms_inconsistent() to invalidate dom and postdom

[libfirm] / ir / ir / irgopt.c

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 560d47e..8bf933a 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -97,8 +97,7 @@ static INLINE void do_local_optimize(ir_node *n) {
     set_irg_pinned(current_ir_graph, op_pin_state_floats);
   if (get_irg_outs_state(current_ir_graph) == outs_consistent)
     set_irg_outs_inconsistent(current_ir_graph);
-  if (get_irg_dom_state(current_ir_graph) == dom_consistent)
-    set_irg_dom_inconsistent(current_ir_graph);
+  set_irg_doms_inconsistent(current_ir_graph);
   set_irg_loopinfo_inconsistent(current_ir_graph);
 
   /* Clean the value_table in irg for the CSE. */
@@ -193,23 +192,6 @@ compute_new_arity(ir_node *b) {
   }
 }
 
-/* TODO: add an ir_op operation */
-static INLINE void new_backedge_info(ir_node *n) {
-  switch(get_irn_opcode(n)) {
-  case iro_Block:
-    n->attr.block.cg_backedge = NULL;
-    n->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-    break;
-  case iro_Phi:
-    n->attr.phi_backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-    break;
-  case iro_Filter:
-    n->attr.filter.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-    break;
-  default: ;
-  }
-}
-
 /**
  * Copies the node to the new obstack. The Ins of the new node point to
  * the predecessors on the old obstack.  For block/phi nodes not all
@@ -451,6 +433,7 @@ copy_graph_env (int copy_node_nr) {
   set_irn_link(get_irg_globals    (current_ir_graph), NULL);
   set_irn_link(get_irg_args       (current_ir_graph), NULL);
   set_irn_link(get_irg_initial_mem(current_ir_graph), NULL);
+  set_irn_link(get_irg_bad        (current_ir_graph), NULL);
   set_irn_link(get_irg_no_mem     (current_ir_graph), NULL);
 
   /* we use the block walk flag for removing Bads from Blocks ins. */
@@ -466,6 +449,7 @@ copy_graph_env (int copy_node_nr) {
   set_irg_end_reg    (current_ir_graph, get_irg_end(current_ir_graph));
   free_End(old_end);
   set_irg_end_block  (current_ir_graph, get_new_node(get_irg_end_block(current_ir_graph)));
+
   if (get_irn_link(get_irg_frame(current_ir_graph)) == NULL) {
     copy_node (get_irg_frame(current_ir_graph), INT_TO_PTR(copy_node_nr));
     copy_preds(get_irg_frame(current_ir_graph), NULL);
@@ -482,26 +466,22 @@ copy_graph_env (int copy_node_nr) {
     copy_node (get_irg_args(current_ir_graph), INT_TO_PTR(copy_node_nr));
     copy_preds(get_irg_args(current_ir_graph), NULL);
   }
-  set_irg_start      (current_ir_graph, get_new_node(get_irg_start(current_ir_graph)));
-
-  set_irg_start_block(current_ir_graph,
-              get_new_node(get_irg_start_block(current_ir_graph)));
-  set_irg_frame      (current_ir_graph, get_new_node(get_irg_frame(current_ir_graph)));
-  set_irg_globals    (current_ir_graph, get_new_node(get_irg_globals(current_ir_graph)));
-  set_irg_initial_mem(current_ir_graph, get_new_node(get_irg_initial_mem(current_ir_graph)));
-  set_irg_args       (current_ir_graph, get_new_node(get_irg_args(current_ir_graph)));
-
   if (get_irn_link(get_irg_bad(current_ir_graph)) == NULL) {
     copy_node(get_irg_bad(current_ir_graph), INT_TO_PTR(copy_node_nr));
     copy_preds(get_irg_bad(current_ir_graph), NULL);
   }
-  set_irg_bad(current_ir_graph, get_new_node(get_irg_bad(current_ir_graph)));
-
   if (get_irn_link(get_irg_no_mem(current_ir_graph)) == NULL) {
     copy_node(get_irg_no_mem(current_ir_graph), INT_TO_PTR(copy_node_nr));
     copy_preds(get_irg_no_mem(current_ir_graph), NULL);
   }
-  set_irg_no_mem(current_ir_graph, get_new_node(get_irg_no_mem(current_ir_graph)));
+  set_irg_start      (current_ir_graph, get_new_node(get_irg_start(current_ir_graph)));
+  set_irg_start_block(current_ir_graph, get_new_node(get_irg_start_block(current_ir_graph)));
+  set_irg_frame      (current_ir_graph, get_new_node(get_irg_frame(current_ir_graph)));
+  set_irg_globals    (current_ir_graph, get_new_node(get_irg_globals(current_ir_graph)));
+  set_irg_initial_mem(current_ir_graph, get_new_node(get_irg_initial_mem(current_ir_graph)));
+  set_irg_args       (current_ir_graph, get_new_node(get_irg_args(current_ir_graph)));
+  set_irg_bad        (current_ir_graph, get_new_node(get_irg_bad(current_ir_graph)));
+  set_irg_no_mem     (current_ir_graph, get_new_node(get_irg_no_mem(current_ir_graph)));
 }
 
 /**
@@ -519,25 +499,28 @@ dead_node_elimination(ir_graph *irg) {
   struct obstack *graveyard_obst = NULL;
   struct obstack *rebirth_obst   = NULL;
 
-       edges_init_graph(irg);
+  if (get_opt_optimize() && get_opt_dead_node_elimination()) {
+    assert(! edges_activated(irg) && "dead node elimination requieres disabled edges");
 
-  /* inform statistics that we started a dead-node elimination run */
-  hook_dead_node_elim_start(irg);
+    /* inform statistics that we started a dead-node elimination run */
+    hook_dead_node_elim(irg, 1);
 
-  /* Remember external state of current_ir_graph. */
-  rem = current_ir_graph;
-  current_ir_graph = irg;
-  set_interprocedural_view(false);
+    /* Remember external state of current_ir_graph. */
+    rem = current_ir_graph;
+    current_ir_graph = irg;
+    set_interprocedural_view(0);
 
-  /* Handle graph state */
-  assert(get_irg_phase_state(current_ir_graph) != phase_building);
-  free_callee_info(current_ir_graph);
-  free_irg_outs(current_ir_graph);
-  free_trouts();
-  /* @@@ so far we loose loops when copying */
-  free_loop_information(current_ir_graph);
+    assert(get_irg_phase_state(current_ir_graph) != phase_building);
 
-  if (get_opt_optimize() && get_opt_dead_node_elimination()) {
+    /* Handle graph state */
+    free_callee_info(current_ir_graph);
+    free_irg_outs(current_ir_graph);
+    free_trouts();
+
+    /* @@@ so far we loose loops when copying */
+    free_loop_information(current_ir_graph);
+
+    set_irg_doms_inconsistent(irg);
 
     /* A quiet place, where the old obstack can rest in peace,
        until it will be cremated. */
@@ -558,13 +541,13 @@ dead_node_elimination(ir_graph *irg) {
     /* Free memory from old unoptimized obstack */
     obstack_free(graveyard_obst, 0);  /* First empty the obstack ... */
     xfree (graveyard_obst);           /* ... then free it.           */
-  }
 
-  /* inform statistics that the run is over */
-  hook_dead_node_elim_stop(irg);
+    /* inform statistics that the run is over */
+    hook_dead_node_elim(irg, 0);
 
-  current_ir_graph = rem;
-  set_interprocedural_view(rem_ipview);
+    current_ir_graph = rem;
+    set_interprocedural_view(rem_ipview);
+  }
 }
 
 /**
@@ -603,9 +586,9 @@ static void relink_bad_block_predecessors(ir_node *n, void *env) {
       for (i = 0; i < old_irn_arity; i++) {
         irn = get_irn_n(n, i);
         if (!is_Bad(irn)) {
-               new_in[new_irn_n] = irn;
-               is_backedge(n, i) ? set_backedge(n, new_irn_n-1) : set_not_backedge(n, new_irn_n-1);
-               new_irn_n++;
+          new_in[new_irn_n] = irn;
+          is_backedge(n, i) ? set_backedge(n, new_irn_n-1) : set_not_backedge(n, new_irn_n-1);
+          ++new_irn_n;
         }
       }
       //ARR_SETLEN(int, n->attr.block.backedge, new_irn_arity);
@@ -650,9 +633,9 @@ static void relink_bad_predecessors(ir_node *n, void *env) {
       new_irn_arity = 1;
       for(i = 1; i < old_irn_arity; i++)
         if (!is_Bad((ir_node *)old_in[i])) {
-               n->in[new_irn_arity] = n->in[i];
-               is_backedge(n, i) ? set_backedge(n, new_irn_arity) : set_not_backedge(n, new_irn_arity);
-               new_irn_arity++;
+          n->in[new_irn_arity] = n->in[i];
+          is_backedge(n, i) ? set_backedge(n, new_irn_arity) : set_not_backedge(n, new_irn_arity);
+          ++new_irn_arity;
         }
 
       ARR_SETLEN(ir_node *, n->in, new_irn_arity);
@@ -1639,7 +1622,7 @@ static INLINE void place_early(pdeq *worklist) {
   }
 
   set_irg_outs_inconsistent(current_ir_graph);
-  current_ir_graph->op_pin_state_pinned = op_pin_state_pinned;
+  set_irg_pinned(current_ir_graph, op_pin_state_pinned);
 }
 
 /**