X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Finterval_analysis.c;h=d52a814fb71ec9fe714e0c63d1851905e19de391;hb=d5d7159c209a9e5c5fa276f770b5b28a217990a8;hp=ff15888d849b010a58d6e091ca2d5e7b95b03a2b;hpb=f0ab4b9fdc3da000de99d540aec49253218ce2aa;p=libfirm

diff --git a/ir/ana/interval_analysis.c b/ir/ana/interval_analysis.c
index ff15888d8..d52a814fb 100644
--- a/ir/ana/interval_analysis.c
+++ b/ir/ana/interval_analysis.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -29,7 +29,6 @@
 #include "debug.h"
 #include "interval_analysis.h"
 #include "execution_frequency.h"
-#include "firm_common_t.h"
 #include "set.h"
 #include "array.h"
 
@@ -64,7 +63,8 @@ static set *region_attr_set = NULL;
 /**
  * Compare two region attributes for identical regions.
  */
-static int region_attr_cmp(const void *e1, const void *e2, size_t size) {
+static int region_attr_cmp(const void *e1, const void *e2, size_t size)
+{
 	region_attr *ra1 = (region_attr *)e1;
 	region_attr *ra2 = (region_attr *)e2;
 	(void) size;
@@ -72,7 +72,8 @@ static int region_attr_cmp(const void *e1, const void *e2, size_t size) {
 }
 
 /** Hash a region attribute (the region only). */
-static inline int attr_set_hash(region_attr *a) {
+static inline int attr_set_hash(region_attr *a)
+{
 	return HASH_PTR(a->reg);
 }
 
@@ -82,11 +83,12 @@ static inline int attr_set_hash(region_attr *a) {
  *
  * @param region  the region
  */
-static inline region_attr *get_region_attr(void *region) {
+static inline region_attr *get_region_attr(void *region)
+{
 	region_attr r_attr, *res;
 	r_attr.reg = region;
 
-	res = set_find(region_attr_set, &r_attr, sizeof(r_attr), attr_set_hash(&r_attr));
+	res = (region_attr*) set_find(region_attr_set, &r_attr, sizeof(r_attr), attr_set_hash(&r_attr));
 
 	if (res == NULL) {
 		r_attr.in_array = NEW_ARR_F(void *, 0);
@@ -96,45 +98,53 @@ static inline region_attr *get_region_attr(void *region) {
 			r_attr.op_array = NULL;
 		r_attr.n_outs     = 0;
 		r_attr.n_exc_outs = 0;
-		res = set_insert(region_attr_set, &r_attr, sizeof(r_attr), attr_set_hash(&r_attr));
+		res = (region_attr*) set_insert(region_attr_set, &r_attr, sizeof(r_attr), attr_set_hash(&r_attr));
 	}
 
 	return res;
 }
 
-int get_region_n_ins(void *region) {
-	return ARR_LEN(get_region_attr(region)->in_array);
+int get_region_n_ins(void *region)
+{
+	return (int)ARR_LEN(get_region_attr(region)->in_array);
 }
 
-void *get_region_in(void *region, int pos) {
+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]);
 }
 
-void add_region_in(void *region, void *in) {
+void add_region_in(void *region, void *in)
+{
 	ARR_APP1(void *, get_region_attr(region)->in_array, in);
 	get_region_attr(in)->n_outs++;
 }
 
-int get_region_n_outs(void *region) {
+int get_region_n_outs(void *region)
+{
 	return get_region_attr(region)->n_outs;
 }
 
-int get_region_n_exc_outs(void *region) {
+int get_region_n_exc_outs(void *region)
+{
 	return get_region_attr(region)->n_exc_outs;
 }
 
-void inc_region_n_exc_outs(void *region) {
+static void inc_region_n_exc_outs(void *region)
+{
 	(get_region_attr(region)->n_exc_outs)++;
 }
 
-void *get_loop_cfop(void *region, int pos) {
+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]);
 }
 
 /** Add a control flow op to a loop region. */
-static inline void add_loop_cfop(void *region, void *cfop) {
+static inline void add_loop_cfop(void *region, void *cfop)
+{
 	assert(cfop);
 	ARR_APP1(void *, get_region_attr(region)->op_array, cfop);
 }
@@ -146,7 +156,8 @@ static inline void add_loop_cfop(void *region, void *cfop) {
  * @param reg   a region
  * @param cfop  a control flow operation leaving this region
  */
-static inline void exc_outs(void *reg, ir_node *cfop) {
+static inline void exc_outs(void *reg, ir_node *cfop)
+{
 	if (is_fragile_op(cfop) || is_fragile_Proj(cfop))
 		inc_region_n_exc_outs(reg);
 }
@@ -167,7 +178,8 @@ static inline void exc_outs(void *reg, ir_node *cfop) {
  *
  * @return  non-zero if outer can be reached from inner via the outer loop relation
  */
-static int find_outer_loop(ir_loop *inner, ir_loop *outer, ir_node *blk, ir_node *cfop) {
+static int find_outer_loop(ir_loop *inner, ir_loop *outer, ir_node *blk, ir_node *cfop)
+{
 	if (get_loop_outer_loop(inner) == outer) {
 		add_region_in(inner, blk);
 		add_loop_cfop(inner, cfop);
@@ -184,8 +196,9 @@ static int find_outer_loop(ir_loop *inner, ir_loop *outer, ir_node *blk, ir_node
  * @param blk   a block
  * @param loop  a loop
  */
-static int test_loop_nest(ir_node *blk, ir_loop *loop) {
-	int i, n_elems = get_loop_n_elements(loop);
+static int test_loop_nest(ir_node *blk, ir_loop *loop)
+{
+	size_t i, n_elems = get_loop_n_elements(loop);
 
 	for (i = 0; i < n_elems; ++i) {
 		loop_element e = get_loop_element(loop, i);
@@ -216,8 +229,9 @@ static int test_loop_nest(ir_node *blk, ir_loop *loop) {
  *
  * @return non-zero if pred is from an inner loop
  */
-static int find_inner_loop(ir_node *blk, ir_loop *l, ir_node *pred, ir_node *cfop) {
-	int i, n_elems = get_loop_n_elements(l);
+static int find_inner_loop(ir_node *blk, ir_loop *l, ir_node *pred, ir_node *cfop)
+{
+	size_t i, n_elems = get_loop_n_elements(l);
 	int found = 0;
 
 	for (i = 0; i < n_elems; ++i) {
@@ -261,14 +275,14 @@ static int find_previous_loop(ir_loop *l, ir_loop *pred_l, ir_node *b,
                               ir_node *pred_b, ir_node *cfop)
 {
 	ir_loop *outer = get_loop_outer_loop(l);
-	int found, i;
-	int l_pos = get_loop_element_pos(outer, l);
+	int found;
+	size_t i, l_pos = get_loop_element_pos(outer, l);
 	(void) pred_l;
-	assert(l_pos > -1);
+	assert(l_pos != INVALID_LOOP_POS);
 	assert(l_pos > 0 && "Is this a necessary condition?  There could be a perfect nest ...");
 
-	for (i = l_pos -1, found = 0; i > -1 && !found; --i) {
-		ir_loop *k = get_loop_element(outer, i).son;
+	for (i = l_pos, found = 0; i > 0;) {
+		ir_loop *k = get_loop_element(outer, --i).son;
 		if (is_ir_loop(k)) {
 			found = test_loop_nest(pred_b, k);
 			if (found) {
@@ -277,6 +291,7 @@ static int find_previous_loop(ir_loop *l, ir_loop *pred_l, ir_node *b,
 				add_loop_cfop(l, cfop);
 				/* placeholder: the edge is in the loop region */
 				add_region_in(b, NULL);
+				break;
 			}
 		}
 	}
@@ -301,7 +316,8 @@ static int find_previous_loop(ir_loop *l, ir_loop *pred_l, ir_node *b,
  *   branches directly from loop k to loop l.  Add an edge l->k.  Watch it: k must
  *   not be a direct predecessor of l in the loop tree!
  */
-static void construct_interval_block(ir_node *blk, ir_loop *l) {
+static void construct_interval_block(ir_node *blk, ir_loop *l)
+{
 	int i, n_cfgpreds;
 
 	if (blk == get_irg_start_block(current_ir_graph))
@@ -385,8 +401,9 @@ static void construct_interval_block(ir_node *blk, ir_loop *l) {
  *
  * @param l  the cf loop
  */
-static void construct_interval_edges(ir_loop *l) {
-	int i, n_elems = get_loop_n_elements(l);
+static void construct_interval_edges(ir_loop *l)
+{
+	size_t i, n_elems = get_loop_n_elements(l);
 	for (i = 0; i < n_elems; ++i) {
 		loop_element e = get_loop_element(l, i);
 		switch (*e.kind) {
@@ -402,7 +419,8 @@ static void construct_interval_edges(ir_loop *l) {
 	}
 }
 
-void construct_intervals(ir_graph *irg) {
+void construct_intervals(ir_graph *irg)
+{
 	ir_loop  *l;
 	ir_graph *rem = current_ir_graph;
 
@@ -413,24 +431,25 @@ void construct_intervals(ir_graph *irg) {
 	if (region_attr_set == NULL)
 		region_attr_set = new_set(region_attr_cmp, 256);
 
-	construct_cf_backedges(current_ir_graph);
+	construct_cf_backedges(irg);
 
-	l = get_irg_loop(current_ir_graph);
+	l = get_irg_loop(irg);
 
 	construct_interval_edges(l);
 
 	current_ir_graph = rem;
 }
 
-void free_intervals(void) {
+void free_intervals(void)
+{
 	region_attr *res;
 
 	if (region_attr_set == NULL)
 		return;
 
-	for (res = set_first(region_attr_set);
+	for (res = (region_attr*) set_first(region_attr_set);
 	     res != NULL;
-	     res = set_next(region_attr_set)) {
+	     res = (region_attr*) set_next(region_attr_set)) {
 		DEL_ARR_F(res->in_array);
 		if (res->op_array != NULL)
 			DEL_ARR_F(res->op_array);
@@ -445,11 +464,12 @@ void free_intervals(void) {
 /*                                                                  */
 /*------------------------------------------------------------------*/
 
-void dump_region_edges(FILE *F, void *reg) {
+static void dump_region_edges(FILE *F, void *reg)
+{
 	int i, n_ins = get_region_n_ins(reg);
 
 	if (is_ir_node(reg)) {
-		ir_node *irn = reg;
+		ir_node *irn = (ir_node*) reg;
 		if (get_Block_n_cfgpreds(irn) > get_region_n_ins(reg)) {
 			for (i = n_ins; i < get_Block_n_cfgpreds(irn); ++i) {
 				if (is_backedge(irn, i))
@@ -468,7 +488,7 @@ void dump_region_edges(FILE *F, void *reg) {
 		void *target = get_region_in(reg, i);
 
 		if (is_ir_node(reg)) {
-			ir_node *irn = reg;
+			ir_node *irn = (ir_node*) reg;
 			if (get_Block_n_cfgpreds(irn) != get_region_n_ins(reg)) {
 				ir_printf("n_cfgpreds = %d, n_ins = %d\n %+F\n", get_Block_n_cfgpreds(irn), get_region_n_ins(reg), irn);
 			}
@@ -501,7 +521,7 @@ void dump_region_edges(FILE *F, void *reg) {
 			PRINT_LOOPID(((ir_loop *)target));
 		}
 		fprintf(F, "\"");
-		if (is_ir_node(reg) && is_fragile_op(skip_Proj(get_Block_cfgpred(reg, i))))
+		if (is_ir_node(reg) && is_fragile_op(skip_Proj(get_Block_cfgpred((ir_node*) reg, i))))
 			fprintf(F, EXC_CF_EDGE_ATTR);
 		fprintf(F, "}\n");
 	}
@@ -509,7 +529,8 @@ void dump_region_edges(FILE *F, void *reg) {
 
 #include "execution_frequency.h"
 
-static void dump_interval_block(FILE *F, ir_node *block) {
+static void dump_interval_block(FILE *F, ir_node *block)
+{
 	int i, fl;
 	/* This is a block. Dump a node for the block. */
 	fprintf(F, "node: {title: \""); PRINT_NODEID(block);
@@ -526,7 +547,7 @@ static void dump_interval_block(FILE *F, ir_node *block) {
 	fprintf(F, " n_exc_outs: %d", get_region_n_exc_outs(block));
 	fprintf(F, "\" ");
 	fprintf(F, "info1:\"");
-	if (dump_dominator_information_flag)
+	if (ir_get_dump_flags() & ir_dump_flag_dominance)
 		fprintf(F, "dom depth %d\n", get_Block_dom_depth(block));
 
 	/* show arity and possible Bad predecessors of the block */
@@ -554,12 +575,13 @@ static void dump_interval_block(FILE *F, ir_node *block) {
 	fprintf(F, "}\n");
 }
 
-static void dump_interval_loop(FILE *F, ir_loop *l) {
-	int i, n_elems = get_loop_n_elements(l);
+static void dump_interval_loop(FILE *F, ir_loop *l)
+{
+	size_t i, n_elems = get_loop_n_elements(l);
 
 	fprintf(F, "graph: { title: \"");
 	PRINT_LOOPID(l);
-	fprintf(F, "\" label: \"loop %d", get_loop_loop_nr(l));
+	fprintf(F, "\" label: \"loop %ld", get_loop_loop_nr(l));
 	fprintf(F, " freq: %9.4lf", get_region_exec_freq(l));
 	fprintf(F, " n_outs: %d", get_region_n_outs(l));
 	fprintf(F, " n_exc_outs: %d", get_region_n_exc_outs(l));
@@ -583,24 +605,14 @@ static void dump_interval_loop(FILE *F, ir_loop *l) {
 	fprintf(F, "}\n\n");
 }
 
-
-void dump_interval_graph(ir_graph *irg, const char *suffix) {
-	FILE     *f;
-	ir_graph *rem;
-
-	if (!is_filtered_dump_name(get_entity_ident(get_irg_entity(irg))))
-		return;
-
-	f = vcg_open(irg, suffix, "-intervals");
-	dump_vcg_header(f, get_irg_dump_name(irg), NULL, NULL);
-
-	rem              = current_ir_graph;
+void dump_interval_graph(FILE *out, ir_graph *irg)
+{
+	ir_graph *rem    = current_ir_graph;
 	current_ir_graph = irg;
 
-	dump_interval_loop(f, get_irg_loop(irg));
-
-	dump_vcg_footer(f);
-	fclose(f);
+	dump_vcg_header(out, get_irg_dump_name(irg), NULL, NULL);
+	dump_interval_loop(out, get_irg_loop(irg));
+	dump_vcg_footer(out);
 
 	current_ir_graph = rem;
 }