2 * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief A bitset implementation.
23 * @author Sebastian Hack
27 #ifndef FIRM_ADT_BITSET_H
28 #define FIRM_ADT_BITSET_H
30 #include "firm_config.h"
38 #include "bitfiddle.h"
40 typedef unsigned int bitset_pos_t;
42 #include "bitset_std.h"
44 #if defined(__GNUC__) && defined(__i386__)
45 #include "bitset_ia32.h"
48 typedef struct _bitset_t {
54 #define BS_UNIT_SIZE sizeof(bitset_unit_t)
55 #define BS_UNIT_SIZE_BITS (BS_UNIT_SIZE * 8)
56 #define BS_UNIT_MASK (BS_UNIT_SIZE_BITS - 1)
59 * Initialize a bitset.
60 * This functions should not be called.
62 * Note that this function needs three macros which must be provided by the
63 * bitfield implementor:
64 * - _bitset_overall_size(size) The overall size that must be
65 * allocated for the bitfield in bytes.
66 * - _bitset_units(size) The number of units that will be
67 * present in the bitfield for a given highest bit.
68 * - _bitset_data_ptr(data, size) This produces as pointer to the
69 * first unit in the allocated memory area. The main reason for this
70 * macro is, that some bitset implementors want control over memory
73 * @param area A pointer to memory reserved for the bitset.
74 * @param size The size of the bitset in bits.
75 * @return A pointer to the initialized bitset.
77 static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
80 memset(area, 0, _bitset_overall_size(sizeof(bitset_t), size));
81 ptr->units = _bitset_units(size);
83 ptr->data = _bitset_data_ptr(area, sizeof(bitset_t), size);
88 * Mask out all bits, which are only there, because the number
89 * of bits in the set didn't match a unit size boundary.
90 * @param bs The bitset.
91 * @return The masked bitset.
93 static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
95 bitset_pos_t rest = bs->size & BS_UNIT_MASK;
97 bs->data[bs->units - 1] &= (1 << rest) - 1;
102 * Get the capacity of the bitset in bits.
103 * @param bs The bitset.
104 * @return The capacity in bits of the bitset.
106 #define bitset_capacity(bs) ((bs)->units * BS_UNIT_SIZE_BITS)
109 * Get the size of the bitset in bits.
110 * @note Note the difference between capacity and size.
111 * @param bs The bitset.
112 * @return The highest bit which can be set or cleared plus 1.
114 #define bitset_size(bs) ((bs)->size)
117 * Allocate a bitset on an obstack.
118 * @param obst The obstack.
119 * @param size The greatest bit that shall be stored in the set.
120 * @return A pointer to an empty initialized bitset.
122 #define bitset_obstack_alloc(obst,size) \
123 _bitset_prepare(obstack_alloc(obst, _bitset_overall_size(sizeof(bitset_t), size)), size)
126 * Allocate a bitset via malloc.
127 * @param size The greatest bit that shall be stored in the set.
128 * @return A pointer to an empty initialized bitset.
130 #define bitset_malloc(size) \
131 _bitset_prepare(xmalloc(_bitset_overall_size(sizeof(bitset_t), size)), size)
134 * Free a bitset allocated with bitset_malloc().
135 * @param bs The bitset.
137 #define bitset_free(bs) free(bs)
140 * Allocate a bitset on the stack via alloca.
141 * @param size The greatest bit that shall be stored in the set.
142 * @return A pointer to an empty initialized bitset.
144 #define bitset_alloca(size) \
145 _bitset_prepare(alloca(_bitset_overall_size(sizeof(bitset_t), size)), size)
149 * Get the unit which contains a specific bit.
150 * This function is internal.
151 * @param bs The bitset.
152 * @param bit The bit.
153 * @return A pointer to the unit containing the bit.
155 static INLINE bitset_unit_t *_bitset_get_unit(const bitset_t *bs, bitset_pos_t bit)
157 /* assert(bit < bs->units * BS_UNIT_SIZE_BITS && "Bit too large"); */
158 assert(bit <= bs->size && "Bit to large");
159 return bs->data + bit / BS_UNIT_SIZE_BITS;
163 * Set a bit in the bitset.
164 * @param bs The bitset.
165 * @param bit The bit to set.
167 static INLINE void bitset_set(bitset_t *bs, bitset_pos_t bit)
169 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
170 _bitset_inside_set(unit, bit & BS_UNIT_MASK);
174 * Clear a bit in the bitset.
175 * @param bs The bitset.
176 * @param bit The bit to clear.
178 static INLINE void bitset_clear(bitset_t *bs, bitset_pos_t bit)
180 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
181 _bitset_inside_clear(unit, bit & BS_UNIT_MASK);
185 * Check, if a bit is set.
186 * @param bs The bitset.
187 * @param bit The bit to check for.
188 * @return 1, if the bit was set, 0 if not.
190 static INLINE int bitset_is_set(const bitset_t *bs, bitset_pos_t bit)
192 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
193 return _bitset_inside_is_set(unit, bit & BS_UNIT_MASK);
197 * Flip a bit in a bitset.
198 * @param bs The bitset.
199 * @param bit The bit to flip.
201 static INLINE void bitset_flip(bitset_t *bs, bitset_pos_t bit)
203 bitset_unit_t *unit = _bitset_get_unit(bs, bit);
204 _bitset_inside_flip(unit, bit & BS_UNIT_MASK);
208 * Flip the whole bitset.
209 * @param bs The bitset.
211 static INLINE void bitset_flip_all(bitset_t *bs)
214 for(i = 0; i < bs->units; i++)
215 _bitset_inside_flip_unit(&bs->data[i]);
216 _bitset_mask_highest(bs);
220 * Copy a bitset to another.
221 * @param tgt The target bitset.
222 * @param src The source bitset.
223 * @return The target bitset.
225 static INLINE bitset_t *bitset_copy(bitset_t *tgt, const bitset_t *src)
227 bitset_pos_t tu = tgt->units;
228 bitset_pos_t su = src->units;
229 bitset_pos_t min_units = tu < su ? tu : su;
230 memcpy(tgt->data, src->data, min_units * BS_UNIT_SIZE);
232 memset(tgt->data + min_units, 0, BS_UNIT_SIZE * (tu - min_units));
233 return _bitset_mask_highest(tgt);
237 * Find the smallest bit set in the bitset.
238 * @param bs The bitset.
239 * @return The smallest bit set in the bitset.
241 static INLINE bitset_pos_t bitset_min(const bitset_t *bs)
243 bitset_pos_t i, ofs = 0;
245 for(i = 0; i < bs->units; ++i) {
246 bitset_unit_t *unit = &bs->data[i];
247 bitset_pos_t pos = _bitset_inside_ntz(unit);
250 ofs += BS_UNIT_SIZE_BITS;
257 * Find the greatest bit set in the bitset.
258 * @param bs The bitset.
259 * @return The greatest bit set in the bitset.
261 static INLINE bitset_pos_t bitset_max(const bitset_t *bs)
263 bitset_pos_t i, max = 0, ofs = 0;
265 for(i = 0; i < bs->units; ++i) {
266 bitset_unit_t *unit = &bs->data[i];
267 bitset_pos_t pos = _bitset_inside_nlz(unit);
270 ofs += BS_UNIT_SIZE_BITS;
277 * Find the next set bit from a given bit.
278 * @note Note that if pos is set, pos is returned.
279 * @param bs The bitset.
280 * @param pos The bit from which to search for the next set bit.
281 * @return The next set bit from pos on, or -1, if no set bit was found
284 static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
285 bitset_pos_t pos, int set)
287 bitset_pos_t unit_number = pos / BS_UNIT_SIZE_BITS;
294 bitset_pos_t bit_in_unit = pos & BS_UNIT_MASK;
295 bitset_pos_t in_unit_mask = (1 << bit_in_unit) - 1;
298 * Mask out the bits smaller than pos in the current unit.
299 * We are only interested in bits set higher than pos.
301 bitset_unit_t curr_unit = bs->data[unit_number];
304 * Find the next bit set in the unit.
305 * Mind that this function returns 0, if the unit is -1 and
306 * counts the bits from 1 on.
308 bitset_pos_t next_in_this_unit =
309 _bitset_inside_ntz_value((set ? curr_unit : ~curr_unit) & ~in_unit_mask);
311 /* If there is a bit set in the current unit, exit. */
312 if (next_in_this_unit < BS_UNIT_SIZE_BITS) {
313 res = next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
314 return res < bs->size ? res : -1;
317 /* Else search for set bits in the next units. */
320 for(i = unit_number + 1; i < bs->units; ++i) {
321 bitset_unit_t data = bs->data[i];
322 bitset_pos_t first_set =
323 _bitset_inside_ntz_value(set ? data : ~data);
325 if (first_set < BS_UNIT_SIZE_BITS) {
326 res = first_set + i * BS_UNIT_SIZE_BITS;
327 return res < bs->size ? res : -1;
336 #define bitset_next_clear(bs,pos) _bitset_next((bs), (pos), 0)
337 #define bitset_next_set(bs,pos) _bitset_next((bs), (pos), 1)
340 * Convenience macro for bitset iteration.
341 * @param bitset The bitset.
342 * @param elm A unsigned long variable.
344 #define bitset_foreach(bitset,elm) \
345 for(elm = bitset_next_set(bitset,0); elm != -1; elm = bitset_next_set(bitset,elm+1))
348 #define bitset_foreach_clear(bitset,elm) \
349 for(elm = bitset_next_clear(bitset,0); elm != -1; elm = bitset_next_clear(bitset,elm+1))
352 * Count the bits set.
353 * This can also be seen as the cardinality of the set.
354 * @param bs The bitset.
355 * @return The number of bits set in the bitset.
357 static INLINE unsigned bitset_popcnt(const bitset_t *bs)
363 for (i = 0, unit = bs->data; i < bs->units; ++i, ++unit)
364 pop += _bitset_inside_pop(unit);
371 * This sets all bits to zero.
372 * @param bs The bitset.
374 static INLINE bitset_t *bitset_clear_all(bitset_t *bs)
376 memset(bs->data, 0, BS_UNIT_SIZE * bs->units);
382 * This sets all bits to one.
383 * @param bs The bitset.
385 static INLINE bitset_t *bitset_set_all(bitset_t *bs)
387 memset(bs->data, -1, bs->units * BS_UNIT_SIZE);
388 return _bitset_mask_highest(bs);
392 * Check, if one bitset is contained by another.
393 * That is, each bit set in lhs is also set in rhs.
394 * @param lhs A bitset.
395 * @param rhs Another bitset.
396 * @return 1, if all bits in lhs are also set in rhs, 0 otherwise.
398 static INLINE int bitset_contains(const bitset_t *lhs, const bitset_t *rhs)
400 bitset_pos_t n = lhs->units < rhs->units ? lhs->units : rhs->units;
403 for(i = 0; i < n; ++i) {
404 bitset_unit_t lu = lhs->data[i];
405 bitset_unit_t ru = rhs->data[i];
412 * If the left hand sinde is a larger bitset than rhs,
413 * we have to check, that all extra bits in lhs are 0
416 for(i = n; i < lhs->units; ++i) {
417 if(lhs->data[i] != 0)
426 * Treat the bitset as a number and subtract 1.
427 * @param bs The bitset.
428 * @return The same bitset.
430 static INLINE void bitset_minus1(bitset_t *bs)
432 #define _SH (sizeof(bitset_unit_t) * 8 - 1)
436 for(i = 0; i < bs->units; ++i) {
437 bitset_unit_t unit = bs->data[i];
438 bitset_unit_t um1 = unit - 1;
442 if(((unit >> _SH) ^ (um1 >> _SH)) == 0)
449 * Check if two bitsets intersect.
450 * @param a The first bitset.
451 * @param b The second bitset.
452 * @return 1 if they have a bit in common, 0 if not.
454 static INLINE int bitset_intersect(const bitset_t *a, const bitset_t *b)
456 bitset_pos_t n = a->units < b->units ? a->units : b->units;
459 for (i = 0; i < n; ++i)
460 if (a->data[i] & b->data[i])
467 * Check, if a bitset is empty.
468 * @param a The bitset.
469 * @return 1, if the bitset is empty, 0 if not.
471 static INLINE int bitset_is_empty(const bitset_t *a)
474 for (i = 0; i < a->units; ++i)
481 * Print a bitset to a stream.
482 * The bitset is printed as a comma separated list of bits set.
483 * @param file The stream.
484 * @param bs The bitset.
486 static INLINE void bitset_fprint(FILE *file, const bitset_t *bs)
488 const char *prefix = "";
492 for(i = bitset_next_set(bs, 0); i != -1; i = bitset_next_set(bs, i + 1)) {
493 fprintf(file, "%s%u", prefix, i);
499 static INLINE void bitset_debug_fprint(FILE *file, const bitset_t *bs)
503 fprintf(file, "%u:", bs->units);
504 for(i = 0; i < bs->units; ++i)
505 fprintf(file, " " BITSET_UNIT_FMT, bs->data[i]);
509 * Perform tgt = tgt \ src operation.
510 * @param tgt The target bitset.
511 * @param src The source bitset.
512 * @return the tgt set.
514 static INLINE bitset_t *bitset_andnot(bitset_t *tgt, const bitset_t *src);
517 * Perform Union, tgt = tgt u src operation.
518 * @param tgt The target bitset.
519 * @param src The source bitset.
520 * @return the tgt set.
522 static INLINE bitset_t *bitset_or(bitset_t *tgt, const bitset_t *src);
525 * Perform tgt = tgt ^ ~src operation.
526 * @param tgt The target bitset.
527 * @param src The source bitset.
528 * @return the tgt set.
530 static INLINE bitset_t *bitset_xor(bitset_t *tgt, const bitset_t *src);
533 * Here, the binary operations follow.
534 * And, Or, And Not, Xor are available.
536 #define BINARY_OP(op) \
537 static INLINE bitset_t *bitset_ ## op(bitset_t *tgt, const bitset_t *src) \
540 bitset_pos_t n = tgt->units > src->units ? src->units : tgt->units; \
541 for(i = 0; i < n; i += _BITSET_BINOP_UNITS_INC) \
542 _bitset_inside_binop_ ## op(&tgt->data[i], &src->data[i]); \
544 _bitset_clear_rest(&tgt->data[i], tgt->units - i); \
545 return _bitset_mask_highest(tgt); \
549 * Define the clear rest macro for the and, since it is the only case,
550 * were non existed (treated as 0) units in the src must be handled.
551 * For all other operations holds: x Op 0 = x for Op in { Andnot, Or, Xor }
553 * For and, each bitset implementer has to provide the macro
554 * _bitset_clear_units(data, n), which clears n units from the pointer
557 #define _bitset_clear_rest(data,n) _bitset_inside_clear_units(data, n)
559 #undef _bitset_clear_rest
560 #define _bitset_clear_rest(data,n)