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 #include "bitset_std.h"
22 #if defined(__GNUC__) && defined(__i386__)
23 #include "bitset_ia32.h"
27 typedef struct _bitset_t {
32 #define BS_UNIT_SIZE sizeof(unsigned long)
33 #define BS_UNIT_SIZE_BITS (BS_UNIT_SIZE * 8)
34 #define BS_UNIT_MASK (BS_UNIT_SIZE_BITS - 1)
37 * Initialize a bitset.
38 * This functions should not be called.
40 * Note that this function needs three macros which must be provided by the
41 * bitfield implementor:
42 * - _bitset_overall_size(highest_bit) The overall size that must be
43 * allocated for the bitfield in bytes.
44 * - _bitset_units(highest_bit) The number of units that will be
45 * present in the bitfield for a given highest bit.
46 * - _bitset_data_ptr(data, highest_bit) This produces as pointer to the
47 * first unit in the allocated memory area. The main reason for this
48 * macro is, that some bitset implementors want control over memory
51 * @param area A pointer to memory reserved for the bitset.
52 * @param units The number of units that are allocated for the bitset.
53 * @return A pointer to the initialized bitset.
55 static INLINE bitset_t *_bitset_prepare(void *area, unsigned long highest_bit)
58 memset(area, 0, _bitset_overall_size(sizeof(bitset_t), highest_bit));
59 ptr->units = _bitset_units(highest_bit);
60 ptr->data = _bitset_data_ptr(area, sizeof(bitset_t), highest_bit);
65 * Get the capacity of the bitset in bits.
66 * @param bs The bitset.
67 * @return The capacity in bits of the bitset.
69 #define bitset_capacity(bs) ((bs)->units * BS_UNIT_SIZE_BITS)
72 * Allocate a bitset on an obstack.
73 * @param obst The obstack.
74 * @param highest_bit The greatest bit that shall be stored in the set.
75 * @return A pointer to an empty initialized bitset.
77 #define bitset_obstack_alloc(obst,highest_bit) \
78 _bitset_prepare(obstack_alloc(obst, _bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
81 * Allocate a bitset via malloc.
82 * @param highest_bit The greatest bit that shall be stored in the set.
83 * @return A pointer to an empty initialized bitset.
85 #define bitset_malloc(highest_bit) \
86 _bitset_prepare(malloc(_bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
89 * Free a bitset allocated with bitset_malloc().
90 * @param bs The bitset.
92 #define bitset_free(bs) free(bs)
95 * Allocate a bitset on the stack via alloca.
96 * @param highest_bit The greatest bit that shall be stored in the set.
97 * @return A pointer to an empty initialized bitset.
99 #define bitset_alloca(highest_bit) \
100 _bitset_prepare(alloca(_bitset_overall_size(sizeof(bitset_t), highest_bit)), highest_bit)
104 * Get the unit which contains a specific bit.
105 * This function is internal.
106 * @param bs The bitset.
107 * @param bit The bit.
108 * @return A pointer to the unit containing the bit.
110 static INLINE unsigned long *_bitset_get_unit(const bitset_t *bs, unsigned long bit)
112 assert(bit < bs->units * BS_UNIT_SIZE_BITS && "Bit too large");
113 return bs->data + bit / BS_UNIT_SIZE_BITS;
117 * Set a bit in the bitset.
118 * @param bs The bitset.
119 * @param bit The bit to set.
121 static INLINE void bitset_set(bitset_t *bs, unsigned long bit)
123 unsigned long *unit = _bitset_get_unit(bs, bit);
124 _bitset_inside_set(unit, bit & BS_UNIT_MASK);
128 * Clear a bit in the bitset.
129 * @param bs The bitset.
130 * @param bit The bit to clear.
132 static INLINE void bitset_clear(bitset_t *bs, unsigned long bit)
134 unsigned long *unit = _bitset_get_unit(bs, bit);
135 _bitset_inside_clear(unit, bit & BS_UNIT_MASK);
138 static INLINE int bitset_is_set(const bitset_t *bs, unsigned long bit)
140 unsigned long *unit = _bitset_get_unit(bs, bit);
141 return _bitset_inside_is_set(unit, bit & BS_UNIT_MASK);
145 * Flip a bit in a bitset.
146 * @param bs The bitset.
147 * @param bit The bit to flip.
149 static INLINE void bitset_flip(bitset_t *bs, unsigned long bit)
151 unsigned long *unit = _bitset_get_unit(bs, bit);
152 _bitset_inside_flip(unit, bit & BS_UNIT_MASK);
156 * Copy a bitset to another.
157 * @param tgt The target bitset.
158 * @param src The source bitset.
159 * @return The target bitset.
161 static INLINE bitset_t *bitset_copy(bitset_t *tgt, const bitset_t *src)
163 unsigned long tu = tgt->units;
164 unsigned long su = src->units;
165 unsigned long min_units = tu < su ? tu : su;
166 memcpy(tgt->data, src->data, min_units * BS_UNIT_SIZE);
168 memset(tgt->data + min_units, 0, BS_UNIT_SIZE * (tu - min_units));
173 * Find the smallest bit set in the bitset.
174 * @param bs The bitset.
175 * @return The smallest bit set in the bitset.
177 static INLINE unsigned long bitset_min(const bitset_t *bs)
179 unsigned long i, ofs = 0;
181 for(i = 0; i < bs->units; ++i) {
182 unsigned long *unit = &bs->data[i];
183 unsigned long pos = _bitset_inside_ntz(unit);
186 ofs += BS_UNIT_SIZE_BITS;
193 * Find the greatest bit set in the bitset.
194 * @param bs The bitset.
195 * @return The greatest bit set in the bitset.
197 static INLINE unsigned long bitset_max(const bitset_t *bs)
199 unsigned long i, max = 0, ofs = 0;
201 for(i = 0; i < bs->units; ++i) {
202 unsigned long *unit = &bs->data[i];
203 unsigned long pos = _bitset_inside_nlz(unit);
206 ofs += BS_UNIT_SIZE_BITS;
213 * Find the next set bit from a given bit.
214 * @note Note that if pos is set, pos is returned.
215 * @param bs The bitset.
216 * @param pos The bit from which to search for the next set bit.
217 * @return The next set bit from pos on, or -1, if no set bit was found
220 static INLINE unsigned long _bitset_next(const bitset_t *bs,
221 unsigned long pos, int set)
223 unsigned long unit_number = pos / BS_UNIT_SIZE_BITS;
225 if(unit_number >= bs->units)
229 unsigned long bit_in_unit = pos & BS_UNIT_MASK;
230 unsigned long in_unit_mask = (1 << bit_in_unit) - 1;
233 * Mask out the bits smaller than pos in the current unit.
234 * We are only interested in bits set higher than pos.
236 unsigned long curr_unit = bs->data[unit_number] & ~in_unit_mask;
238 /* Find the next bit set in the unit. */
239 unsigned long next_in_this_unit
240 = _bitset_inside_ntz_value(set ? curr_unit : ~curr_unit);
242 /* If there is a bit set in the current unit, exit. */
243 if(next_in_this_unit < BS_UNIT_SIZE_BITS)
244 return next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
246 /* Else search for set bits in the next units. */
249 for(i = unit_number + 1; i < bs->units; ++i) {
250 unsigned long data = bs->data[i];
251 unsigned long first_set = _bitset_inside_ntz_value(set ? data : ~data);
252 if(first_set < BS_UNIT_SIZE_BITS)
253 return first_set + i * BS_UNIT_SIZE_BITS;
261 #define bitset_next_clear(bs,pos) _bitset_next((bs), (pos), 0)
262 #define bitset_next_set(bs,pos) _bitset_next((bs), (pos), 1)
265 * Convenience macro for bitset iteration.
266 * @param bitset The bitset.
267 * @param elm A unsigned long variable.
269 #define bitset_foreach(bitset,elm) \
270 for(elm = bitset_next_set(bitset,0); elm != -1; elm = bitset_next_set(bitset,elm+1))
273 * Count the bits set.
274 * This can also be seen as the cardinality of the set.
275 * @param bs The bitset.
276 * @return The number of bits set in the bitset.
278 static INLINE unsigned long bitset_popcnt(const bitset_t *bs)
280 unsigned long i, pop = 0;
283 for(i = 0, unit = bs->data; i < bs->units; ++i, ++unit)
284 pop += _bitset_inside_pop(unit);
291 * This sets all bits to zero.
292 * @param bs The bitset.
294 static INLINE void bitset_clear_all(bitset_t *bs)
296 memset(bs->data, 0, BS_UNIT_SIZE * bs->units);
300 * Check, if one bitset is contained by another.
301 * That is, each bit set in lhs is also set in rhs.
302 * @param lhs A bitset.
303 * @param rhs Another bitset.
304 * @return 1, if all bits in lhs are also set in rhs, 0 otherwise.
306 static INLINE int bitset_contains(const bitset_t *lhs, const bitset_t *rhs)
308 unsigned long n = lhs->units < rhs->units ? lhs->units : rhs->units;
311 for(i = 0; i < n; ++i) {
312 unsigned long lu = lhs->data[i];
313 unsigned long ru = rhs->data[i];
320 * If the left hand sinde is a larger bitset than rhs,
321 * we have to check, that all extra bits in lhs are 0
324 for(i = n; i < lhs->units; ++i) {
325 if(lhs->data[i] != 0)
334 * Print a bitset to a stream.
335 * The bitset is printed as a comma seperated list of bits set.
336 * @param file The stream.
337 * @param bs The bitset.
339 static INLINE void bitset_fprint(FILE *file, const bitset_t *bs)
341 const char *prefix = "";
345 for(i = bitset_next_set(bs, 0); i != -1; i = bitset_next_set(bs, i + 1)) {
346 fprintf(file, "%s%u", prefix, i);
352 static INLINE void bitset_debug_fprint(FILE *file, const bitset_t *bs)
356 fprintf(file, "%d:", bs->units);
357 for(i = 0; i < bs->units; ++i)
358 fprintf(file, " %0lx", bs->data[i]);
362 * Here, the binary operations follow.
363 * And, Or, And Not, Xor are available.
365 #define BINARY_OP(op) \
366 static INLINE bitset_t *bitset_ ## op(bitset_t *tgt, const bitset_t *src) \
369 int n = tgt->units > src->units ? src->units : tgt->units; \
370 for(i = 0; i < n; i += _BITSET_BINOP_UNITS_INC) \
371 _bitset_inside_binop_ ## op(&tgt->data[i], &src->data[i]); \
373 _bitset_clear_rest(&tgt->data[i], tgt->units - i); \
378 * Define the clear rest macro for the and, since it is the only case,
379 * were non existed (treated as 0) units in the src must be handled.
380 * For all other operations holds: x Op 0 = x for Op in { Andnot, Or, Xor }
382 * For and, each bitset implementer has to provide the macro
383 * _bitset_clear_units(data, n), which clears n units from the pointer
386 #define _bitset_clear_rest(data,n) _bitset_inside_clear_units(data, n)
388 #undef _bitset_clear_rest
389 #define _bitset_clear_rest(data,n)