remove rbitset_w_size type functions: a raw_bitset with a size is a bitset_t

[r28057]

diff --git a/ir/adt/raw_bitset.h b/ir/adt/raw_bitset.h
index 8847ad8..0dbf6b2 100644 (file)
--- a/ir/adt/raw_bitset.h
+++ b/ir/adt/raw_bitset.h
@@ -96,30 +96,6 @@ static inline unsigned *rbitset_obstack_alloc(struct obstack *obst,
        return res;
 }
 
-/**
- * Allocate an empty raw bitset including the size on an obstack.
- * The size of this bitset can be accessed by bitset[-1].
- *
- * @param obst  the obstack where the bitset is allocated on
- * @param size  number of bits in the bitset
- *
- * @return the new bitset
- */
-static inline unsigned *rbitset_w_size_obstack_alloc(struct obstack *obst,
-                                                     unsigned size)
-{
-       unsigned  size_bytes = BITSET_SIZE_BYTES(size);
-       unsigned *res        = obstack_alloc(obst, size_bytes + sizeof(unsigned));
-       *res = size;
-       ++res;
-       memset(res, 0, size_bytes);
-
-       return res;
-}
-
-/** Return the size of a bitset allocated with a *_w_size_* function */
-#define rbitset_size(set)      (set)[-1]
-
 /**
  * Duplicate a raw bitset on an obstack.
  *

diff --git a/ir/ana/irbackedge.c b/ir/ana/irbackedge.c
index c28cc9d..0af98d8 100644 (file)
--- a/ir/ana/irbackedge.c
+++ b/ir/ana/irbackedge.c
@@ -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(ir_node *n)
 {
        switch (get_irn_opcode(n)) {
        case iro_Block:
@@ -65,13 +65,13 @@ 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(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 bal = bitset_size(ba);  /* avoid macro expansion in assertion. */
                int inl = get_irn_arity(n);
                assert(bal == inl && "backedge array with faulty length");
        }
@@ -87,8 +87,8 @@ static unsigned *get_backarray(ir_node *n)
  */
 static int legal_backarray(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,7 +96,7 @@ static int legal_backarray(ir_node *n)
 
 void fix_backedges(struct obstack *obst, ir_node *n)
 {
-       unsigned *arr = mere_get_backarray(n);
+       bitset_t *arr = mere_get_backarray(n);
        ir_opcode opc;
        int arity;
 
@@ -104,7 +104,7 @@ void fix_backedges(struct obstack *obst, ir_node *n)
                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);
@@ -121,35 +121,34 @@ 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)
 {
-       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)
 {
-       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, unsigned size)
 {
-       return rbitset_w_size_obstack_alloc(obst, size);
+       return bitset_obstack_alloc(obst, size);
 }

diff --git a/ir/ana/irbackedge_t.h b/ir/ana/irbackedge_t.h
index bdcde44..3a45a23 100644 (file)
--- a/ir/ana/irbackedge_t.h
+++ b/ir/ana/irbackedge_t.h
@@ -33,7 +33,7 @@
  * @param obst   the obstack to allocate the array on
  * @param size   the size of the backedge array
  */
-unsigned *new_backedge_arr(struct obstack *obst, unsigned size);
+bitset_t *new_backedge_arr(struct obstack *obst, unsigned size);
 
 /**
  * Adapts backedges array to new size.

diff --git a/ir/ir/irtypes.h b/ir/ir/irtypes.h
index 6c94860..7b7caf1 100644 (file)
--- a/ir/ir/irtypes.h
+++ b/ir/ir/irtypes.h
@@ -40,6 +40,7 @@
 #include "irprog.h"
 #include "field_temperature.h"
 #include "irphase.h"
+#include "bitset.h"
 
 #include "pset.h"
 #include "set.h"
@@ -154,8 +155,8 @@ typedef struct {
        ir_node ** in_cg;           /**< array with predecessors in
                                     * interprocedural_view, if they differ
                                     * from intraprocedural predecessors */
-       unsigned *backedge;         /**< Raw Bitfield n set to true if pred n is backedge.*/
-       unsigned *cg_backedge;      /**< Raw Bitfield n set to true if pred n is interprocedural backedge. */
+       bitset_t *backedge;         /**< Bitfield n set to true if pred n is backedge.*/
+       bitset_t *cg_backedge;      /**< Bitfield n set to true if pred n is interprocedural backedge. */
        ir_extblk *extblk;          /**< The extended basic block this block belongs to. */
        ir_region *region;          /**< The immediate structural region this block belongs to. */
        ir_entity *entity;          /**< entitiy representing this block */
@@ -250,7 +251,7 @@ typedef struct {
 typedef struct {
        ir_node        *next;         /**< Points to the next Phi in the Phi list of a block. */
        union {
-               unsigned       *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
+               bitset_t      *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
                int            pos;           /**< For Phi0. Used to remember the value defined by
                                               this Phi node.  Needed when the Phi is completed
                                               to call get_r_internal_value() to find the