X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgopt.c;h=47d00d64f5bf93d96cc76ad45457f560f0f9d1ae;hb=23ea16875f38dc0c067cce24f64b5c70f3acc496;hp=e788f4ad0f404f15400cb510b3c64e1f571801d7;hpb=95ea45b6d9050f3638c68dda8c4fcc92a79c81ed;p=libfirm

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index e788f4ad0..47d00d64f 100644
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -46,51 +46,26 @@
 #include "iredges_t.h"
 #include "irtools.h"
 
-/* Defined in iropt.c */
-pset *new_identities (void);
-void  del_identities (pset *value_table);
-void  add_identities (pset *value_table, ir_node *node);
-
 /*------------------------------------------------------------------*/
 /* apply optimizations of iropt to all nodes.                       */
 /*------------------------------------------------------------------*/
 
-static void init_link (ir_node *n, void *env) {
-  set_irn_link(n, NULL);
-}
-
-#if 0   /* Old version. Avoids Ids.
-           This is not necessary:  we do a post walk, and get_irn_n
-           removes ids anyways.  So it's much cheaper to call the
-           optimization less often and use the exchange() algorithm. */
-static void
-optimize_in_place_wrapper (ir_node *n, void *env) {
-  int i, irn_arity;
-  ir_node *optimized, *old;
-
-  irn_arity = get_irn_arity(n);
-  for (i = 0; i < irn_arity; i++) {
-    /* get_irn_n skips Id nodes, so comparison old != optimized does not
-       show all optimizations. Therefore always set new predecessor. */
-    old = get_irn_intra_n(n, i);
-    optimized = optimize_in_place_2(old);
-    set_irn_n(n, i, optimized);
-  }
-
-  if (get_irn_op(n) == op_Block) {
-    optimized = optimize_in_place_2(n);
-    if (optimized != n) exchange (n, optimized);
-  }
-}
-#else
-static void
-optimize_in_place_wrapper (ir_node *n, void *env) {
+/**
+ * A wrapper around optimize_inplace_2() to be called from a walker.
+ */
+static void optimize_in_place_wrapper (ir_node *n, void *env) {
   ir_node *optimized = optimize_in_place_2(n);
   if (optimized != n) exchange (n, optimized);
 }
-#endif
-
 
+/**
+ * Do local optimizations for a node.
+ *
+ * @param n  the IR-node where to start. Typically the End node
+ *           of a graph
+ *
+ * @note current_ir_graph must be set
+ */
 static INLINE void do_local_optimize(ir_node *n) {
   /* Handle graph state */
   assert(get_irg_phase_state(current_ir_graph) != phase_building);
@@ -106,9 +81,10 @@ static INLINE void do_local_optimize(ir_node *n) {
   current_ir_graph->value_table = new_identities();
 
   /* walk over the graph */
-  irg_walk(n, init_link, optimize_in_place_wrapper, NULL);
+  irg_walk(n, firm_clear_link, optimize_in_place_wrapper, NULL);
 }
 
+/* Applies local optimizations (see iropt.h) to all nodes reachable from node n */
 void local_optimize_node(ir_node *n) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_irn_irg(n);
@@ -123,12 +99,13 @@ void local_optimize_node(ir_node *n) {
  */
 static void kill_dead_blocks(ir_node *block, void *env)
 {
-  if (get_Block_dom_depth(block) < 0)
-    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);
-    }
+  if (get_Block_dom_depth(block) < 0) {
+    /*
+     * Note that the new dominance code correctly handles
+     * the End block, i.e. it is always reachable from Start
+     */
+    set_Block_dead(block);
+  }
 }
 
 void
@@ -136,7 +113,7 @@ local_optimize_graph (ir_graph *irg) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = irg;
 
-  if (get_irg_dom_state(current_ir_graph) == dom_consistent)
+  if (get_irg_dom_state(irg) == dom_consistent)
     irg_block_walk_graph(irg, NULL, kill_dead_blocks, NULL);
 
   do_local_optimize(get_irg_end(irg));
@@ -144,6 +121,74 @@ local_optimize_graph (ir_graph *irg) {
   current_ir_graph = rem;
 }
 
+/**
+ * Data flow optimization walker.
+ */
+static void opt_walker(ir_node *n, void *env) {
+  pdeq *waitq = env;
+  ir_node *optimized;
+
+  optimized = optimize_in_place_2(n);
+  set_irn_link(optimized, NULL);
+
+  if (optimized != n) {
+    const ir_edge_t *edge;
+
+    foreach_out_edge(n, edge) {
+      ir_node *succ = get_edge_src_irn(edge);
+
+      if (get_irn_link(succ) != waitq) {
+        pdeq_putr(waitq, succ);
+        set_irn_link(succ, waitq);
+      }
+    }
+    exchange(n, optimized);
+  }
+}
+
+void optimize_graph_df(ir_graph *irg) {
+  pdeq     *waitq = new_pdeq();
+  int      state = edges_activated(irg);
+  ir_graph *rem = current_ir_graph;
+
+  current_ir_graph = irg;
+
+  if (! state)
+    edges_activate(irg);
+
+  if (get_opt_global_cse())
+    set_irg_pinned(current_ir_graph, op_pin_state_floats);
+
+  /* Clean the value_table in irg for the CSE. */
+  del_identities(irg->value_table);
+  irg->value_table = new_identities();
+
+  if (get_irg_dom_state(current_ir_graph) == dom_consistent)
+    irg_block_walk_graph(irg, NULL, kill_dead_blocks, NULL);
+
+  /* invalidate info */
+  set_irg_outs_inconsistent(irg);
+  set_irg_doms_inconsistent(irg);
+  set_irg_loopinfo_inconsistent(irg);
+
+  /* walk over the graph */
+  irg_walk_graph(irg, NULL, opt_walker, waitq);
+
+  /* finish the wait queue */
+  while (! pdeq_empty(waitq)) {
+    ir_node *n = pdeq_getl(waitq);
+    if (! is_Bad(n))
+      opt_walker(n, waitq);
+  }
+
+  del_pdeq(waitq);
+
+  if (! state)
+    edges_deactivate(irg);
+
+  current_ir_graph = rem;
+}
+
 
 /*------------------------------------------------------------------*/
 /* Routines for dead node elimination / copying garbage collection  */
@@ -412,22 +457,23 @@ static void copy_graph(ir_graph *irg, int copy_node_nr) {
   /*- ... and now the keep alives. -*/
   /* First pick the not marked block nodes and walk them.  We must pick these
      first as else we will oversee blocks reachable from Phis. */
-  irn_arity = get_irn_arity(oe);
+  irn_arity = get_End_n_keepalives(oe);
   for (i = 0; i < irn_arity; i++) {
-    ka = get_irn_intra_n(oe, i);
-    if (is_Block(ka) &&
-        (get_irn_visited(ka) <= vfl)) {
-      /* We must keep the block alive and copy everything reachable */
-      set_irg_visited(irg, vfl);
-      irg_walk(ka, copy_node, copy_preds, INT_TO_PTR(copy_node_nr));
+    ka = get_End_keepalive(oe, i);
+    if (is_Block(ka)) {
+      if (get_irn_visited(ka) <= vfl) {
+        /* We must keep the block alive and copy everything reachable */
+        set_irg_visited(irg, vfl);
+        irg_walk(ka, copy_node, copy_preds, INT_TO_PTR(copy_node_nr));
+      }
       add_End_keepalive(ne, get_new_node(ka));
     }
   }
 
   /* Now pick other nodes.  Here we will keep all! */
-  irn_arity = get_irn_arity(oe);
+  irn_arity = get_End_n_keepalives(oe);
   for (i = 0; i < irn_arity; i++) {
-    ka = get_irn_intra_n(oe, i);
+    ka = get_End_keepalive(oe, i);
     if (!is_Block(ka)) {
       if (get_irn_visited(ka) <= vfl) {
         /* We didn't copy the node yet.  */
@@ -528,16 +574,17 @@ dead_node_elimination(ir_graph *irg) {
     graveyard_obst = irg->obst;
 
     /* A new obstack, where the reachable nodes will be copied to. */
-    rebirth_obst = xmalloc (sizeof(*rebirth_obst));
+    rebirth_obst = xmalloc(sizeof(*rebirth_obst));
     current_ir_graph->obst = rebirth_obst;
     obstack_init (current_ir_graph->obst);
+    current_ir_graph->last_node_idx = 0;
 
-    /* We also need a new hash table for cse */
-    del_identities (irg->value_table);
-    irg->value_table = new_identities ();
+    /* We also need a new value table for CSE */
+    del_identities(irg->value_table);
+    irg->value_table = new_identities();
 
     /* Copy the graph from the old to the new obstack */
-    copy_graph_env(1);
+    copy_graph_env(/*copy_node_nr=*/1);
 
     /* Free memory from old unoptimized obstack */
     obstack_free(graveyard_obst, 0);  /* First empty the obstack ... */
@@ -656,7 +703,7 @@ static void relink_bad_predecessors(ir_node *n, void *env) {
  * changes).
  */
 void remove_bad_predecessors(ir_graph *irg) {
-  irg_walk_graph(irg, init_link, relink_bad_predecessors, NULL);
+  irg_walk_graph(irg, firm_clear_link, relink_bad_predecessors, NULL);
 }
 
 
@@ -855,7 +902,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph)
 int inline_method(ir_node *call, ir_graph *called_graph) {
   ir_node *pre_call;
   ir_node *post_call, *post_bl;
-  ir_node *in[5];
+  ir_node *in[pn_Start_max];
   ir_node *end, *end_bl;
   ir_node **res_pred;
   ir_node **cf_pred;
@@ -865,7 +912,7 @@ int inline_method(ir_node *call, ir_graph *called_graph) {
   ir_type *called_frame;
   irg_inline_property prop = get_irg_inline_property(called_graph);
 
-  if ( (prop != irg_inline_forced) &&
+  if ( (prop < irg_inline_forced) &&
        (!get_opt_optimize() || !get_opt_inline() || (prop == irg_inline_forbidden))) return 0;
 
   /* Do not inline variadic functions. */
@@ -938,14 +985,16 @@ int inline_method(ir_node *call, ir_graph *called_graph) {
      graph. Both will end up being a tuple.  -- */
   post_bl = get_nodes_block(call);
   set_irg_current_block(current_ir_graph, post_bl);
-  /* XxMxPxP of Start + parameter of Call */
-  in[pn_Start_X_initial_exec] = new_Jmp();
-  in[pn_Start_M]              = get_Call_mem(call);
-  in[pn_Start_P_frame_base]   = get_irg_frame(current_ir_graph);
-  in[pn_Start_P_globals]      = get_irg_globals(current_ir_graph);
-  in[pn_Start_T_args]         = new_Tuple(get_Call_n_params(call), get_Call_param_arr(call));
+  /* XxMxPxPxPxT of Start + parameter of Call */
+  in[pn_Start_X_initial_exec]   = new_Jmp();
+  in[pn_Start_M]                = get_Call_mem(call);
+  in[pn_Start_P_frame_base]     = get_irg_frame(current_ir_graph);
+  in[pn_Start_P_globals]        = get_irg_globals(current_ir_graph);
+  in[pn_Start_P_tls]            = get_irg_tls(current_ir_graph);
+  in[pn_Start_T_args]           = new_Tuple(get_Call_n_params(call), get_Call_param_arr(call));
   /* in[pn_Start_P_value_arg_base] = ??? */
-  pre_call = new_Tuple(5, in);
+  assert(pn_Start_P_value_arg_base == pn_Start_max - 1 && "pn_Start_P_value_arg_base not supported, fix");
+  pre_call = new_Tuple(pn_Start_max - 1, in);
   post_call = call;
 
   /* --
@@ -1307,7 +1356,7 @@ void inline_small_irgs(ir_graph *irg, int size) {
       ir_graph *callee;
       callee = get_entity_irg(get_SymConst_entity(get_Call_ptr(env.calls[i])));
       if (((_obstack_memory_used(callee->obst) - (int)obstack_room(callee->obst)) < size) ||
-        (get_irg_inline_property(callee) == irg_inline_forced)) {
+        (get_irg_inline_property(callee) >= irg_inline_forced)) {
         inline_method(env.calls[i], callee);
       }
     }
@@ -1490,7 +1539,7 @@ void inline_leave_functions(int maxsize, int leavesize, int size) {
 
       if (callee &&
           ((is_smaller(callee, size) && (env->n_nodes < maxsize)) ||    /* small function */
-           (get_irg_inline_property(callee) == irg_inline_forced))) {
+           (get_irg_inline_property(callee) >= irg_inline_forced))) {
         if (!phiproj_computed) {
             phiproj_computed = 1;
             collect_phiprojs(current_ir_graph);
@@ -1972,8 +2021,7 @@ void place_code(ir_graph *irg) {
 
   /* Handle graph state */
   assert(get_irg_phase_state(irg) != phase_building);
-  if (get_irg_dom_state(irg) != dom_consistent)
-    compute_doms(irg);
+  assure_doms(irg);
 
   if (1 || get_irg_loopinfo_state(irg) != loopinfo_consistent) {
     free_loop_information(irg);