- reenabled modeb handling after condeval fix

[libfirm] / ir / ana / ircfscc.c

diff --git a/ir/ana/ircfscc.c b/ir/ana/ircfscc.c
index 884a309..15230a9 100644 (file)
--- a/ir/ana/ircfscc.c
+++ b/ir/ana/ircfscc.c
@@ -163,6 +163,12 @@ static INLINE void init_stack(void) {
        tos = 0;
 }
 
+static void finish_stack(void)
+{
+       DEL_ARR_F(stack);
+       stack = NULL;
+}
+
 /**
  * Push a node n onto the IR-node stack.
  */
@@ -296,6 +302,11 @@ static INLINE void init_scc(ir_graph *irg, struct obstack *obst) {
        irg_walk_graph(irg, init_node, NULL, obst);
 }
 
+static INLINE void finish_scc(void)
+{
+       finish_stack();
+}
+
 #ifdef INTERPROCEDURAL_VIEW
 /**
  * Initializes the scc algorithm for the interprocedural case.
@@ -335,20 +346,23 @@ static int is_outermost_StartBlock(ir_node *n) {
 static int is_head(ir_node *n, ir_node *root) {
        int i, arity;
        int some_outof_loop = 0, some_in_loop = 0;
+       (void) root;
 
        assert(is_Block(n));
 
        if (!is_outermost_StartBlock(n)) {
-               arity = get_irn_arity(n);
+               arity = get_Block_n_cfgpreds(n);
                for (i = 0; i < arity; i++) {
-                       ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
-                       if (is_backedge(n, i)) continue;
+                       ir_node *pred = get_Block_cfgpred_block(n, i);
+                       /* ignore Bad control flow: it cannot happen */
+                       if (is_Bad(pred))
+                               continue;
+                       if (is_backedge(n, i))
+                               continue;
                        if (!irn_is_in_stack(pred)) {
                                some_outof_loop = 1;
                        } else {
-                               if (get_irn_uplink(pred) < get_irn_uplink(root)) {
-                                       assert(get_irn_uplink(pred) >= get_irn_uplink(root));
-                               }
+                               assert(get_irn_uplink(pred) >= get_irn_uplink(root));
                                some_in_loop = 1;
                        }
                }
