changed code placement so it can work in more environments:

[libfirm] / ir / ana / interval_analysis.c

diff --git a/ir/ana/interval_analysis.c b/ir/ana/interval_analysis.c
index 5e90668..41edaa0 100644 (file)
--- a/ir/ana/interval_analysis.c
+++ b/ir/ana/interval_analysis.c
@@ -1,6 +1,14 @@
 
-#include "interval_analysis.h"
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
 
+#include "interval_analysis.h"
+#include "execution_frequency.h"
 #include "firm_common_t.h"
 #include "set.h"
 #include "array.h"
@@ -9,6 +17,7 @@
 #include "irnode.h"
 #include "irdump_t.h"
 #include "irdom.h"
+#include "irflag.h"
 
 /*------------------------------------------------------------------*/
 /* A new in array via a hashmap. */
@@ -63,7 +72,7 @@ int get_region_n_ins(void *region) {
 
 void *get_region_in(void *region, int pos) {
   assert(0 <= pos && pos < get_region_n_ins(region));
-  return (get_region_attr(region)->in_array)[pos];
+  return ((get_region_attr(region)->in_array)[pos]);
 }
 
 void add_region_in (void *region, void *in) {
@@ -85,7 +94,7 @@ void inc_region_n_exc_outs(void *region) {
 
 void *get_loop_cfop(void *region, int pos) {
   assert(0 <= pos && pos < get_region_n_ins(region));
-  return (get_region_attr(region)->op_array)[pos];
+  return ((get_region_attr(region)->op_array)[pos]);
 }
 
 void add_loop_cfop (void *region, void *cfop) {
@@ -94,7 +103,8 @@ void add_loop_cfop (void *region, void *cfop) {
 }
 
 static INLINE void exc_outs(void *reg, ir_node *cfop) {
-  if (is_fragile_op(cfop)) inc_region_n_exc_outs(reg);
+  if (is_fragile_op(cfop) || (is_fragile_Proj(cfop)))
+    inc_region_n_exc_outs(reg);
 }
 
 /*------------------------------------------------------------------*/
@@ -213,18 +223,34 @@ static void construct_interval_block(ir_node *b, ir_loop *l) {
   assert(n_cfgpreds > 0);
 
   for (i = 0; i < n_cfgpreds; ++i) {
+    ir_node *cfop, *pred;
+    ir_loop *pred_l;
+
     if (is_backedge(b, i)) {
+      if (b != get_loop_element(l, 0).node) {
+           if (get_firm_verbosity()) {
+             printf("Loophead not at loop position 0. "); DDMN(b);
+           }
+      }
       /* There are no backedges in the interval decomposition. */
       add_region_in(b, NULL);
       continue;
     }
 
-    ir_node *cfop = skip_Proj(get_Block_cfgpred(b, i));
-    ir_node *pred = get_nodes_block(cfop);
+    cfop = get_Block_cfgpred(b, i);
+    if (is_Proj(cfop)) {
+      if (get_irn_op(get_Proj_pred(cfop)) != op_Cond) {
+       cfop = skip_Proj(cfop);
+      } else {
+       assert(get_nodes_block(cfop) == get_nodes_block(skip_Proj(cfop)));
+      }
+    }
+
+    pred = skip_Proj(get_nodes_block(cfop));
     /* We want nice blocks. */
     assert(   get_irn_op(pred) != op_Bad
            && get_irn_op(skip_Proj(get_Block_cfgpred(b, i))) != op_Bad);
-    ir_loop *pred_l = get_irn_loop(pred);
+    pred_l = get_irn_loop(pred);
     if (pred_l == l) {
       add_region_in(b, pred);
       //if (is_fragile_op(cfop)) inc_region_n_exc_outs(b);
@@ -232,28 +258,33 @@ static void construct_interval_block(ir_node *b, ir_loop *l) {
     } else {
       int found = find_inner_loop(b, l, pred, cfop);
       if (!found) {
-       found = find_outer_loop(l, pred_l, pred, cfop);
-       if (found) add_region_in(b, NULL);  /* placeholder */
+           if (b != get_loop_element(l, 0).node) {
+             if (get_firm_verbosity()) {
+               printf("Loop entry not at loop position 0. "); DDMN(b);
+             }
+           }
+           found = find_outer_loop(l, pred_l, pred, cfop);
+           if (found) add_region_in(b, NULL);  /* placeholder */
       }
       if (!found) {
-       found = find_previous_loop(l, pred_l, b, pred, cfop);
+        found = find_previous_loop(l, pred_l, b, pred, cfop);
       }
       if (!found) {
-       DDMG(current_ir_graph);
-       DDMN(b);
-       DDMN(pred);
-       assert(is_backedge(b, i));
-       assert(found && "backedge from inner loop");
+           DDMG(current_ir_graph);
+           DDMN(b);
+           DDMN(pred);
+           assert(is_backedge(b, i));
+           assert(found && "backedge from inner loop");
       }
     }
 
     if (b != get_loop_element(l, 0).node) {
       /* Check for improper region */
       if (has_backedges(b)) {
-       printf("Improper Region!!!!!!\n");
-       DDMG(current_ir_graph);
-       DDMN(b);
-       DDML(l);
+           printf("Improper Region!!!!!!\n");
+           DDMG(current_ir_graph);
+           DDMN(b);
+           DDML(l);
       }
     }
   }
@@ -285,7 +316,6 @@ void construct_intervals(ir_graph *irg) {
 
   construct_cf_backedges(current_ir_graph);
 
-
   l = get_irg_loop(current_ir_graph);
 
   construct_interval_edges(l);
@@ -450,7 +480,7 @@ void dump_interval_loop(FILE *F, ir_loop *l) {
 void dump_interval_graph(ir_graph *irg, const char *suffix) {
   FILE *f;
 
-  if (strncmp(get_entity_name(get_irg_entity(irg)), dump_file_filter, strlen(dump_file_filter)) != 0)
+  if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
     return;
 
   f = vcg_open(irg, suffix, "-intervals");