remove opt_manage, provide assure_irg_properties

[libfirm] / ir / ana / irscc.c

diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c
index 8fa6b41..610c693 100644 (file)
--- 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);