@@ -359,7 +373,7 @@ static int is_head(ir_node *n, ir_node *root) {
 
 /**
  * Returns non-zero if n is possible loop head of an endless loop.
- * I.e., it is a Block, Phi or Filter node and has only predecessors
+ * I.e., it is a Block node and has only predecessors
  * within the loop.
  *
  * @param n     the block node to check
@@ -367,28 +381,29 @@ static int is_head(ir_node *n, ir_node *root) {
  */
 static int is_endless_head(ir_node *n, ir_node *root) {
        int i, arity;
-       int some_outof_loop = 0, some_in_loop = 0;
+       int none_outof_loop = 1, some_in_loop = 0;
+       (void) root;
 
        assert(is_Block(n));
        /* Test for legal loop header: Block, Phi, ... */
        if (!is_outermost_StartBlock(n)) {
-               arity = get_irn_arity(n);
+               arity = get_Block_n_cfgpreds(n);
                for (i = 0; i < arity; i++) {
-                       ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
-                       assert(pred);
+                       ir_node *pred = get_Block_cfgpred_block(n, i);
+                       /* ignore Bad control flow: it cannot happen */
+                       if (is_Bad(pred))
+                               continue;
                        if (is_backedge(n, i))
                                continue;
                        if (!irn_is_in_stack(pred)) {
-                               some_outof_loop = 1; //printf(" some out of loop ");
+                               none_outof_loop = 0;
                        } else {
-                               if (get_irn_uplink(pred) < get_irn_uplink(root)) {
-                                       assert(get_irn_uplink(pred) >= get_irn_uplink(root));
-                               }
+                               assert(get_irn_uplink(pred) >= get_irn_uplink(root));
                                some_in_loop = 1;
                        }
                }
        }
-       return !some_outof_loop && some_in_loop;
+       return none_outof_loop && some_in_loop;
 }
 
 /**
@@ -399,9 +414,12 @@ static int smallest_dfn_pred(ir_node *n, int limit) {
        int i, index = -2, min = -1;
 
        if (!is_outermost_StartBlock(n)) {
-               int arity = get_irn_arity(n);
+               int arity = get_Block_n_cfgpreds(n);
                for (i = 0; i < arity; i++) {
-                       ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+                       ir_node *pred = get_Block_cfgpred_block(n, i);
+                       /* ignore Bad control flow: it cannot happen */
+                       if (is_Bad(pred))
+                               continue;
                        if (is_backedge(n, i) || !irn_is_in_stack(pred))
                                continue;
                        if (get_irn_dfn(pred) >= limit && (min == -1 || get_irn_dfn(pred) < min)) {
@@ -420,9 +438,12 @@ static int largest_dfn_pred(ir_node *n) {
        int i, index = -2, max = -1;
 
        if (!is_outermost_StartBlock(n)) {
-               int arity = get_irn_arity(n);
+               int arity = get_Block_n_cfgpreds(n);
                for (i = 0; i < arity; i++) {
-                       ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+                       ir_node *pred = get_Block_cfgpred_block(n, i);
+                       /* ignore Bad control flow: it cannot happen */
+                       if (is_Bad(pred))
+                               continue;
                        if (is_backedge(n, i) || !irn_is_in_stack(pred))
                                continue;
                        if (get_irn_dfn(pred) > max) {
@@ -480,10 +501,10 @@ static ir_node *find_tail(ir_node *n) {
                        /* A dead loop not reachable from Start. */
                        for (i = tos-2; i >= 0; --i) {
                                m = stack[i];
-                               if (is_endless_head (m, n)) {
+                               if (is_endless_head(m, n)) {
                                        res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
                                        if (res_index == -2)  /* no smallest dfn pred found. */
-                                               res_index = largest_dfn_pred (m);
+                                               res_index = largest_dfn_pred(m);
                                        break;
                                }
                                if (m == n) break;   /* It's not an unreachable loop, either. */
@@ -494,7 +515,7 @@ static ir_node *find_tail(ir_node *n) {
        assert(res_index > -2);
 
        set_backedge(m, res_index);
-       return is_outermost_StartBlock(n) ? NULL : get_nodes_block(skip_Proj(get_irn_n(m, res_index)));
+       return is_outermost_StartBlock(n) ? NULL : get_Block_cfgpred_block(m, res_index);
 }
 
 /**
@@ -527,14 +548,17 @@ static void cfscc(ir_node *n) {
        push(n);
 
        if (!is_outermost_StartBlock(n)) {
-               int arity = get_irn_arity(n);
+               int arity = get_Block_n_cfgpreds(n);
 
                for (i = 0; i < arity; i++) {
                        ir_node *m;
 
                        if (is_backedge(n, i))
                                continue;
-                       m = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+                       m = get_Block_cfgpred_block(n, i);
+                       /* ignore Bad control flow: it cannot happen */
+                       if (is_Bad(m))
+                               continue;
 
                        cfscc(m);
                        if (irn_is_in_stack(m)) {
@@ -591,7 +615,7 @@ static void cfscc(ir_node *n) {
 #endif
 
                        /* Remove the cfloop from the stack ... */
-                       pop_scc_unmark_visit (n);
+                       pop_scc_unmark_visit(n);
 
                        /* The current backedge has been marked, that is temporarily eliminated,
                           by find tail. Start the scc algorithm
@@ -644,6 +668,8 @@ int construct_cf_backedges(ir_graph *irg) {
                if (is_Block(el))
                        cfscc(el);
        }
+       finish_scc();
+       obstack_free(&temp, NULL);
 
        assert(head_rem == current_loop);
        mature_loops(current_loop, irg->obst);
@@ -651,11 +677,17 @@ int construct_cf_backedges(ir_graph *irg) {
        set_irg_loopinfo_state(irg, loopinfo_cf_consistent);
        assert(get_irg_loop(irg)->kind == k_ir_loop);
 
-       obstack_free(&temp, NULL);
        current_ir_graph = rem;
        return max_loop_depth;
 }
 
+void assure_cf_loop(ir_graph *irg) {
+       irg_loopinfo_state state = get_irg_loopinfo_state(irg);
+
+       if (state != loopinfo_cf_consistent)
+               construct_cf_backedges(irg);
+}
+
 #ifdef INTERPROCEDURAL_VIEW
 int construct_ip_cf_backedges (void) {
        ir_graph *rem = current_ir_graph;