4 * @author Sebastian Hack
5 * @brief A bitset implementation.
8 #ifndef __FIRM_BITSET_H
9 #define __FIRM_BITSET_H
16 #include "firm_config.h"
17 #include "bitfiddle.h"
19 typedef unsigned int bitset_pos_t;
21 #include "bitset_std.h"
24 #if defined(__GNUC__) && defined(__i386__)
25 #include "bitset_ia32.h"
29 typedef struct _bitset_t {
31 bitset_pos_t highest_bit;
35 #define BS_UNIT_SIZE sizeof(bitset_unit_t)
36 #define BS_UNIT_SIZE_BITS (BS_UNIT_SIZE * 8)
37 #define BS_UNIT_MASK (BS_UNIT_SIZE_BITS - 1)
40 * Initialize a bitset.
41 * This functions should not be called.
43 * Note that this function needs three macros which must be provided by the
44 * bitfield implementor:
45 * - _bitset_overall_size(highest_bit) The overall size that must be
46 * allocated for the bitfield in bytes.
47 * - _bitset_units(highest_bit) The number of units that will be
48 * present in the bitfield for a given highest bit.
49 * - _bitset_data_ptr(data, highest_bit) This produces as pointer to the
50 * first unit in the allocated memory area. The main reason for this
51 * macro is, that some bitset implementors want control over memory
54 * @param area A pointer to memory reserved for the bitset.
55 * @param units The number of units that are allocated for the bitset.
56 * @return A pointer to the initialized bitset.
58 static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t highest_bit)
61 memset(area, 0, _bitset_overall_size(sizeof(bitset_t), highest_bit));
62 ptr->units = _bitset_units(highest_bit);
63 ptr->highest_bit = highest_bit;
64 ptr->data = _bitset_data_ptr(area, sizeof(bitset_t), highest_bit);
69 * Mask out all bits, which are only there, because the number
70 * of bits in the set didn't match a unit size boundary.
71 * @param bs The bitset.
72 * @return The masked bitset.
74 static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
76 bs->data[bs->units - 1] &= (bs->highest_bit & BS_UNIT_MASK) - 1;
81 * Get the capacity of the bitset in bits.
82 * @param bs The bitset.
83 * @return The capacity in bits of the bitset.
85 #define bitset_capacity(bs) ((bs)->units * BS_UNIT_SIZE_BITS)
88 * Get the highest bit which can be stored in the bitset.
89 * @param bs The bitset.
90 * @return The highest bit which can be set or cleared.
92 #define bistet_highest_bit(bs) ((bs)->highest_bit)
95 * Allocate a bitset on an obstack.
96 * @param obst The obstack.
97 * @param highest_bit The greatest bit that shall be stored in the set.
98 * @return A pointer to an empty initialized bitset.
100 #define bitset_obstack_alloc(obst,highest_bit) \
101 _bitset_prepare(obstack_alloc(obst, _bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
104 * Allocate a bitset via malloc.
105 * @param highest_bit The greatest bit that shall be stored in the set.
106 * @return A pointer to an empty initialized bitset.
108 #define bitset_malloc(highest_bit) \
109 _bitset_prepare(malloc(_bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
112 * Free a bitset allocated with bitset_malloc().
113 * @param bs The bitset.
115 #define bitset_free(bs) free(bs)
118 * Allocate a bitset on the stack via alloca.
119 * @param highest_bit The greatest bit that shall be stored in the set.
120 * @return A pointer to an empty initialized bitset.
122 #define bitset_alloca(highest_bit) \
123 _bitset_prepare(alloca(_bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
127 * Get the unit which contains a specific bit.
128 * This function is internal.
129 * @param bs The bitset.
130 * @param bit The bit.
131 * @return A pointer to the unit containing the bit.
133 static INLINE bitset_unit_t *_bitset_get_unit(const bitset_t *bs, bitset_pos_t bit)
135 /* assert(bit < bs->units * BS_UNIT_SIZE_BITS && "Bit too large"); */
136 assert(bit <= bs->highest_bit && "Bit to large");
137 return bs->data + bit / BS_UNIT_SIZE_BITS;
141 * Set a bit in the bitset.
142 * @param bs The bitset.
143 * @param bit The bit to set.
145 static INLINE void bitset_set(bitset_t *bs, bitset_pos_t bit)
147 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
148 _bitset_inside_set(unit, bit & BS_UNIT_MASK);
152 * Clear a bit in the bitset.
153 * @param bs The bitset.
154 * @param bit The bit to clear.
156 static INLINE void bitset_clear(bitset_t *bs, bitset_pos_t bit)
158 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
159 _bitset_inside_clear(unit, bit & BS_UNIT_MASK);
163 * Check, if a bit is set.
164 * @param bs The bitset.
165 * @param bit The bit to check for.
166 * @return 1, if the bit was set, 0 if not.
168 static INLINE int bitset_is_set(const bitset_t *bs, bitset_pos_t bit)
170 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
171 return _bitset_inside_is_set(unit, bit & BS_UNIT_MASK);
175 * Flip a bit in a bitset.
176 * @param bs The bitset.
177 * @param bit The bit to flip.
179 static INLINE void bitset_flip(bitset_t *bs, bitset_pos_t bit)
181 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
182 _bitset_inside_flip(unit, bit & BS_UNIT_MASK);
186 * Copy a bitset to another.
187 * @param tgt The target bitset.
188 * @param src The source bitset.
189 * @return The target bitset.
191 static INLINE bitset_t *bitset_copy(bitset_t *tgt, const bitset_t *src)
193 bitset_pos_t tu = tgt->units;
194 bitset_pos_t su = src->units;
195 bitset_pos_t min_units = tu < su ? tu : su;
196 memcpy(tgt->data, src->data, min_units * BS_UNIT_SIZE);
198 memset(tgt->data + min_units, 0, BS_UNIT_SIZE * (tu - min_units));
199 return _bitset_mask_highest(tgt);
203 * Find the smallest bit set in the bitset.
204 * @param bs The bitset.
205 * @return The smallest bit set in the bitset.
207 static INLINE bitset_pos_t bitset_min(const bitset_t *bs)
209 bitset_pos_t i, ofs = 0;
211 for(i = 0; i < bs->units; ++i) {
212 bitset_unit_t *unit = &bs->data[i];
213 bitset_pos_t pos = _bitset_inside_ntz(unit);
216 ofs += BS_UNIT_SIZE_BITS;
223 * Find the greatest bit set in the bitset.
224 * @param bs The bitset.
225 * @return The greatest bit set in the bitset.
227 static INLINE bitset_pos_t bitset_max(const bitset_t *bs)
229 bitset_pos_t i, max = 0, ofs = 0;
231 for(i = 0; i < bs->units; ++i) {
232 bitset_unit_t *unit = &bs->data[i];
233 bitset_pos_t pos = _bitset_inside_nlz(unit);
236 ofs += BS_UNIT_SIZE_BITS;
243 * Find the next set bit from a given bit.
244 * @note Note that if pos is set, pos is returned.
245 * @param bs The bitset.
246 * @param pos The bit from which to search for the next set bit.
247 * @return The next set bit from pos on, or -1, if no set bit was found
250 static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
251 bitset_pos_t pos, int set)
253 bitset_pos_t unit_number = pos / BS_UNIT_SIZE_BITS;
255 if(unit_number >= bs->units)
259 bitset_pos_t bit_in_unit = pos & BS_UNIT_MASK;
260 bitset_pos_t in_unit_mask = (1 << bit_in_unit) - 1;
263 * Mask out the bits smaller than pos in the current unit.
264 * We are only interested in bits set higher than pos.
266 bitset_unit_t curr_unit = bs->data[unit_number];
269 * Find the next bit set in the unit.
270 * Mind that this function returns 0, if the unit is -1 and
271 * counts the bits from 1 on.
273 bitset_pos_t next_in_this_unit =
274 _bitset_inside_ntz_value((set ? curr_unit : ~curr_unit) & ~in_unit_mask);
276 /* If there is a bit set in the current unit, exit. */
277 if(next_in_this_unit < BS_UNIT_SIZE_BITS)
278 return next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
280 /* Else search for set bits in the next units. */
283 for(i = unit_number + 1; i < bs->units; ++i) {
284 bitset_unit_t data = bs->data[i];
285 bitset_pos_t first_set =
286 _bitset_inside_ntz_value(set ? data : ~data);
288 if(first_set < BS_UNIT_SIZE_BITS)
289 return first_set + i * BS_UNIT_SIZE_BITS;
297 #define bitset_next_clear(bs,pos) _bitset_next((bs), (pos), 0)
298 #define bitset_next_set(bs,pos) _bitset_next((bs), (pos), 1)
301 * Convenience macro for bitset iteration.
302 * @param bitset The bitset.
303 * @param elm A unsigned long variable.
305 #define bitset_foreach(bitset,elm) \
306 for(elm = bitset_next_set(bitset,0); elm != -1; elm = bitset_next_set(bitset,elm+1))
309 #define bitset_foreach_clear(bitset,elm) \
310 for(elm = bitset_next_clear(bitset,0); elm != -1; elm = bitset_next_clear(bitset,elm+1))
313 * Count the bits set.
314 * This can also be seen as the cardinality of the set.
315 * @param bs The bitset.
316 * @return The number of bits set in the bitset.
318 static INLINE bitset_pos_t bitset_popcnt(const bitset_t *bs)
320 bitset_pos_t i, pop = 0;
323 for(i = 0, unit = bs->data; i < bs->units; ++i, ++unit)
324 pop += _bitset_inside_pop(unit);
331 * This sets all bits to zero.
332 * @param bs The bitset.
334 static INLINE bitset_t *bitset_clear_all(bitset_t *bs)
336 memset(bs->data, 0, BS_UNIT_SIZE * bs->units);
342 * This sets all bits to one.
343 * @param bs The bitset.
345 static INLINE bitset_t *bitset_set_all(bitset_t *bs)
347 memset(bs->data, -1, BS_UNIT_SIZE * bs->units);
352 * Check, if one bitset is contained by another.
353 * That is, each bit set in lhs is also set in rhs.
354 * @param lhs A bitset.
355 * @param rhs Another bitset.
356 * @return 1, if all bits in lhs are also set in rhs, 0 otherwise.
358 static INLINE int bitset_contains(const bitset_t *lhs, const bitset_t *rhs)
360 bitset_pos_t n = lhs->units < rhs->units ? lhs->units : rhs->units;
363 for(i = 0; i < n; ++i) {
364 bitset_unit_t lu = lhs->data[i];
365 bitset_unit_t ru = rhs->data[i];
372 * If the left hand sinde is a larger bitset than rhs,
373 * we have to check, that all extra bits in lhs are 0
376 for(i = n; i < lhs->units; ++i) {
377 if(lhs->data[i] != 0)
386 * Print a bitset to a stream.
387 * The bitset is printed as a comma seperated list of bits set.
388 * @param file The stream.
389 * @param bs The bitset.
391 static INLINE void bitset_fprint(FILE *file, const bitset_t *bs)
393 const char *prefix = "";
397 for(i = bitset_next_set(bs, 0); i != -1; i = bitset_next_set(bs, i + 1)) {
398 fprintf(file, "%s%u", prefix, i);
404 static INLINE void bitset_debug_fprint(FILE *file, const bitset_t *bs)
408 fprintf(file, "%u:", bs->units);
409 for(i = 0; i < bs->units; ++i)
410 fprintf(file, " " BITSET_UNIT_FMT, bs->data[i]);
414 * Here, the binary operations follow.
415 * And, Or, And Not, Xor are available.
417 #define BINARY_OP(op) \
418 static INLINE bitset_t *bitset_ ## op(bitset_t *tgt, const bitset_t *src) \
421 bitset_pos_t n = tgt->units > src->units ? src->units : tgt->units; \
422 for(i = 0; i < n; i += _BITSET_BINOP_UNITS_INC) \
423 _bitset_inside_binop_ ## op(&tgt->data[i], &src->data[i]); \
425 _bitset_clear_rest(&tgt->data[i], tgt->units - i); \
426 return _bitset_mask_highest(tgt); \
430 * Define the clear rest macro for the and, since it is the only case,
431 * were non existed (treated as 0) units in the src must be handled.
432 * For all other operations holds: x Op 0 = x for Op in { Andnot, Or, Xor }
434 * For and, each bitset implementer has to provide the macro
435 * _bitset_clear_units(data, n), which clears n units from the pointer
438 #define _bitset_clear_rest(data,n) _bitset_inside_clear_units(data, n)
440 #undef _bitset_clear_rest
441 #define _bitset_clear_rest(data,n)