X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firbackedge.c;h=6607f216f22c9f325b299eb4a40d5eba485f20ab;hb=2232b14b4acf810ae96a69d1d2a33cf150b695d9;hp=a049e73c72afe8e8afadca76d50ec2cc62ca859d;hpb=32ea6ea0320f551448bb66e534e3351977464d42;p=libfirm

diff --git a/ir/ana/irbackedge.c b/ir/ana/irbackedge.c
index a049e73c7..6607f216f 100644
--- a/ir/ana/irbackedge.c
+++ b/ir/ana/irbackedge.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.
  *
@@ -44,30 +44,19 @@
  * Does not assert whether the backarray is correct -- use
  * very careful!
  */
-static unsigned *mere_get_backarray(ir_node *n)
+static bitset_t *mere_get_backarray(const ir_node *n)
 {
 	switch (get_irn_opcode(n)) {
 	case iro_Block:
 		if (!get_Block_matured(n)) return NULL;
-		if (get_interprocedural_view() && n->attr.block.in_cg) {
-			assert(n->attr.block.cg_backedge && "backedge array not allocated!");
-			return n->attr.block.cg_backedge;
-		} else {
-			assert(n->attr.block.backedge && "backedge array not allocated!");
-			return n->attr.block.backedge;
-		}
-		break;
+
+		assert(n->attr.block.backedge && "backedge array not allocated!");
+		return n->attr.block.backedge;
 	case iro_Phi:
 		assert(n->attr.phi.u.backedge && "backedge array not allocated!");
 		return n->attr.phi.u.backedge;
+	default:
 		break;
-	case iro_Filter:
-		if (get_interprocedural_view()) {
-			assert(n->attr.filter.backedge && "backedge array not allocated!");
-			return n->attr.filter.backedge;
-		}
-		break;
-	default: ;
 	}
 	return NULL;
 }
@@ -76,14 +65,14 @@ static unsigned *mere_get_backarray(ir_node *n)
  * Returns backarray if the node can have backedges, else returns
  * NULL.
  */
