X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fadt%2Fbitset.h;h=9ae16372b73ff483b755c33563e7b8fc9254636a;hb=d2dc2564b47d9c113d7e6e598574e9733627fcca;hp=18ae3b4400078b9bb6d58e459b3592b19d3be3db;hpb=70613faf23e4d8e157a68b781ccdda28ea7a3937;p=libfirm

diff --git a/ir/adt/bitset.h b/ir/adt/bitset.h
index 18ae3b440..9ae16372b 100644
--- a/ir/adt/bitset.h
+++ b/ir/adt/bitset.h
@@ -16,6 +16,12 @@
 #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"
@@ -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;
 }
 
 /**
@@ -90,7 +98,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
  * @param bs The bitset.
  * @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.
@@ -107,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().
@@ -183,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.
@@ -252,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;
 
 	{
@@ -275,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 {
@@ -286,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;
+				}
 			}
 		}
 	}
@@ -345,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);
 }
 
 /**
@@ -390,9 +415,10 @@ static INLINE int bitset_contains(const bitset_t *lhs, const bitset_t *rhs)
  */
 static INLINE void bitset_minus1(bitset_t *bs)
 {
-	int i;
 #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;