-#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"
#include "irnode.h"
#include "irdump_t.h"
#include "irdom.h"
+#include "irflag.h"
+#include "hashptr.h"
/*------------------------------------------------------------------*/
/* A new in array via a hashmap. */
return (ra1->reg != ra2->reg);
}
-static INLINE int attr_set_hash (region_attr *a) {
- unsigned int v = (unsigned int) a->reg;
- return v ^ (v>>8);
+static INLINE int attr_set_hash(region_attr *a) {
+ return HASH_PTR(a->reg);
}
static INLINE region_attr *get_region_attr(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) {
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) {
}
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);
}
/*------------------------------------------------------------------*/
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);
} 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);
}
}
}
construct_cf_backedges(current_ir_graph);
-
l = get_irg_loop(current_ir_graph);
construct_interval_edges(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");