LXR linux-bk/include/linux/bitops.h

   1#ifndef _LINUX_BITOPS_H
   2#define _LINUX_BITOPS_H
   3#include <asm/types.h>
   4#include <asm/bitops.h>
   5
   6/*
   7 * ffs: find first bit set. This is defined the same way as
   8 * the libc and compiler builtin ffs routines, therefore
   9 * differs in spirit from the above ffz (man ffs).
  10 */
  11
  12static inline int generic_ffs(int x)
  13{
  14        int r = 1;
  15
  16        if (!x)
  17                return 0;
  18        if (!(x & 0xffff)) {
  19                x >>= 16;
  20                r += 16;
  21        }
  22        if (!(x & 0xff)) {
  23                x >>= 8;
  24                r += 8;
  25        }
  26        if (!(x & 0xf)) {
  27                x >>= 4;
  28                r += 4;
  29        }
  30        if (!(x & 3)) {
  31                x >>= 2;
  32                r += 2;
  33        }
  34        if (!(x & 1)) {
  35                x >>= 1;
  36                r += 1;
  37        }
  38        return r;
  39}
  40
  41/*
  42 * fls: find last bit set.
  43 */
  44
  45static __inline__ int generic_fls(int x)
  46{
  47        int r = 32;
  48
  49        if (!x)
  50                return 0;
  51        if (!(x & 0xffff0000u)) {
  52                x <<= 16;
  53                r -= 16;
  54        }
  55        if (!(x & 0xff000000u)) {
  56                x <<= 8;
  57                r -= 8;
  58        }
  59        if (!(x & 0xf0000000u)) {
  60                x <<= 4;
  61                r -= 4;
  62        }
  63        if (!(x & 0xc0000000u)) {
  64                x <<= 2;
  65                r -= 2;
  66        }
  67        if (!(x & 0x80000000u)) {
  68                x <<= 1;
  69                r -= 1;
  70        }
  71        return r;
  72}
  73
  74static __inline__ int get_bitmask_order(unsigned int count)
  75{
  76        int order;
  77        
  78        order = fls(count);
  79        return order;   /* We could be slightly more clever with -1 here... */
  80}
  81
  82/*
  83 * hweightN: returns the hamming weight (i.e. the number
  84 * of bits set) of a N-bit word
  85 */
  86
  87static inline unsigned int generic_hweight32(unsigned int w)
  88{
  89        unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
  90        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
  91        res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
  92        res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
  93        return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
  94}
  95
  96static inline unsigned int generic_hweight16(unsigned int w)
  97{
  98        unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
  99        res = (res & 0x3333) + ((res >> 2) & 0x3333);
 100        res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
 101        return (res & 0x00FF) + ((res >> 8) & 0x00FF);
 102}
 103
 104static inline unsigned int generic_hweight8(unsigned int w)
 105{
 106        unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
 107        res = (res & 0x33) + ((res >> 2) & 0x33);
 108        return (res & 0x0F) + ((res >> 4) & 0x0F);
 109}
 110
 111static inline unsigned long generic_hweight64(__u64 w)
 112{
 113#if BITS_PER_LONG < 64
 114        return generic_hweight32((unsigned int)(w >> 32)) +
 115                                generic_hweight32((unsigned int)w);
 116#else
 117        u64 res;
 118        res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
 119        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
 120        res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
 121        res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
 122        res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
 123        return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
 124#endif
 125}
 126
 127static inline unsigned long hweight_long(unsigned long w)
 128{
 129        return sizeof(w) == 4 ? generic_hweight32(w) : generic_hweight64(w);
 130}
 131
 132#endif
 133