ReactOS  0.4.14-dev-552-g2fad488
bitops.h File Reference
#include <ntifs.h>
#include <linux/types.h>
Include dependency graph for bitops.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define find_first_zero_bit(addr, size)   find_next_zero_bit((addr), (size), 0)
 
#define ffz(x)   __ffs(~(x))
 
#define for_each_bit(bit, addr, size)
 

Functions

int find_next_zero_bit (const unsigned long *addr, int size, int offset)
 
static unsigned long __ffs (unsigned long word)
 
static unsigned find_first_bit (const unsigned long *addr, unsigned size)
 
long find_next_bit (const unsigned long *addr, long size, long offset)
 
static int ffs (int x)
 
static int fls (int x)
 
static int fls64 (__u64 x)
 
static __inline int get_bitmask_order (unsigned int count)
 
static __inline int get_count_order (unsigned int count)
 
static __u32 rol32 (__u32 word, unsigned int shift)
 
static __u32 ror32 (__u32 word, unsigned int shift)
 
static unsigned fls_long (unsigned long l)
 
static unsigned long hweight32 (unsigned long w)
 
static unsigned long hweight64 (__u64 w)
 
static unsigned long hweight_long (unsigned long w)
 

Macro Definition Documentation

◆ ffz

#define ffz (   x)    __ffs(~(x))

Definition at line 171 of file bitops.h.

◆ find_first_zero_bit

#define find_first_zero_bit (   addr,
  size 
)    find_next_zero_bit((addr), (size), 0)

find_first_zero_bit - find the first zero bit in a memory region @addr: The address to start the search at @size: The maximum size to search

Returns the bit number of the first zero bit, not the number of the byte containing a bit.

Definition at line 28 of file bitops.h.

◆ for_each_bit

#define for_each_bit (   bit,
  addr,
  size 
)
Value:
for ((bit) = find_first_bit((addr), (size)); \
(bit) < (size); \
(bit) = find_next_bit((addr), (size), (bit) + 1))
long find_next_bit(const unsigned long *addr, long size, long offset)
Definition: bitops.h:136
GLsizeiptr size
Definition: glext.h:5919
GLenum const GLvoid * addr
Definition: glext.h:9621
static unsigned find_first_bit(const unsigned long *addr, unsigned size)
Definition: bitops.h:83

Definition at line 256 of file bitops.h.

Function Documentation

◆ __ffs()

static unsigned long __ffs ( unsigned long  word)
inlinestatic

__ffs - find first bit in word. @word: The word to search

Undefined if no bit exists, so code should check against 0 first.

Definition at line 44 of file bitops.h.

45 {
46  int num = 0;
47 
48 #if BITS_PER_LONG == 64
49  if ((word & 0xffffffff) == 0) {
50  num += 32;
51  word >>= 32;
52  }
53 #endif
54  if ((word & 0xffff) == 0) {
55  num += 16;
56  word >>= 16;
57  }
58  if ((word & 0xff) == 0) {
59  num += 8;
60  word >>= 8;
61  }
62  if ((word & 0xf) == 0) {
63  num += 4;
64  word >>= 4;
65  }
66  if ((word & 0x3) == 0) {
67  num += 2;
68  word >>= 2;
69  }
70  if ((word & 0x1) == 0)
71  num += 1;
72  return num;
73 }
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
GLuint GLuint num
Definition: glext.h:9618
const WCHAR * word
Definition: lex.c:36

Referenced by find_first_bit().

◆ ffs()

static int ffs ( int  x)
inlinestatic

ffs - find first bit set @x: the word to search

This is defined the same way as the libc and compiler builtin ffs routines, therefore differs in spirit from the above ffz (man ffs).

Definition at line 182 of file bitops.h.

183 {
184  int r = 1;
185 
186  if (!x)
187  return 0;
188  if (!(x & 0xffff)) {
189  x >>= 16;
190  r += 16;
191  }
192  if (!(x & 0xff)) {
193  x >>= 8;
194  r += 8;
195  }
196  if (!(x & 0xf)) {
197  x >>= 4;
198  r += 4;
199  }
200  if (!(x & 3)) {
201  x >>= 2;
202  r += 2;
203  }
204  if (!(x & 1)) {
205  x >>= 1;
206  r += 1;
207  }
208  return r;
209 }
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

