X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firscc.c;h=9ae89f97a6aed3845533c77fece7aa62bb98f74a;hb=8aca33381b3dea1ef0bb6c120f59989075c438d1;hp=68df00ca850dd560c09713d0a7f421fce9d5cc38;hpb=337d80943727432a91e53ef5b5554eac00a7b7da;p=libfirm

diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c
index 68df00ca8..9ae89f97a 100644
--- 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);