irgmod: Pass the new inputs to turn_into_tuple() instead of initialising them with...

[libfirm] / ir / ana / irscc.c

diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c
index edae426..e97911d 100644 (file)
--- a/ir/ana/irscc.c
+++ b/ir/ana/irscc.c
@@ -54,16 +54,6 @@ static int loop_node_cnt = 0;
 /** Counter to generate depth first numbering of visited nodes. */
 static int current_dfn = 1;
 
-static unsigned max_loop_depth = 0;
-
-void link_to_reg_end(ir_node *n, void *env);
-void set_projx_link(ir_node *cb_projx, ir_node *end_projx);
-ir_node *get_projx_link(ir_node *cb_projx);
-
-/**********************************************************************/
-/* Node attributes                                                   **/
-/**********************************************************************/
-
 /**********************************************************************/
 /* Node attributes needed for the construction.                      **/
 /**********************************************************************/
@@ -72,12 +62,6 @@ typedef struct scc_info {
        int in_stack;          /**< Marks whether node is on the stack. */
        int dfn;               /**< Depth first search number. */
        int uplink;            /**< dfn number of ancestor. */
-       /*  ir_loop *loop;         *//* Refers to the containing loop. */
-       /*
-           struct section *section;
-           xset def;
-           xset use;
-       */
 } scc_info;
 
 /**
@@ -158,36 +142,6 @@ static int get_irn_dfn(ir_node *n)
        return scc->dfn;
 }
 
-#if 0
-static ir_loop *find_nodes_loop(ir_node *n, ir_loop *l)
-{
-       int i;
-       ir_loop *res = NULL;
-
-       /* Test whether n is contained in this loop. */
-       for (i = 0; i < get_loop_n_nodes(l); i++)
-               if (n == get_loop_node(l, i)) return l;
-
-       /* Is this a leave in the loop tree? If so loop not found. */
-       if (get_loop_n_sons(l) == 0) return NULL;
-
-       /* Else descend in the loop tree. */
-       for (i = 0; i < get_loop_n_sons(l); i++) {
-               res = find_nodes_loop(n, get_loop_son(l, i));
-               if (res) break;
-       }
-       return res;
-}
-
-/* @@@ temporary implementation, costly!!! */
-ir_loop * get_irn_loop(ir_node *n)
-{
-       ir_loop *l = get_irg_loop(current_ir_graph);
-       l = find_nodes_loop(n, l);
-       return l;
-}
-#endif
-
 /**********************************************************************/
 /* A stack.                                                          **/
 /**********************************************************************/
@@ -316,7 +270,6 @@ static ir_loop *new_loop(void)
        ir_loop *father = current_loop;
        ir_loop *son    = alloc_loop(father, get_irg_obstack(outermost_ir_graph));
 
-       if (son->depth > max_loop_depth) max_loop_depth = son->depth;
        current_loop = son;
        return father;
 }
@@ -345,9 +298,6 @@ static inline void init_scc(ir_graph *irg, struct obstack *obst)
 {
        init_scc_common();
        irg_walk_graph(irg, init_node, NULL, obst);
-       /*
-       irg_walk (irg, link_to_reg_end, NULL, NULL);
-       */
 }
 
 static inline void finish_scc(void)
@@ -379,11 +329,6 @@ static int is_outermost_Start(ir_node *n)
 /* When to walk from nodes to blocks. Only for Control flow operations? */
 static inline int get_start_index(ir_node *n)
 {
-#undef BLOCK_BEFORE_NODE
-#define BLOCK_BEFORE_NODE 1
-
-#if BLOCK_BEFORE_NODE
-
        /* This version assures, that all nodes are ordered absolutely.  This allows
           to undef all nodes in the heap analysis if the block is false, which
           means not reachable.
@@ -397,20 +342,6 @@ static inline int get_start_index(ir_node *n)
                return 0;
        else
                return -1;
-
-#else
-
-       /* This version causes deeper loop trees (at least we verified this
-          for Polymor).
-          But it guarantees that Blocks are analysed before nodes contained in the
-          block.  If so, we can set the value to undef if the block is not \
-          executed. */
-       if (is_cfop(n) || is_fragile_op(n) || is_Start(n))
-               return -1;
-       else
-               return 0;
-
-#endif
 }
 
 /**
@@ -560,9 +491,6 @@ static ir_node *find_tail(ir_node *n)
        ir_node *m;
        int i, res_index = -2;
 
-       /*
-       if (!icfg && rm_cyclic_phis && remove_cyclic_phis (n)) return NULL;
-        */
        m = stack[tos-1];  /* tos = top of stack */
        if (is_head(m, n)) {
                res_index = smallest_dfn_pred(m, 0);
@@ -737,13 +665,12 @@ static void scc(ir_node *n)
        }
 }
 
-int construct_backedges(ir_graph *irg)
+void construct_backedges(ir_graph *irg)
 {
        ir_graph *rem = current_ir_graph;
        ir_loop *head_rem;
        struct obstack temp;
 
-       max_loop_depth = 0;
        current_ir_graph   = irg;
        outermost_ir_graph = irg;
 
@@ -767,7 +694,6 @@ int construct_backedges(ir_graph *irg)
        add_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
        assert(get_irg_loop(irg)->kind == k_ir_loop);
        current_ir_graph = rem;
-       return max_loop_depth;
 }
 
 static void reset_backedges(ir_node *n)
@@ -777,19 +703,6 @@ static void reset_backedges(ir_node *n)
        }
 }
 
-/*
-static void loop_reset_backedges(ir_loop *l)
-{
-       int i;
-       reset_backedges(get_loop_node(l, 0));
-       for (i = 0; i < get_loop_n_nodes(l); ++i)
-               set_irn_loop(get_loop_node(l, i), NULL);
-       for (i = 0; i < get_loop_n_sons(l); ++i) {
-               loop_reset_backedges(get_loop_son(l, i));
-       }
-}
-*/
-
 static void loop_reset_node(ir_node *n, void *env)
 {
        (void) env;
@@ -799,11 +712,6 @@ static void loop_reset_node(ir_node *n, void *env)
 
 void free_loop_information(ir_graph *irg)
 {
-       /* We can not use this recursion, as the loop might contain
-          illegal nodes by now.  Why else would we throw away the
-          representation?
-       if (get_irg_loop(irg)) loop_reset_backedges(get_irg_loop(irg));
-       */
        irg_walk_graph(irg, loop_reset_node, NULL, NULL);
        set_irg_loop(irg, NULL);
        clear_irg_properties(current_ir_graph, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);