use a hook to dump vrp info instead of polluting irdump.c

[libfirm] / ir / ana / irbackedge.c

diff --git a/ir/ana/irbackedge.c b/ir/ana/irbackedge.c
index c28cc9d..6607f21 100644 (file)
--- 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,7 +44,7 @@
  * 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:
@@ -65,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
@@ -85,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;
 }
@@ -96,15 +96,15 @@ 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);
@@ -119,37 +119,36 @@ void fix_backedges(struct obstack *obst, ir_node *n)
 }
 
 /* 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);
+       bitset_t *ba = get_backarray(n);
        assert(ba && "can only set backedges at Phi, Block nodes.");
-       rbitset_set(ba, pos);
+       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);
+       bitset_t *ba = get_backarray(n);
        assert(ba && "can only set backedges at Phi, Block nodes.");
-       rbitset_clear(ba, pos);
+       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;
 }
@@ -157,18 +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;
-       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);
        }
 }
 
 /* Allocate a new backedge array on the obstack for given size. */
-unsigned *new_backedge_arr(struct obstack *obst, unsigned size)
+bitset_t *new_backedge_arr(struct obstack *obst, size_t size)
 {
-       return rbitset_w_size_obstack_alloc(obst, size);
+       return bitset_obstack_alloc(obst, size);
 }