don't access irg anchor nodes directly

[r7586]

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 547dc81..bd227e6 100644 (file)
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -124,7 +124,11 @@ void local_optimize_node(ir_node *n) {
 static void kill_dead_blocks(ir_node *block, void *env)
 {
   if (get_Block_dom_depth(block) < 0)
-    set_Block_dead(block);
+    if (block != get_irg_end_block(current_ir_graph)) {
+      /* we don't want that the end block of graphs with
+         endless loops is marked bad (although it is of course */
+      set_Block_dead(block);
+    }
 }
 
 void
@@ -135,7 +139,7 @@ local_optimize_graph (ir_graph *irg) {
   if (get_irg_dom_state(current_ir_graph) == dom_consistent)
     irg_block_walk_graph(irg, NULL, kill_dead_blocks, NULL);
 
-  do_local_optimize(irg->end);
+  do_local_optimize(get_irg_end(irg));
 
   current_ir_graph = rem;
 }
@@ -427,15 +431,14 @@ static void
 copy_graph_env (int copy_node_nr) {
   ir_graph *irg = current_ir_graph;
   ir_node *old_end, *n;
+  int i;
+
   /* Not all nodes remembered in irg might be reachable
      from the end node.  Assure their link is set to NULL, so that
      we can test whether new nodes have been computed. */
-  set_irn_link(get_irg_frame      (irg), NULL);
-  set_irn_link(get_irg_globals    (irg), NULL);
-  set_irn_link(get_irg_args       (irg), NULL);
-  set_irn_link(get_irg_initial_mem(irg), NULL);
-  set_irn_link(get_irg_bad        (irg), NULL);
-  set_irn_link(get_irg_no_mem     (irg), NULL);
+  for (i = anchor_max - 1; i >= 0; --i)
+    if (irg->anchors[i])
+      set_new_node(irg->anchors[i], NULL);
 
   /* we use the block walk flag for removing Bads from Blocks ins. */
   inc_irg_block_visited(irg);
@@ -667,58 +670,58 @@ void remove_bad_predecessors(ir_graph *irg) {
 
 
 /*
-        __                      _  __ __
-       (_     __    o     _    | \/  |_
-       __)|_| | \_/ | \_/(/_   |_/\__|__
+   __                      _  __ __
+  (_     __    o     _    | \/  |_
+  __)|_| | \_/ | \_/(/_   |_/\__|__
 
   The following stuff implements a facility that automatically patches
   registered ir_node pointers to the new node when a dead node elimination occurs.
 */
 
 struct _survive_dce_t {
-       struct obstack obst;
-       pmap *places;
-       pmap *new_places;
-       hook_entry_t dead_node_elim;
-       hook_entry_t dead_node_elim_subst;
+  struct obstack obst;
+  pmap *places;
+  pmap *new_places;
+  hook_entry_t dead_node_elim;
+  hook_entry_t dead_node_elim_subst;
 };
 
 typedef struct _survive_dce_list_t {
-       struct _survive_dce_list_t *next;
-       ir_node **place;
+  struct _survive_dce_list_t *next;
+  ir_node **place;
 } survive_dce_list_t;
 
 static void dead_node_hook(void *context, ir_graph *irg, int start)
 {
-       survive_dce_t *sd = context;
-
-       /* Create a new map before the dead node elimination is performed. */
-       if(start) {
-               sd->new_places = pmap_create_ex(pmap_count(sd->places));
-       }
-
-       /* Patch back all nodes if dead node elimination is over and something is to be done. */
-       else {
-               pmap_destroy(sd->places);
-               sd->places     = sd->new_places;
-               sd->new_places = NULL;
-       }
+  survive_dce_t *sd = context;
+
+  /* Create a new map before the dead node elimination is performed. */
+  if(start) {
+    sd->new_places = pmap_create_ex(pmap_count(sd->places));
+  }
+
+  /* Patch back all nodes if dead node elimination is over and something is to be done. */
+  else {
+    pmap_destroy(sd->places);
+    sd->places     = sd->new_places;
+    sd->new_places = NULL;
+  }
 }
 
 static void dead_node_subst_hook(void *context, ir_graph *irg, ir_node *old, ir_node *nw)
 {
-       survive_dce_t *sd = context;
-       survive_dce_list_t *list = pmap_get(sd->places, old);
+  survive_dce_t *sd = context;
+  survive_dce_list_t *list = pmap_get(sd->places, old);
 
-       /* If the node is to be patched back, write the new address to all registered locations. */
-       if(list) {
-               survive_dce_list_t *p;
+  /* If the node is to be patched back, write the new address to all registered locations. */
+  if(list) {
+    survive_dce_list_t *p;
 
-               for(p = list; p; p = p->next)
-                       *(p->place) = nw;
+    for(p = list; p; p = p->next)
+      *(p->place) = nw;
 
-               pmap_insert(sd->new_places, nw, list);
-       }
+    pmap_insert(sd->new_places, nw, list);
+  }
 }
 
 /**
@@ -726,22 +729,22 @@ static void dead_node_subst_hook(void *context, ir_graph *irg, ir_node *old, ir_
  */
 survive_dce_t *new_survive_dce(void)
 {
-       survive_dce_t *res = xmalloc(sizeof(res[0]));
-       obstack_init(&res->obst);
-       res->places     = pmap_create();
-       res->new_places = NULL;
-
-       res->dead_node_elim.hook._hook_dead_node_elim = dead_node_hook;
-       res->dead_node_elim.context                   = res;
-       res->dead_node_elim.next                      = NULL;
-
-       res->dead_node_elim_subst.hook._hook_dead_node_elim_subst = dead_node_subst_hook;
-       res->dead_node_elim_subst.context = res;
-       res->dead_node_elim_subst.next    = NULL;
-
-       register_hook(hook_dead_node_elim, &res->dead_node_elim);
-       register_hook(hook_dead_node_elim_subst, &res->dead_node_elim_subst);
-       return res;
+  survive_dce_t *res = xmalloc(sizeof(res[0]));
+  obstack_init(&res->obst);
+  res->places     = pmap_create();
+  res->new_places = NULL;
+
+  res->dead_node_elim.hook._hook_dead_node_elim = dead_node_hook;
+  res->dead_node_elim.context                   = res;
+  res->dead_node_elim.next                      = NULL;
+
+  res->dead_node_elim_subst.hook._hook_dead_node_elim_subst = dead_node_subst_hook;
+  res->dead_node_elim_subst.context = res;
+  res->dead_node_elim_subst.next    = NULL;
+
+  register_hook(hook_dead_node_elim, &res->dead_node_elim);
+  register_hook(hook_dead_node_elim_subst, &res->dead_node_elim_subst);
+  return res;
 }
 
 /**
@@ -749,11 +752,11 @@ survive_dce_t *new_survive_dce(void)
  */
 void free_survive_dce(survive_dce_t *sd)
 {
-       obstack_free(&sd->obst, NULL);
-       pmap_destroy(sd->places);
-       unregister_hook(hook_dead_node_elim, &sd->dead_node_elim);
-       unregister_hook(hook_dead_node_elim_subst, &sd->dead_node_elim_subst);
-       free(sd);
+  obstack_free(&sd->obst, NULL);
+  pmap_destroy(sd->places);
+  unregister_hook(hook_dead_node_elim, &sd->dead_node_elim);
+  unregister_hook(hook_dead_node_elim_subst, &sd->dead_node_elim_subst);
+  free(sd);
 }
 
 /**
@@ -766,16 +769,16 @@ void free_survive_dce(survive_dce_t *sd)
  */
 void survive_dce_register_irn(survive_dce_t *sd, ir_node **place)
 {
-       if(*place != NULL) {
-               ir_node *irn      = *place;
-               survive_dce_list_t *curr = pmap_get(sd->places, irn);
-               survive_dce_list_t *nw   = obstack_alloc(&sd->obst, sizeof(nw));
+  if(*place != NULL) {
+    ir_node *irn      = *place;
+    survive_dce_list_t *curr = pmap_get(sd->places, irn);
+    survive_dce_list_t *nw   = obstack_alloc(&sd->obst, sizeof(nw));
 
-               nw->next  = curr;
-               nw->place = place;
+    nw->next  = curr;
+    nw->place = place;
 
-               pmap_insert(sd->places, irn, nw);
-       }
+    pmap_insert(sd->places, irn, nw);
+  }
 }
 
 /*--------------------------------------------------------------------*/