added missing include
[libfirm] / ir / adt / bitset.h
index 3635631..9ae1637 100644 (file)
 #include "firm_config.h"
 #include "bitfiddle.h"
 
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+
 typedef unsigned int bitset_pos_t;
 
 #include "bitset_std.h"
@@ -52,7 +58,7 @@ typedef struct _bitset_t {
  *   alignment.
  *
  * @param area A pointer to memory reserved for the bitset.
- * @param units The number of units that are allocated for the bitset.
+ * @param size The size of the bitset in bits.
  * @return A pointer to the initialized bitset.
  */
 static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
@@ -60,7 +66,7 @@ static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
        bitset_t *ptr = area;
        memset(area, 0, _bitset_overall_size(sizeof(bitset_t), size));
        ptr->units = _bitset_units(size);
-  ptr->size = size;
+       ptr->size = size;
        ptr->data = _bitset_data_ptr(area, sizeof(bitset_t), size);
        return ptr;
 }
@@ -73,8 +79,10 @@ static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
  */
 static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
 {
-  bs->data[bs->units - 1] &= (bs->size & BS_UNIT_MASK) - 1;
-  return bs;
+       bitset_pos_t rest = bs->size & BS_UNIT_MASK;
+       if (rest)
+               bs->data[bs->units - 1] &= (1 << rest) - 1;
+       return bs;
 }
 
 /**
@@ -85,11 +93,12 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
 #define bitset_capacity(bs) ((bs)->units * BS_UNIT_SIZE_BITS)
 
 /**
- * Get the highest bit which can be stored in the bitset.
+ * Get the size of the bitset in bits.
+ * @note Note the difference between capacity and size.
  * @param bs The bitset.
- * @return The highest bit which can be set or cleared.
+ * @return The highest bit which can be set or cleared plus 1.
  */
-#define bistet_size(bs)  ((bs)->size)
+#define bitset_size(bs)  ((bs)->size)
 
 /**
  * Allocate a bitset on an obstack.
@@ -106,7 +115,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
  * @return A pointer to an empty initialized bitset.
  */
 #define bitset_malloc(size) \
-       _bitset_prepare(malloc(_bitset_overall_size(sizeof(bitset_t), size)), size)
+       _bitset_prepare(xmalloc(_bitset_overall_size(sizeof(bitset_t), size)), size)
 
 /**
  * Free a bitset allocated with bitset_malloc().
@@ -182,6 +191,18 @@ static INLINE void bitset_flip(bitset_t *bs, bitset_pos_t bit)
        _bitset_inside_flip(unit, bit & BS_UNIT_MASK);
 }
 
+/**
+ * Flip the whole bitset.
+ * @param bs The bitset.
+ */
+static INLINE void bitset_flip_all(bitset_t *bs)
+{
+       bitset_pos_t i;
+       for(i = 0; i < bs->units; i++)
+               _bitset_inside_flip_unit(&bs->data[i]);
+       _bitset_mask_highest(bs);
+}
+
 /**
  * Copy a bitset to another.
  * @param tgt The target bitset.
@@ -251,8 +272,9 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                bitset_pos_t pos, int set)
 {
        bitset_pos_t unit_number = pos / BS_UNIT_SIZE_BITS;
+       bitset_pos_t res;
 
-       if(unit_number >= bs->units)
+       if(pos >= bs->size)
                return -1;
 
        {
@@ -274,8 +296,10 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                        _bitset_inside_ntz_value((set ? curr_unit : ~curr_unit) & ~in_unit_mask);
 
                /* If there is a bit set in the current unit, exit. */
-               if(next_in_this_unit < BS_UNIT_SIZE_BITS)
-                       return next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
+               if (next_in_this_unit < BS_UNIT_SIZE_BITS) {
+                       res = next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
+                       return res < bs->size ? res : -1;
+               }
 
                /* Else search for set bits in the next units. */
                else {
@@ -285,8 +309,10 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                                bitset_pos_t first_set =
                                        _bitset_inside_ntz_value(set ? data : ~data);
 
-                               if(first_set < BS_UNIT_SIZE_BITS)
-                                       return first_set + i * BS_UNIT_SIZE_BITS;
+                               if (first_set < BS_UNIT_SIZE_BITS) {
+                                       res = first_set + i * BS_UNIT_SIZE_BITS;
+                                       return res < bs->size ? res : -1;
+                               }
                        }
                }
        }
@@ -344,8 +370,8 @@ static INLINE bitset_t *bitset_clear_all(bitset_t *bs)
  */
 static INLINE bitset_t *bitset_set_all(bitset_t *bs)
 {
-       memset(bs->data, -1, BS_UNIT_SIZE * bs->units);
-  return bs;
+       memset(bs->data, -1, bs->units * BS_UNIT_SIZE);
+  return _bitset_mask_highest(bs);
 }
 
 /**
@@ -382,6 +408,29 @@ static INLINE int bitset_contains(const bitset_t *lhs, const bitset_t *rhs)
        return 1;
 }
 
+/**
+ * Treat the bitset as a number and subtract 1.
+ * @param bs The bitset.
+ * @return The same bitset.
+ */
+static INLINE void bitset_minus1(bitset_t *bs)
+{
+#define _SH (sizeof(bitset_unit_t) * 8 - 1)
+
+  bitset_pos_t i;
+
+  for(i = 0; i < bs->units; ++i) {
+    bitset_unit_t unit = bs->data[i];
+    bitset_unit_t um1  = unit - 1;
+
+    bs->data[i] = um1;
+
+    if(((unit >> _SH) ^ (um1 >> _SH)) == 0)
+      break;
+  }
+#undef _SH
+}
+
 /**
  * Print a bitset to a stream.
  * The bitset is printed as a comma seperated list of bits set.