X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firscc.c;h=610c69378ac37d706553f5f6c2ae8604ab2891eb;hb=7a483ab981d403222150c320242adaad13d60af9;hp=8fa6b4145af8a42f16b4d7afd828c94c31837a40;hpb=0a4048fbaae21a969b0f03b066dde30a06968814;p=libfirm

diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c
index 8fa6b4145..610c69378 100644
--- a/ir/ana/irscc.c
+++ b/ir/ana/irscc.c
@@ -25,7 +25,6 @@
  *              Chapter 5.2.1.2.
  * @author   Goetz Lindenmaier
  * @date     7.2002
- * @version  $Id$
  */
 #include "config.h"
 
@@ -41,6 +40,7 @@
 #include "irdump.h"
 #include "array.h"
 #include "pmap.h"
+#include "ircons.h"
 
 /* A variant of the loop tree that avoids loops without head.
    This reduces the depth of the loop tree. */
@@ -274,7 +274,7 @@ static inline void pop_scc_to_loop(ir_node *n)
    can't they have two loops as sons? Does it never get that far? ) */
 static void close_loop(ir_loop *l)
 {
-	int last = get_loop_n_elements(l) - 1;
+	size_t last = get_loop_n_elements(l) - 1;
 	loop_element lelement = get_loop_element(l, last);
 	ir_loop *last_son = lelement.son;
 
@@ -609,7 +609,9 @@ static ir_node *find_tail(ir_node *n)
 						res_index = largest_dfn_pred (m);
 					break;
 				}
-				if (m == n) { break; }  /* It's not an unreachable loop, either. */
+				/* It's not an unreachable loop, either. */
+				if (m == n)
+					break;
 			}
 			//assert(0 && "no head found on stack");
 		}
@@ -619,8 +621,10 @@ static ir_node *find_tail(ir_node *n)
 		/* It's a completely bad loop: without Phi/Block nodes that can
 		   be a head. I.e., the code is "dying".  We break the loop by
 		   setting Bad nodes. */
-		int arity = get_irn_arity(n);
-		ir_node *bad = get_irg_bad(get_irn_irg(n));
+		ir_graph *irg   = get_irn_irg(n);
+		ir_mode  *mode  = get_irn_mode(n);
+		ir_node  *bad   = new_r_Bad(irg, mode);
+		int       arity = get_irn_arity(n);
 		for (i = -1; i < arity; ++i) {
 			set_irn_n(n, i, bad);
 		}
@@ -745,8 +749,6 @@ static void scc(ir_node *n)
 	}
 }
 
-/* Constructs backedge information for irg. In interprocedural view constructs
-   backedges for all methods called by irg, too. */
 int construct_backedges(ir_graph *irg)
 {
 	ir_graph *rem = current_ir_graph;
@@ -774,7 +776,7 @@ int construct_backedges(ir_graph *irg)
 	assert(head_rem == current_loop);
 	mature_loops(current_loop, irg->obst);
 	set_irg_loop(irg, current_loop);
-	set_irg_loopinfo_state(irg, loopinfo_consistent);
+	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;
@@ -807,8 +809,6 @@ static void loop_reset_node(ir_node *n, void *env)
 	reset_backedges(n);
 }
 
-/** Removes all loop information.
-    Resets all backedges */
 void free_loop_information(ir_graph *irg)
 {
 	/* We can not use this recursion, as the loop might contain
@@ -818,7 +818,7 @@ void free_loop_information(ir_graph *irg)
 	*/
 	irg_walk_graph(irg, loop_reset_node, NULL, NULL);
 	set_irg_loop(irg, NULL);
-	set_irg_loopinfo_state(current_ir_graph, loopinfo_none);
+	clear_irg_properties(current_ir_graph, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
 	/* We cannot free the loop nodes, they are on the obstack. */
 }
 
@@ -836,7 +836,7 @@ void free_all_loop_information(void)
 
 static int is_loop_variant(ir_loop *l, ir_loop *b)
 {
-	int i, n_elems;
+	size_t i, n_elems;
 
 	if (l == b) return 1;
 
@@ -851,14 +851,6 @@ static int is_loop_variant(ir_loop *l, ir_loop *b)
 	return 0;
 }
 
-/* Test whether a value is loop invariant.
- *
- * @param n      The node to be tested.
- * @param block  A block node.  We pass the block, not the loop as we must
- *               start off with a block loop to find all proper uses.
- *
- * Returns non-zero, if the node n is not changed in the loop block
- * belongs to or in inner loops of this blocks loop. */
 int is_loop_invariant(const ir_node *n, const ir_node *block)
 {
 	ir_loop *l = get_irn_loop(block);