◆ find_first_bit()

static unsigned find_first_bit ( const unsigned long addr,
unsigned  size 
)
inlinestatic

find_first_bit - find the first set bit in a memory region @addr: The address to start the search at @size: The maximum size to search

Returns the bit number of the first set bit, not the number of the byte containing a bit.

Definition at line 83 of file bitops.h.

84 {
85  unsigned x = 0;
86 
87  while (x < size) {
88  unsigned long val = *addr++;
89  if (val)
90  return __ffs(val) + x;
91  x += (sizeof(*addr)<<3);
92  }
93  return x;
94 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint GLfloat * val
Definition: glext.h:7180
GLsizeiptr size
Definition: glext.h:5919
GLenum const GLvoid * addr
Definition: glext.h:9621
static unsigned long __ffs(unsigned long word)
Definition: bitops.h:44

Referenced by find_next_bit().

◆ find_next_bit()

long find_next_bit ( const unsigned long addr,
long  size,
long  offset 
)

find_next_bit - find the next set bit in a memory region @addr: The address to base the search on @offset: The bitnumber to start searching at @size: The maximum size to search

Definition at line 136 of file bitops.h.

137 {
138  const unsigned long * p = addr + (offset >> 6);
139  unsigned long set = 0, bit = offset & 63, res = 0;
140 
141 #if 0
142  if (bit) {
143  /*
144  * Look for nonzero in the first 64 bits:
145  */
146  asm("bsfq %1,%0\n\t"
147  "cmoveq %2,%0\n\t"
148  : "=r" (set)
149  : "r" (*p >> bit), "r" (64L));
150  if (set < (64 - bit))
151  return set + offset;
152  set = 64 - bit;
153  p++;
154  }
155  /*
156  * No set bit yet, search remaining full words for a bit
157  */
158  res = find_first_bit (p, size - 64 * (p - addr));
159 #endif
160 
161  return (offset + set + res);
162 }
GLintptr offset
Definition: glext.h:5920
GLsizeiptr size
Definition: glext.h:5919
static UINT set(struct ID3DXConstantTableImpl *table, IDirect3DDevice9 *device, struct ctab_constant *constant, const void **indata, D3DXPARAMETER_TYPE intype, UINT *size, UINT incol, D3DXPARAMETER_CLASS inclass, UINT index, BOOL is_pointer)
Definition: shader.c:1095
GLenum const GLvoid * addr
Definition: glext.h:9621
static const WCHAR L[]
Definition: oid.c:1250
static unsigned find_first_bit(const unsigned long *addr, unsigned size)
Definition: bitops.h:83
GLuint res
Definition: glext.h:9613
GLfloat GLfloat p
Definition: glext.h:8902
Definition: _set.h:46

◆ find_next_zero_bit()

int find_next_zero_bit ( const unsigned long addr,
int  size,
int  offset 
)

find_next_zero_bit - find the first zero bit in a memory region @addr: The address to base the search on @offset: The bit number to start searching at @size: The maximum size to search

◆ fls()

static int fls ( int  x)
inlinestatic

fls - find last (most-significant) bit set @x: the word to search

This is defined the same way as ffs. Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.

Definition at line 219 of file bitops.h.

220 {
221  int r = 32;
222 
223  if (!x)
224  return 0;
225  if (!(x & 0xffff0000u)) {
226  x <<= 16;
227  r -= 16;
228  }
229  if (!(x & 0xff000000u)) {
230  x <<= 8;
231  r -= 8;
232  }
233  if (!(x & 0xf0000000u)) {
234  x <<= 4;
235  r -= 4;
236  }
237  if (!(x & 0xc0000000u)) {
238  x <<= 2;
239  r -= 2;
240  }
241  if (!(x & 0x80000000u)) {
242  x <<= 1;
243  r -= 1;
244  }
245  return r;
246 }
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

Referenced by fls64(), fls_long(), get_bitmask_order(), and get_count_order().

◆ fls64()

static int fls64 ( __u64  x)
inlinestatic

Definition at line 248 of file bitops.h.

249 {
250  __u32 h = (__u32) (x >> 32);
251  if (h)
252  return fls(h) + 32;
253  return fls((int)x);
254 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
static int fls(int x)
Definition: bitops.h:219
unsigned int __u32
Definition: compat.h:90

Referenced by fls_long().

◆ fls_long()

static unsigned fls_long ( unsigned long  l)
inlinestatic

Definition at line 301 of file bitops.h.

302 {
303  if (sizeof(l) == 4)
304  return fls(l);
305  return fls64(l);
306 }
static int fls64(__u64 x)
Definition: bitops.h:248
r l[0]
Definition: byte_order.h:167
static int fls(int x)
Definition: bitops.h:219

◆ get_bitmask_order()

static __inline int get_bitmask_order ( unsigned int  count)
static

Definition at line 262 of file bitops.h.

263 {
264  int order;
265 
266  order = fls(count);
267  return order; /* We could be slightly more clever with -1 here... */
268 }
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLuint GLuint GLsizei count
Definition: gl.h:1545
static int fls(int x)
Definition: bitops.h:219

◆ get_count_order()

static __inline int get_count_order ( unsigned int  count)
static

Definition at line 270 of file bitops.h.

271 {
272  int order;
273 
274  order = fls(count) - 1;
275  if (count & (count - 1))
276  order++;
277  return order;
278 }
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLuint GLuint GLsizei count
Definition: gl.h:1545
static int fls(int x)
Definition: bitops.h:219

◆ hweight32()

static unsigned long hweight32 ( unsigned long  w)
inlinestatic

Definition at line 313 of file bitops.h.

314 {
315  unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
316  res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
317  res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
318  res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
319  return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
320 }
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLuint res
Definition: glext.h:9613

Referenced by hweight64(), and hweight_long().

◆ hweight64()

static unsigned long hweight64 ( __u64  w)
inlinestatic

Definition at line 322 of file bitops.h.

323 {
324 #if BITS_PER_LONG < 64
325  return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
326 #else
327  u64 res;
328  res = (w & 0x5555555555555555U) + ((w >> 1) & 0x5555555555555555U);
329  res = (res & 0x3333333333333333U) + ((res >> 2) & 0x3333333333333333U);
330  res = (res & 0x0F0F0F0F0F0F0F0FU) + ((res >> 4) & 0x0F0F0F0F0F0F0F0FU);
331  res = (res & 0x00FF00FF00FF00FFU) + ((res >> 8) & 0x00FF00FF00FF00FFU);
332  res = (res & 0x0000FFFF0000FFFFU) + ((res >> 16) & 0x0000FFFF0000FFFFU);
333  return (res & 0x00000000FFFFFFFFU) + ((res >> 32) & 0x00000000FFFFFFFFU);
334 #endif
335 }
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
#define U(x)
Definition: wordpad.c:44
static unsigned long hweight32(unsigned long w)
Definition: bitops.h:313
ULONG64 u64
Definition: btrfs.h:15
GLuint res
Definition: glext.h:9613

Referenced by hweight_long().

◆ hweight_long()

static unsigned long hweight_long ( unsigned long  w)
inlinestatic

Definition at line 337 of file bitops.h.

338 {
339  return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
340 }
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
static unsigned long hweight64(__u64 w)
Definition: bitops.h:322
static unsigned long hweight32(unsigned long w)
Definition: bitops.h:313

◆ rol32()

static __u32 rol32 ( __u32  word,
unsigned int  shift 
)
inlinestatic

rol32 - rotate a 32-bit value left @word: value to rotate @shift: bits to roll

Definition at line 286 of file bitops.h.

287 {
288  return (word << shift) | (word >> (32 - shift));
289 }
#define shift
Definition: input.c:1761
const WCHAR * word
Definition: lex.c:36

◆ ror32()

static __u32 ror32 ( __u32  word,
unsigned int  shift 
)
inlinestatic

ror32 - rotate a 32-bit value right @word: value to rotate @shift: bits to roll

Definition at line 296 of file bitops.h.

297 {
298  return (word >> shift) | (word << (32 - shift));
299 }
#define shift
Definition: input.c:1761
const WCHAR * word
Definition: lex.c:36