beloopana: Remove duplicate comments.

[libfirm] / ir / ana / irscc.c

diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c
index 68df00c..9ae89f9 100644 (file)
--- a/ir/ana/irscc.c
+++ b/ir/ana/irscc.c
@@ -1,20 +1,6 @@
 /*
- * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
- *
  * This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
  */
 
 /**
@@ -62,12 +48,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;
 
 /**
@@ -148,36 +128,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.                                                          **/
 /**********************************************************************/
@@ -365,11 +315,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.
@@ -383,20 +328,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
 }
 
 /**
@@ -546,9 +477,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);
@@ -761,19 +689,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;
@@ -783,11 +698,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);