Annotation of qemu/bitops.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Bitops Module
                      3:  *
                      4:  * Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com>
                      5:  *
                      6:  * Mostly inspired by (stolen from) linux/bitmap.h and linux/bitops.h
                      7:  *
                      8:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
                      9:  * See the COPYING.LIB file in the top-level directory.
                     10:  */
                     11: 
                     12: #ifndef BITOPS_H
                     13: #define BITOPS_H
                     14: 
                     15: #include "qemu-common.h"
                     16: 
                     17: #define BITS_PER_BYTE           CHAR_BIT
                     18: #define BITS_PER_LONG           (sizeof (unsigned long) * BITS_PER_BYTE)
                     19: 
                     20: #define BIT(nr)                        (1UL << (nr))
                     21: #define BIT_MASK(nr)           (1UL << ((nr) % BITS_PER_LONG))
                     22: #define BIT_WORD(nr)           ((nr) / BITS_PER_LONG)
                     23: #define BITS_TO_LONGS(nr)      DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
                     24: 
                     25: /**
                     26:  * bitops_ffs - find first bit in word.
                     27:  * @word: The word to search
                     28:  *
                     29:  * Undefined if no bit exists, so code should check against 0 first.
                     30:  */
                     31: static unsigned long bitops_ffsl(unsigned long word)
                     32: {
                     33:        int num = 0;
                     34: 
                     35: #if LONG_MAX > 0x7FFFFFFF
                     36:        if ((word & 0xffffffff) == 0) {
                     37:                num += 32;
                     38:                word >>= 32;
                     39:        }
                     40: #endif
                     41:        if ((word & 0xffff) == 0) {
                     42:                num += 16;
                     43:                word >>= 16;
                     44:        }
                     45:        if ((word & 0xff) == 0) {
                     46:                num += 8;
                     47:                word >>= 8;
                     48:        }
                     49:        if ((word & 0xf) == 0) {
                     50:                num += 4;
                     51:                word >>= 4;
                     52:        }
                     53:        if ((word & 0x3) == 0) {
                     54:                num += 2;
                     55:                word >>= 2;
                     56:        }
                     57:        if ((word & 0x1) == 0) {
                     58:                num += 1;
                     59:         }
                     60:        return num;
                     61: }
                     62: 
                     63: /**
                     64:  * bitops_fls - find last (most-significant) set bit in a long word
                     65:  * @word: the word to search
                     66:  *
                     67:  * Undefined if no set bit exists, so code should check against 0 first.
                     68:  */
                     69: static inline unsigned long bitops_flsl(unsigned long word)
                     70: {
                     71:        int num = BITS_PER_LONG - 1;
                     72: 
                     73: #if LONG_MAX > 0x7FFFFFFF
                     74:        if (!(word & (~0ul << 32))) {
                     75:                num -= 32;
                     76:                word <<= 32;
                     77:        }
                     78: #endif
                     79:        if (!(word & (~0ul << (BITS_PER_LONG-16)))) {
                     80:                num -= 16;
                     81:                word <<= 16;
                     82:        }
                     83:        if (!(word & (~0ul << (BITS_PER_LONG-8)))) {
                     84:                num -= 8;
                     85:                word <<= 8;
                     86:        }
                     87:        if (!(word & (~0ul << (BITS_PER_LONG-4)))) {
                     88:                num -= 4;
                     89:                word <<= 4;
                     90:        }
                     91:        if (!(word & (~0ul << (BITS_PER_LONG-2)))) {
                     92:                num -= 2;
                     93: 
                     94:                word <<= 2;
                     95:        }
                     96:        if (!(word & (~0ul << (BITS_PER_LONG-1))))
                     97:                num -= 1;
                     98:        return num;
                     99: }
                    100: 
                    101: /**
                    102:  * ffz - find first zero in word.
                    103:  * @word: The word to search
                    104:  *
                    105:  * Undefined if no zero exists, so code should check against ~0UL first.
                    106:  */
                    107: static inline unsigned long ffz(unsigned long word)
                    108: {
                    109:     return bitops_ffsl(~word);
                    110: }
                    111: 
                    112: /**
                    113:  * set_bit - Set a bit in memory
                    114:  * @nr: the bit to set
                    115:  * @addr: the address to start counting from
                    116:  */
                    117: static inline void set_bit(int nr, volatile unsigned long *addr)
                    118: {
                    119:        unsigned long mask = BIT_MASK(nr);
                    120:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    121: 
                    122:        *p  |= mask;
                    123: }
                    124: 
                    125: /**
                    126:  * clear_bit - Clears a bit in memory
                    127:  * @nr: Bit to clear
                    128:  * @addr: Address to start counting from
                    129:  */
                    130: static inline void clear_bit(int nr, volatile unsigned long *addr)
                    131: {
                    132:        unsigned long mask = BIT_MASK(nr);
                    133:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    134: 
                    135:        *p &= ~mask;
                    136: }
                    137: 
                    138: /**
                    139:  * change_bit - Toggle a bit in memory
                    140:  * @nr: Bit to change
                    141:  * @addr: Address to start counting from
                    142:  */
                    143: static inline void change_bit(int nr, volatile unsigned long *addr)
                    144: {
                    145:        unsigned long mask = BIT_MASK(nr);
                    146:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    147: 
                    148:        *p ^= mask;
                    149: }
                    150: 
                    151: /**
                    152:  * test_and_set_bit - Set a bit and return its old value
                    153:  * @nr: Bit to set
                    154:  * @addr: Address to count from
                    155:  */
                    156: static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
                    157: {
                    158:        unsigned long mask = BIT_MASK(nr);
                    159:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    160:        unsigned long old = *p;
                    161: 
                    162:        *p = old | mask;
                    163:        return (old & mask) != 0;
                    164: }
                    165: 
                    166: /**
                    167:  * test_and_clear_bit - Clear a bit and return its old value
                    168:  * @nr: Bit to clear
                    169:  * @addr: Address to count from
                    170:  */
                    171: static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
                    172: {
                    173:        unsigned long mask = BIT_MASK(nr);
                    174:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    175:        unsigned long old = *p;
                    176: 
                    177:        *p = old & ~mask;
                    178:        return (old & mask) != 0;
                    179: }
                    180: 
                    181: /**
                    182:  * test_and_change_bit - Change a bit and return its old value
                    183:  * @nr: Bit to change
                    184:  * @addr: Address to count from
                    185:  */
                    186: static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
                    187: {
                    188:        unsigned long mask = BIT_MASK(nr);
                    189:        unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
                    190:        unsigned long old = *p;
                    191: 
                    192:        *p = old ^ mask;
                    193:        return (old & mask) != 0;
                    194: }
                    195: 
                    196: /**
                    197:  * test_bit - Determine whether a bit is set
                    198:  * @nr: bit number to test
                    199:  * @addr: Address to start counting from
                    200:  */
                    201: static inline int test_bit(int nr, const volatile unsigned long *addr)
                    202: {
                    203:        return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));
                    204: }
                    205: 
                    206: /**
                    207:  * find_last_bit - find the last set bit in a memory region
                    208:  * @addr: The address to start the search at
                    209:  * @size: The maximum size to search
                    210:  *
                    211:  * Returns the bit number of the first set bit, or size.
                    212:  */
                    213: unsigned long find_last_bit(const unsigned long *addr,
                    214:                             unsigned long size);
                    215: 
                    216: /**
                    217:  * find_next_bit - find the next set bit in a memory region
                    218:  * @addr: The address to base the search on
                    219:  * @offset: The bitnumber to start searching at
                    220:  * @size: The bitmap size in bits
                    221:  */
                    222: unsigned long find_next_bit(const unsigned long *addr,
                    223:                                   unsigned long size, unsigned long offset);
                    224: 
                    225: /**
                    226:  * find_next_zero_bit - find the next cleared bit in a memory region
                    227:  * @addr: The address to base the search on
                    228:  * @offset: The bitnumber to start searching at
                    229:  * @size: The bitmap size in bits
                    230:  */
                    231: 
                    232: unsigned long find_next_zero_bit(const unsigned long *addr,
                    233:                                  unsigned long size,
                    234:                                  unsigned long offset);
                    235: 
                    236: /**
                    237:  * find_first_bit - find the first set bit in a memory region
                    238:  * @addr: The address to start the search at
                    239:  * @size: The maximum size to search
                    240:  *
                    241:  * Returns the bit number of the first set bit.
                    242:  */
                    243: static inline unsigned long find_first_bit(const unsigned long *addr,
                    244:                                            unsigned long size)
                    245: {
                    246:     return find_next_bit(addr, size, 0);
                    247: }
                    248: 
                    249: /**
                    250:  * find_first_zero_bit - find the first cleared bit in a memory region
                    251:  * @addr: The address to start the search at
                    252:  * @size: The maximum size to search
                    253:  *
                    254:  * Returns the bit number of the first cleared bit.
                    255:  */
                    256: static inline unsigned long find_first_zero_bit(const unsigned long *addr,
                    257:                                                 unsigned long size)
                    258: {
                    259:     return find_next_zero_bit(addr, size, 0);
                    260: }
                    261: 
                    262: static inline unsigned long hweight_long(unsigned long w)
                    263: {
                    264:     unsigned long count;
                    265: 
                    266:     for (count = 0; w; w >>= 1) {
                    267:         count += w & 1;
                    268:     }
                    269:     return count;
                    270: }
                    271: 
                    272: #endif

unix.superglobalmegacorp.com