-static unsigned *get_backarray(ir_node *n)
+static bitset_t *get_backarray(const ir_node *n)
 {
-	unsigned *ba = mere_get_backarray(n);
+	bitset_t *ba = mere_get_backarray(n);
 
 #ifndef NDEBUG
 	if (ba) {
-		int bal = rbitset_size(ba);  /* avoid macro expansion in assertion. */
-		int inl = get_irn_arity(n);
+		size_t bal = bitset_size(ba);  /* avoid macro expansion in assertion. */
+		size_t inl = get_irn_arity(n);
 		assert(bal == inl && "backedge array with faulty length");
 	}
 #endif
@@ -96,10 +85,10 @@ static unsigned *get_backarray(ir_node *n)
  * Returns non-zero if node has no backarray, or
  *                  if size of backarray == size of in array.
  */
-static int legal_backarray(ir_node *n)
+static int legal_backarray(const ir_node *n)
 {
-	unsigned *ba = mere_get_backarray(n);
-	if (ba && (rbitset_size(ba) != (unsigned) get_irn_arity(n)))
+	bitset_t *ba = mere_get_backarray(n);
+	if (ba && (bitset_size(ba) != (unsigned) get_irn_arity(n)))
 		return 0;
 	return 1;
 }
@@ -107,88 +96,59 @@ static int legal_backarray(ir_node *n)
 
 void fix_backedges(struct obstack *obst, ir_node *n)
 {
-	unsigned *arr = mere_get_backarray(n);
-	ir_opcode opc;
+	bitset_t *arr = mere_get_backarray(n);
+	unsigned opc;
 	int arity;
 
 	if (! arr)
 		return;
 
 	arity = get_irn_arity(n);
-	if (rbitset_size(arr) != (unsigned) arity) {
+	if (bitset_size(arr) != (unsigned) arity) {
 		arr = new_backedge_arr(obst, arity);
 
 		opc = get_irn_opcode(n);
 		if (opc == iro_Phi)
 			n->attr.phi.u.backedge = arr;
 		else if (opc == iro_Block) {
-			if (!get_interprocedural_view())
-				n->attr.block.backedge = arr;
-			else
-				n->attr.block.cg_backedge = arr;
+			n->attr.block.backedge = arr;
 		}
-		else if (opc == iro_Filter)
-			n->attr.filter.backedge = arr;
 	}
 
 	assert(legal_backarray(n));
 }
 
-#ifdef INTERPROCEDURAL_VIEW
-int is_inter_backedge(ir_node *n, int pos)
-{
-	int res;
-	int rem = get_interprocedural_view();
-	set_interprocedural_view(0);
-	res = is_backedge(n, pos);
-	set_interprocedural_view(rem);
-	return res;
-}
-
-int is_intra_backedge(ir_node *n, int pos)
-{
-	int res;
-	int rem = get_interprocedural_view();
-	set_interprocedural_view(1);
-	res = is_backedge(n, pos);
-	set_interprocedural_view(rem);
-	return res;
-}
-#endif
-
-
 /* Returns non-zero if the predecessor pos is a backedge. */
-int is_backedge(ir_node *n, int pos)
+int is_backedge(const ir_node *n, int pos)
 {
-	unsigned *ba = get_backarray(n);
+	bitset_t *ba = get_backarray(n);
 	if (ba)
-		return rbitset_is_set(ba, pos);
+		return bitset_is_set(ba, pos);
 	return 0;
 }
 
 /* Remarks that edge pos is a backedge. */
 void set_backedge(ir_node *n, int pos)
 {
-	unsigned *ba = get_backarray(n);
-	assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
-	rbitset_set(ba, pos);
+	bitset_t *ba = get_backarray(n);
+	assert(ba && "can only set backedges at Phi, Block nodes.");
+	bitset_set(ba, pos);
 }
 
 /* Remarks that edge pos is a backedge. */
 void set_not_backedge(ir_node *n, int pos)
 {
-	unsigned *ba = get_backarray(n);
-	assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
-	rbitset_clear(ba, pos);
+	bitset_t *ba = get_backarray(n);
+	assert(ba && "can only set backedges at Phi, Block nodes.");
+	bitset_clear(ba, pos);
 }
 
 /* Returns non-zero if n has backedges. */
-int has_backedges(ir_node *n)
+int has_backedges(const ir_node *n)
 {
-	unsigned *ba = get_backarray(n);
-	if (ba) {
-		int arity = get_irn_arity(n);
-		return !rbitset_is_empty(ba, arity);
+	bitset_t *ba = get_backarray(n);
+	if (ba != NULL) {
+		return !bitset_is_empty(ba);
 	}
 	return 0;
 }
@@ -196,50 +156,14 @@ int has_backedges(ir_node *n)
 /** Sets all backedge information to zero. */
 void clear_backedges(ir_node *n)
 {
-	int i, arity;
-	unsigned *ba;
-#ifdef INTERPROCEDURAL_VIEW
-	int rem = get_interprocedural_view();
-	set_interprocedural_view(0);
-#endif
-	ba = get_backarray(n);
-	if (ba) {
-		arity = get_irn_arity(n);
-		for (i = 0; i < arity; i++)
-			rbitset_clear(ba, i);
-	}
-#ifdef INTERPROCEDURAL_VIEW
-	set_interprocedural_view(1);
-	ba = get_backarray (n);
-	if (ba) {
-		arity = get_irn_arity(n);
-		for (i = 0; i < arity; i++)
-			rbitset_clear(ba, i);
+	bitset_t *ba = get_backarray(n);
+	if (ba != NULL) {
+		bitset_clear_all(ba);
 	}
-	set_interprocedural_view(rem);
-#endif
 }
 
 /* Allocate a new backedge array on the obstack for given size. */
-unsigned *new_backedge_arr(struct obstack *obst, unsigned size)
-{
-	return rbitset_w_size_obstack_alloc(obst, size);
-}
-
-/* TODO: add an ir_op operation */
-void new_backedge_info(ir_node *n)
+bitset_t *new_backedge_arr(struct obstack *obst, size_t size)
 {
-	switch (get_irn_opcode(n)) {
-	case iro_Block:
-		n->attr.block.cg_backedge = NULL;
-		n->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-		break;
-	case iro_Phi:
-		n->attr.phi.u.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-		break;
-	case iro_Filter:
-		n->attr.filter.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
-		break;
-	default: ;
-	}
+	return bitset_obstack_alloc(obst, size);
 }