include/asm-x86/bitops_64.h

   1 #ifndef _X86_64_BITOPS_H
   2 #define _X86_64_BITOPS_H
   3
   4 /*
   5  * Copyright 1992, Linus Torvalds.
   6  */
   7
   8 extern long find_first_zero_bit(const unsigned long *addr, unsigned long size);
   9 extern long find_next_zero_bit(const unsigned long *addr, long size, long offset);
  10 extern long find_first_bit(const unsigned long *addr, unsigned long size);
  11 extern long find_next_bit(const unsigned long *addr, long size, long offset);
  12
  13 /* return index of first bet set in val or max when no bit is set */
  14 static inline long __scanbit(unsigned long val, unsigned long max)
  15 {
  16         asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
  17         return val;
  18 }
  19
  20 #define find_first_bit(addr,size) \
  21 ((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
  22   (__scanbit(*(unsigned long *)addr,(size))) : \
  23   find_first_bit(addr,size)))
  24
  25 #define find_next_bit(addr,size,off) \
  26 ((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ?         \
  27   ((off) + (__scanbit((*(unsigned long *)addr) >> (off),(size)-(off)))) : \
  28         find_next_bit(addr,size,off)))
  29
  30 #define find_first_zero_bit(addr,size) \
  31 ((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ? \
  32   (__scanbit(~*(unsigned long *)addr,(size))) : \
  33         find_first_zero_bit(addr,size)))
  34
  35 #define find_next_zero_bit(addr,size,off) \
  36 ((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ?         \
  37   ((off)+(__scanbit(~(((*(unsigned long *)addr)) >> (off)),(size)-(off)))) : \
  38         find_next_zero_bit(addr,size,off)))
  39
  40 /*
  41  * Find string of zero bits in a bitmap. -1 when not found.
  42  */
  43 extern unsigned long
  44 find_next_zero_string(unsigned long *bitmap, long start, long nbits, int len);
  45
  46 static inline void set_bit_string(unsigned long *bitmap, unsigned long i,
  47                                   int len)
  48 {
  49         unsigned long end = i + len;
  50         while (i < end) {
  51                 __set_bit(i, bitmap);
  52                 i++;
  53         }
  54 }
  55
  56 static inline void __clear_bit_string(unsigned long *bitmap, unsigned long i,
  57                                     int len)
  58 {
  59         unsigned long end = i + len;
  60         while (i < end) {
  61                 __clear_bit(i, bitmap);
  62                 i++;
  63         }
  64 }
  65
  66 /**
  67  * ffz - find first zero in word.
  68  * @word: The word to search
  69  *
  70  * Undefined if no zero exists, so code should check against ~0UL first.
  71  */
  72 static inline unsigned long ffz(unsigned long word)
  73 {
  74         __asm__("bsfq %1,%0"
  75                 :"=r" (word)
  76                 :"r" (~word));
  77         return word;
  78 }
  79
  80 /**
  81  * __ffs - find first bit in word.
  82  * @word: The word to search
  83  *
  84  * Undefined if no bit exists, so code should check against 0 first.
  85  */
  86 static inline unsigned long __ffs(unsigned long word)
  87 {
  88         __asm__("bsfq %1,%0"
  89                 :"=r" (word)
  90                 :"rm" (word));
  91         return word;
  92 }
  93
  94 /*
  95  * __fls: find last bit set.
  96  * @word: The word to search
  97  *
  98  * Undefined if no zero exists, so code should check against ~0UL first.
  99  */
 100 static inline unsigned long __fls(unsigned long word)
 101 {
 102         __asm__("bsrq %1,%0"
 103                 :"=r" (word)
 104                 :"rm" (word));
 105         return word;
 106 }
 107
 108 #ifdef __KERNEL__
 109
 110 #include <asm-generic/bitops/sched.h>
 111
 112 /**
 113  * ffs - find first bit set
 114  * @x: the word to search
 115  *
 116  * This is defined the same way as
 117  * the libc and compiler builtin ffs routines, therefore
 118  * differs in spirit from the above ffz (man ffs).
 119  */
 120 static inline int ffs(int x)
 121 {
 122         int r;
 123
 124         __asm__("bsfl %1,%0\n\t"
 125                 "cmovzl %2,%0"
 126                 : "=r" (r) : "rm" (x), "r" (-1));
 127         return r+1;
 128 }
 129
 130 /**
 131  * fls64 - find last bit set in 64 bit word
 132  * @x: the word to search
 133  *
 134  * This is defined the same way as fls.
 135  */
 136 static inline int fls64(__u64 x)
 137 {
 138         if (x == 0)
 139                 return 0;
 140         return __fls(x) + 1;
 141 }
 142
 143 /**
 144  * fls - find last bit set
 145  * @x: the word to search
 146  *
 147  * This is defined the same way as ffs.
 148  */
 149 static inline int fls(int x)
 150 {
 151         int r;
 152
 153         __asm__("bsrl %1,%0\n\t"
 154                 "cmovzl %2,%0"
 155                 : "=&r" (r) : "rm" (x), "rm" (-1));
 156         return r+1;
 157 }
 158
 159 #define ARCH_HAS_FAST_MULTIPLIER 1
 160
 161 #include <asm-generic/bitops/hweight.h>
 162
 163 #endif /* __KERNEL__ */
 164
 165 #ifdef __KERNEL__
 166
 167 #include <asm-generic/bitops/ext2-non-atomic.h>
 168
 169 #define ext2_set_bit_atomic(lock,nr,addr) \
 170                 test_and_set_bit((nr),(unsigned long*)addr)
 171 #define ext2_clear_bit_atomic(lock,nr,addr) \
 172                 test_and_clear_bit((nr),(unsigned long*)addr)
 173
 174 #include <asm-generic/bitops/minix.h>
 175
 176 #endif /* __KERNEL__ */
 177
 178 #endif /* _X86_64_BITOPS_H */