projects
/
libfirm
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
Use Lea instead of Add in the ia32 transformer.
[libfirm]
/
ir
/
adt
/
raw_bitset.h
diff --git
a/ir/adt/raw_bitset.h
b/ir/adt/raw_bitset.h
index
77630f0
..
e5056c4
100644
(file)
--- a/
ir/adt/raw_bitset.h
+++ b/
ir/adt/raw_bitset.h
@@
-56,13
+56,9
@@
*
* @return the new bitset
*/
*
* @return the new bitset
*/
-static inline unsigned *rbitset_malloc(
unsigned
size)
+static inline unsigned *rbitset_malloc(
size_t
size)
{
{
- unsigned size_bytes = BITSET_SIZE_BYTES(size);
- unsigned *res = xmalloc(size_bytes);
- memset(res, 0, size_bytes);
-
- return res;
+ return XMALLOCNZ(unsigned, BITSET_SIZE_ELEMS(size));
}
/**
}
/**
@@
-73,8
+69,8
@@
static inline unsigned *rbitset_malloc(unsigned size)
*/
#define rbitset_alloca(res, size) \
do { \
*/
#define rbitset_alloca(res, size) \
do { \
-
unsigned
size_bytes = BITSET_SIZE_BYTES(size); \
- res = alloca(size_bytes); \
+
size_t
size_bytes = BITSET_SIZE_BYTES(size); \
+ res =
(unsigned*)
alloca(size_bytes); \
memset(res, 0, size_bytes); \
} while(0)
memset(res, 0, size_bytes); \
} while(0)
@@
-87,13
+83,9
@@
do { \
* @return the new bitset
*/
static inline unsigned *rbitset_obstack_alloc(struct obstack *obst,
* @return the new bitset
*/
static inline unsigned *rbitset_obstack_alloc(struct obstack *obst,
-
unsigned
size)
+
size_t
size)
{
{
- unsigned size_bytes = BITSET_SIZE_BYTES(size);
- unsigned *res = obstack_alloc(obst, size_bytes);
- memset(res, 0, size_bytes);
-
- return res;
+ return OALLOCNZ(obst, unsigned, BITSET_SIZE_ELEMS(size));
}
/**
}
/**
@@
-106,10
+98,10
@@
static inline unsigned *rbitset_obstack_alloc(struct obstack *obst,
* @return the new bitset
*/
static inline unsigned *rbitset_duplicate_obstack_alloc(struct obstack *obst,
* @return the new bitset
*/
static inline unsigned *rbitset_duplicate_obstack_alloc(struct obstack *obst,
- const unsigned *old_bitset,
unsigned
size)
+ const unsigned *old_bitset,
size_t
size)
{
{
-
unsigned
size_bytes = BITSET_SIZE_BYTES(size);
- unsigned *res =
obstack_alloc(obst, size_bytes
);
+
size_t
size_bytes = BITSET_SIZE_BYTES(size);
+ unsigned *res =
OALLOCN(obst, unsigned, BITSET_SIZE_ELEMS(size)
);
memcpy(res, old_bitset, size_bytes);
return res;
memcpy(res, old_bitset, size_bytes);
return res;
@@
-118,10
+110,10
@@
static inline unsigned *rbitset_duplicate_obstack_alloc(struct obstack *obst,
/**
* Check if a bitset is empty, ie all bits cleared.
*/
/**
* Check if a bitset is empty, ie all bits cleared.
*/
-static inline bool rbitset_is_empty(const unsigned *bitset,
unsigned
size)
+static inline bool rbitset_is_empty(const unsigned *bitset,
size_t
size)
{
{
-
unsigned
i;
-
unsigned
n = BITSET_SIZE_ELEMS(size);
+
size_t
i;
+
size_t
n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
if (bitset[i] != 0) {
for (i = 0; i < n; ++i) {
if (bitset[i] != 0) {
@@
-137,7
+129,7
@@
static inline bool rbitset_is_empty(const unsigned *bitset, unsigned size)
* @param bitset the bitset
* @param pos the position of the bit to be set
*/
* @param bitset the bitset
* @param pos the position of the bit to be set
*/
-static inline void rbitset_set(unsigned *bitset,
unsigned
pos)
+static inline void rbitset_set(unsigned *bitset,
size_t
pos)
{
BITSET_ELEM(bitset,pos) |= 1 << (pos % BITS_PER_ELEM);
}
{
BITSET_ELEM(bitset,pos) |= 1 << (pos % BITS_PER_ELEM);
}
@@
-148,14
+140,14
@@
static inline void rbitset_set(unsigned *bitset, unsigned pos)
* @param bitset the bitset
* @param pos position of the bit to be flipped
*/
* @param bitset the bitset
* @param pos position of the bit to be flipped
*/
-static inline void rbitset_flip(unsigned *bitset,
unsigned
pos)
+static inline void rbitset_flip(unsigned *bitset,
size_t
pos)
{
BITSET_ELEM(bitset, pos) ^= 1 << (pos % BITS_PER_ELEM);
}
{
BITSET_ELEM(bitset, pos) ^= 1 << (pos % BITS_PER_ELEM);
}
-static inline unsigned rbitset_last_mask_(
unsigned
size)
+static inline unsigned rbitset_last_mask_(
size_t
size)
{
{
-
unsigned
p;
+
size_t
p;
if (size == 0)
return 0;
p = size % BITS_PER_ELEM;
if (size == 0)
return 0;
p = size % BITS_PER_ELEM;
@@
-168,10
+160,10
@@
static inline unsigned rbitset_last_mask_(unsigned size)
* @param bitset the bitset
* @param size number of bits in the bitset
*/
* @param bitset the bitset
* @param size number of bits in the bitset
*/
-static inline void rbitset_set_all(unsigned *bitset,
unsigned
size)
+static inline void rbitset_set_all(unsigned *bitset,
size_t
size)
{
{
-
unsigned
i;
-
unsigned
n = BITSET_SIZE_ELEMS(size);
+
size_t
i;
+
size_t
n = BITSET_SIZE_ELEMS(size);
if (n == 0)
return;
if (n == 0)
return;
@@
-188,7
+180,7
@@
static inline void rbitset_set_all(unsigned *bitset, unsigned size)
* @param bitset the bitset
* @param pos the position of the bit to be clear
*/
* @param bitset the bitset
* @param pos the position of the bit to be clear
*/
-static inline void rbitset_clear(unsigned *bitset,
unsigned
pos)
+static inline void rbitset_clear(unsigned *bitset,
size_t
pos)
{
BITSET_ELEM(bitset, pos) &= ~(1 << (pos % BITS_PER_ELEM));
}
{
BITSET_ELEM(bitset, pos) &= ~(1 << (pos % BITS_PER_ELEM));
}
@@
-199,9
+191,9
@@
static inline void rbitset_clear(unsigned *bitset, unsigned pos)
* @param bitset the bitset
* @param size number of bits in the bitset
*/
* @param bitset the bitset
* @param size number of bits in the bitset
*/
-static inline void rbitset_clear_all(unsigned *bitset,
unsigned
size)
+static inline void rbitset_clear_all(unsigned *bitset,
size_t
size)
{
{
-
unsigned
size_bytes = BITSET_SIZE_BYTES(size);
+
size_t
size_bytes = BITSET_SIZE_BYTES(size);
memset(bitset, 0, size_bytes);
}
memset(bitset, 0, size_bytes);
}
@@
-211,10
+203,10
@@
static inline void rbitset_clear_all(unsigned *bitset, unsigned size)
* @param bitset the bitset
* @param size number of bits in the bitset
*/
* @param bitset the bitset
* @param size number of bits in the bitset
*/
-static inline void rbitset_flip_all(unsigned *bitset,
unsigned
size)
+static inline void rbitset_flip_all(unsigned *bitset,
size_t
size)
{
{
-
unsigned
pos;
-
unsigned
n = BITSET_SIZE_ELEMS(size);
+
size_t
pos;
+
size_t
n = BITSET_SIZE_ELEMS(size);
if (n == 0)
return;
if (n == 0)
return;
@@
-231,7
+223,7
@@
static inline void rbitset_flip_all(unsigned *bitset, unsigned size)
* @param bitset the bitset
* @param pos the position of the bit to check
*/
* @param bitset the bitset
* @param pos the position of the bit to check
*/
-static inline bool rbitset_is_set(const unsigned *bitset,
unsigned
pos)
+static inline bool rbitset_is_set(const unsigned *bitset,
size_t
pos)
{
return (BITSET_ELEM(bitset, pos) & (1 << (pos % BITS_PER_ELEM))) != 0;
}
{
return (BITSET_ELEM(bitset, pos) & (1 << (pos % BITS_PER_ELEM))) != 0;
}
@@
-242,11
+234,10
@@
static inline bool rbitset_is_set(const unsigned *bitset, unsigned pos)
* @param bitset the bitset
* @param size size of the bitset in bits
*/
* @param bitset the bitset
* @param size size of the bitset in bits
*/
-static inline
unsigned rbitset_popcount(const unsigned *bitset, unsigned
size)
+static inline
size_t rbitset_popcount(const unsigned *bitset, size_t
size)
{
{
- unsigned i;
- unsigned n = BITSET_SIZE_ELEMS(size);
- unsigned res = 0;
+ size_t i, n = BITSET_SIZE_ELEMS(size);
+ size_t res = 0;
for (i = 0; i < n; ++i) {
res += popcount(bitset[i]);
for (i = 0; i < n; ++i) {
res += popcount(bitset[i]);
@@
-268,12
+259,12
@@
static inline unsigned rbitset_popcount(const unsigned *bitset, unsigned size)
* @note Does NOT check the size of the bitset, so ensure that a bit
* will be found or use a sentinel bit!
*/
* @note Does NOT check the size of the bitset, so ensure that a bit
* will be found or use a sentinel bit!
*/
-static inline
unsigned rbitset_next(const unsigned *bitset, unsigned
pos,
-
bool set)
+static inline
size_t rbitset_next(const unsigned *bitset, size_t
pos,
+ bool set)
{
unsigned p;
{
unsigned p;
-
unsigned
elem_pos = pos / BITS_PER_ELEM;
-
unsigned
bit_pos = pos % BITS_PER_ELEM;
+
size_t
elem_pos = pos / BITS_PER_ELEM;
+
size_t
bit_pos = pos % BITS_PER_ELEM;
unsigned elem = bitset[elem_pos];
unsigned mask = set ? 0 : ~0u;
unsigned elem = bitset[elem_pos];
unsigned mask = set ? 0 : ~0u;
@@
-314,24
+305,24
@@
static inline unsigned rbitset_next(const unsigned *bitset, unsigned pos,
* @param set if 0 search for unset bit, else for set bit
*
* @return the first position where a matched bit was found.
* @param set if 0 search for unset bit, else for set bit
*
* @return the first position where a matched bit was found.
- * (
unsigned
)-1 if no bit was found.
+ * (
size_t
)-1 if no bit was found.
*/
*/
-static inline
unsigned rbitset_next_max(const unsigned *bitset, unsigned
pos,
-
unsigned
last, bool set)
+static inline
size_t rbitset_next_max(const unsigned *bitset, size_t
pos,
+
size_t
last, bool set)
{
{
-
unsigned
p;
-
unsigned
elem_pos = pos / BITS_PER_ELEM;
-
unsigned
bit_pos = pos % BITS_PER_ELEM;
+
size_t
p;
+
size_t
elem_pos = pos / BITS_PER_ELEM;
+
size_t
bit_pos = pos % BITS_PER_ELEM;
unsigned elem = bitset[elem_pos];
unsigned elem = bitset[elem_pos];
- unsigned mask = set ? 0 : ~0u;
-
unsigned res = (unsigned
)-1;
+ unsigned mask = set ? 0
u
: ~0u;
+
size_t res = (size_t
)-1;
/*
* Mask out the bits smaller than pos in the current unit.
* We are only interested in bits set higher than pos.
*/
/*
* Mask out the bits smaller than pos in the current unit.
* We are only interested in bits set higher than pos.
*/
- unsigned in_elem_mask = (1 << bit_pos) - 1;
+ unsigned in_elem_mask = (1
u
<< bit_pos) - 1;
assert(pos < last);
assert(pos < last);
@@
-342,7
+333,7
@@
static inline unsigned rbitset_next_max(const unsigned *bitset, unsigned pos,
if (p < BITS_PER_ELEM) {
res = elem_pos * BITS_PER_ELEM + p;
} else {
if (p < BITS_PER_ELEM) {
res = elem_pos * BITS_PER_ELEM + p;
} else {
-
unsigned
n = BITSET_SIZE_ELEMS(last);
+
size_t
n = BITSET_SIZE_ELEMS(last);
/* Else search for set bits in the next units. */
for (elem_pos++; elem_pos < n; elem_pos++) {
elem = bitset[elem_pos] ^ mask;
/* Else search for set bits in the next units. */
for (elem_pos++; elem_pos < n; elem_pos++) {
elem = bitset[elem_pos] ^ mask;
@@
-355,7
+346,7
@@
static inline unsigned rbitset_next_max(const unsigned *bitset, unsigned pos,
}
}
if (res >= last)
}
}
if (res >= last)
- res = (
unsigned
)-1;
+ res = (
size_t
)-1;
return res;
}
return res;
}
@@
-367,9
+358,9
@@
static inline unsigned rbitset_next_max(const unsigned *bitset, unsigned pos,
* @param src the second bitset
* @param size size of both bitsets in bits
*/
* @param src the second bitset
* @param size size of both bitsets in bits
*/
-static inline void rbitset_and(unsigned *dst, const unsigned *src,
unsigned
size)
+static inline void rbitset_and(unsigned *dst, const unsigned *src,
size_t
size)
{
{
-
unsigned
i, n = BITSET_SIZE_ELEMS(size);
+
size_t
i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
dst[i] &= src[i];
for (i = 0; i < n; ++i) {
dst[i] &= src[i];
@@
-383,9
+374,9
@@
static inline void rbitset_and(unsigned *dst, const unsigned *src, unsigned size
* @param src the second bitset
* @param size size of both bitsets in bits
*/
* @param src the second bitset
* @param size size of both bitsets in bits
*/
-static inline void rbitset_or(unsigned *dst, const unsigned *src,
unsigned
size)
+static inline void rbitset_or(unsigned *dst, const unsigned *src,
size_t
size)
{
{
-
unsigned
i, n = BITSET_SIZE_ELEMS(size);
+
size_t
i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
dst[i] |= src[i];
for (i = 0; i < n; ++i) {
dst[i] |= src[i];
@@
-399,9
+390,9
@@
static inline void rbitset_or(unsigned *dst, const unsigned *src, unsigned size)
* @param src the second bitset
* @param size size of both bitsets in bits
*/
* @param src the second bitset
* @param size size of both bitsets in bits
*/
-static inline void rbitset_andnot(unsigned *dst, const unsigned *src,
unsigned
size)
+static inline void rbitset_andnot(unsigned *dst, const unsigned *src,
size_t
size)
{
{
-
unsigned
i, n = BITSET_SIZE_ELEMS(size);
+
size_t
i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
dst[i] &= ~src[i];
for (i = 0; i < n; ++i) {
dst[i] &= ~src[i];
@@
-415,9
+406,9
@@
static inline void rbitset_andnot(unsigned *dst, const unsigned *src, unsigned s
* @param src the second bitset
* @param size size of both bitsets in bits
*/
* @param src the second bitset
* @param size size of both bitsets in bits
*/
-static inline void rbitset_xor(unsigned *dst, const unsigned *src,
unsigned
size)
+static inline void rbitset_xor(unsigned *dst, const unsigned *src,
size_t
size)
{
{
-
unsigned
i, n = BITSET_SIZE_ELEMS(size);
+
size_t
i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
dst[i] ^= src[i];
for (i = 0; i < n; ++i) {
dst[i] ^= src[i];
@@
-431,8
+422,8
@@
static inline void rbitset_xor(unsigned *dst, const unsigned *src, unsigned size
* @param to last bit (the first bit which is not set anymore)
* @param val wether to set to 1 or 0
*/
* @param to last bit (the first bit which is not set anymore)
* @param val wether to set to 1 or 0
*/
-static inline void rbitset_set_range(unsigned *bitset,
unsigned
from,
-
unsigned
to, bool val)
+static inline void rbitset_set_range(unsigned *bitset,
size_t
from,
+
size_t
to, bool val)
{
/*
* A small example (for cleaning bits in the same unit).
{
/*
* A small example (for cleaning bits in the same unit).
@@
-446,13
+437,13
@@
static inline void rbitset_set_range(unsigned *bitset, unsigned from,
* 1 2 3
*/
* 1 2 3
*/
-
unsigned from_bit
= from % BITS_PER_ELEM;
-
unsigned from_pos
= from / BITS_PER_ELEM;
+
size_t from_bit
= from % BITS_PER_ELEM;
+
size_t from_pos
= from / BITS_PER_ELEM;
unsigned from_unit_mask = ~((1 << from_bit) - 1);
unsigned from_unit_mask = ~((1 << from_bit) - 1);
-
unsigned
to_bit = to % BITS_PER_ELEM;
-
unsigned
to_pos = to / BITS_PER_ELEM;
- unsigned to_unit_mask
= (1 << to_bit) - 1;
+
size_t
to_bit = to % BITS_PER_ELEM;
+
size_t
to_pos = to / BITS_PER_ELEM;
+ unsigned to_unit_mask = (1 << to_bit) - 1;
assert(from < to);
assert(from < to);
@@
-461,7
+452,7
@@
static inline void rbitset_set_range(unsigned *bitset, unsigned from,
if (from_pos == to_pos) {
BITSET_ELEM(bitset, from_pos) |= from_unit_mask & to_unit_mask;
} else {
if (from_pos == to_pos) {
BITSET_ELEM(bitset, from_pos) |= from_unit_mask & to_unit_mask;
} else {
-
unsigned
i;
+
size_t
i;
BITSET_ELEM(bitset, from_pos) |= from_unit_mask;
BITSET_ELEM(bitset, to_pos) |= to_unit_mask;
for (i = from_pos + 1; i < to_pos; ++i)
BITSET_ELEM(bitset, from_pos) |= from_unit_mask;
BITSET_ELEM(bitset, to_pos) |= to_unit_mask;
for (i = from_pos + 1; i < to_pos; ++i)
@@
-472,7
+463,7
@@
static inline void rbitset_set_range(unsigned *bitset, unsigned from,
if (from_pos == to_pos) {
BITSET_ELEM(bitset, from_pos) &= ~(from_unit_mask & to_unit_mask);
} else {
if (from_pos == to_pos) {
BITSET_ELEM(bitset, from_pos) &= ~(from_unit_mask & to_unit_mask);
} else {
-
unsigned
i;
+
size_t
i;
BITSET_ELEM(bitset, from_pos) &= ~from_unit_mask;
BITSET_ELEM(bitset, to_pos) &= ~to_unit_mask;
for (i = from_pos + 1; i < to_pos; ++i)
BITSET_ELEM(bitset, from_pos) &= ~from_unit_mask;
BITSET_ELEM(bitset, to_pos) &= ~to_unit_mask;
for (i = from_pos + 1; i < to_pos; ++i)
@@
-489,9
+480,9
@@
static inline void rbitset_set_range(unsigned *bitset, unsigned from,
* @param size size of both bitsets in bits
*/
static inline bool rbitsets_equal(const unsigned *bitset1,
* @param size size of both bitsets in bits
*/
static inline bool rbitsets_equal(const unsigned *bitset1,
- const unsigned *bitset2,
unsigned
size)
+ const unsigned *bitset2,
size_t
size)
{
{
-
unsigned
size_bytes = BITSET_SIZE_BYTES(size);
+
size_t
size_bytes = BITSET_SIZE_BYTES(size);
return memcmp(bitset1, bitset2, size_bytes) == 0;
}
return memcmp(bitset1, bitset2, size_bytes) == 0;
}
@@
-503,10
+494,9
@@
static inline bool rbitsets_equal(const unsigned *bitset1,
* @param size size of both bitsets in bits
*/
static inline bool rbitsets_have_common(const unsigned *bitset1,
* @param size size of both bitsets in bits
*/
static inline bool rbitsets_have_common(const unsigned *bitset1,
- const unsigned *bitset2,
unsigned
size)
+ const unsigned *bitset2,
size_t
size)
{
{
- unsigned i;
- unsigned n = BITSET_SIZE_ELEMS(size);
+ size_t i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
if ((bitset1[i] & bitset2[i]) != 0)
for (i = 0; i < n; ++i) {
if ((bitset1[i] & bitset2[i]) != 0)
@@
-523,10
+513,9
@@
static inline bool rbitsets_have_common(const unsigned *bitset1,
* @param size size of both bitsets in bits
*/
static inline bool rbitset_contains(const unsigned *bitset1,
* @param size size of both bitsets in bits
*/
static inline bool rbitset_contains(const unsigned *bitset1,
- const unsigned *bitset2,
unsigned
size)
+ const unsigned *bitset2,
size_t
size)
{
{
- unsigned i;
- unsigned n = BITSET_SIZE_ELEMS(size);
+ size_t i, n = BITSET_SIZE_ELEMS(size);
for (i = 0; i < n; ++i) {
if ((bitset1[i] & bitset2[i]) != bitset1[i])
for (i = 0; i < n; ++i) {
if ((bitset1[i] & bitset2[i]) != bitset1[i])
@@
-540,10
+529,9
@@
static inline bool rbitset_contains(const unsigned *bitset1,
* @param bitset the bitset.
* @return size size of the bitset in bits
*/
* @param bitset the bitset.
* @return size size of the bitset in bits
*/
-static inline void rbitset_minus1(unsigned *bitset,
unsigned
size)
+static inline void rbitset_minus1(unsigned *bitset,
size_t
size)
{
{
- unsigned i;
- unsigned n = BITSET_SIZE_ELEMS(size);
+ size_t i, n = BITSET_SIZE_ELEMS(size);
unsigned last_mask = rbitset_last_mask_(size);
for (i = 0; i < n; ++i) {
unsigned last_mask = rbitset_last_mask_(size);
for (i = 0; i < n; ++i) {
@@
-565,15
+553,15
@@
static inline void rbitset_minus1(unsigned *bitset, unsigned size)
* @param size size of both bitsets in bits
*/
static inline void rbitset_copy(unsigned *dst, const unsigned *src,
* @param size size of both bitsets in bits
*/
static inline void rbitset_copy(unsigned *dst, const unsigned *src,
-
unsigned
size)
+
size_t
size)
{
memcpy(dst, src, BITSET_SIZE_BYTES(size));
}
static inline void rbitset_copy_into(unsigned *dst, const unsigned *src,
{
memcpy(dst, src, BITSET_SIZE_BYTES(size));
}
static inline void rbitset_copy_into(unsigned *dst, const unsigned *src,
-
unsigned
size)
+
size_t
size)
{
{
-
unsigned n
= BITSET_SIZE_ELEMS(size);
+
size_t n
= BITSET_SIZE_ELEMS(size);
unsigned last_mask = rbitset_last_mask_(size);
memcpy(dst, src, (n-1) * (BITS_PER_ELEM/8));
unsigned last_mask = rbitset_last_mask_(size);
memcpy(dst, src, (n-1) * (BITS_PER_ELEM/8));