include/bitops.h

Go to the documentation of this file.

#ifndef BITOPS_H_INCLUDED
#define BITOPS_H_INCLUDED

#include <assert.h>
#include <compiler.h>
#include <stdbool.h>
#include <types.h>
#include <util.h>

#define bit_mask(ws, nr)        (1 << ((nr) & ((ws) - 1)))

#define bit_word(ws, nr)        ((nr) / (ws))

#define set_bit(nr, bitmap)                                             \
        do {                                                            \
                unsigned int priv_bit_ws = 8 * sizeof(*(bitmap));       \
                unsigned int priv_bit_nr = (nr);                        \
                (bitmap)[bit_word(priv_bit_ws, priv_bit_nr)]            \
                        |= bit_mask(priv_bit_ws, priv_bit_nr);          \
        } while (0)

#define clear_bit(nr, bitmap)                                           \
        do {                                                            \
                unsigned int priv_bit_ws = 8 * sizeof(*(bitmap));       \
                unsigned int priv_bit_nr = (nr);                        \
                (bitmap)[bit_word(priv_bit_ws, priv_bit_nr)]            \
                        &= ~bit_mask(priv_bit_ws, priv_bit_nr);         \
        } while (0)

#define toggle_bit(nr, bitmap)                                          \
        do {                                                            \
                unsigned int priv_bit_ws = 8 * sizeof(*(bitmap));       \
                unsigned int priv_bit_nr = (nr);                        \
                (bitmap)[bit_word(priv_bit_ws, priv_bit_nr)]            \
                        ^= bit_mask(priv_bit_ws, priv_bit_nr);          \
        } while (0)

ERROR_FUNC(priv_test_bit_bad_type, "Invalid type passed to test_bit()");

__always_inline static bool priv_test_bit_ws(unsigned int nr, const void *bp,
                unsigned int ws)
{
        union {
                const uint8_t *b;
                const uint16_t *s;
                const uint32_t *l;
        } p = { bp };

        switch (ws) {
        case 8:
                return 1U & (p.b[bit_word(8, nr)] >> (nr & (8 - 1)));
        case 16:
                return 1U & (p.s[bit_word(16, nr)] >> (nr & (16 - 1)));
        case 32:
                return 1U & (p.l[bit_word(32, nr)] >> (nr & (32 - 1)));
        default:
                priv_test_bit_bad_type();
                return false;
        }
}

#define test_bit(nr, bitmap)                                            \
        priv_test_bit_ws(nr, bitmap, 8 * sizeof(*(bitmap)))

#include <arch/bitops.h>

#define bit_word_reverse(word)                  compiler_brev(word)

#define bit_word_find_first_one_bit(word)       compiler_ctz(word)

#define bit_word_find_last_one_bit(word)        (31 - compiler_clz(word))

#define bit_word_find_first_zero_bit(word)              \
        bit_word_find_first_one_bit(~word)

#define bit_word_find_last_zero_bit(word)               \
        bit_word_find_last_one_bit(~word)

static inline unsigned int bit_array_find_first_one_bit(
                const bit_word_t *bitmap, unsigned int len)
{
        unsigned int    i;
        unsigned int    nr_words;

        nr_words = div_ceil(len, 8 * sizeof(*bitmap));

        for (i = 0; i < nr_words; i++) {
                if (bitmap[i])
                        return bit_word_find_first_one_bit(bitmap[i]);
        }

        return len;
}


#endif /* BITOPS_H_INCLUDED */

---