LXR linux/include/asm-x86/bitops

   1#ifndef _I386_BITOPS_H
   2#define _I386_BITOPS_H
   3
   4/*
   5 * Copyright 1992, Linus Torvalds.
   6 */
   7
   8/**
   9 * find_first_zero_bit - find the first zero bit in a memory region
  10 * @addr: The address to start the search at
  11 * @size: The maximum size to search
  12 *
  13 * Returns the bit number of the first zero bit, not the number of the byte
  14 * containing a bit.
  15 */
  16static inline int find_first_zero_bit(const unsigned long *addr, unsigned size)
  17{
  18        int d0, d1, d2;
  19        int res;
  20
  21        if (!size)
  22                return 0;
  23        /* This looks at memory. Mark it volatile to tell gcc not to move it around */
  24        __asm__ __volatile__(
  25                "movl $-1,%%eax\n\t"
  26                "xorl %%edx,%%edx\n\t"
  27                "repe; scasl\n\t"
  28                "je 1f\n\t"
  29                "xorl -4(%%edi),%%eax\n\t"
  30                "subl $4,%%edi\n\t"
  31                "bsfl %%eax,%%edx\n"
  32                "1:\tsubl %%ebx,%%edi\n\t"
  33                "shll $3,%%edi\n\t"
  34                "addl %%edi,%%edx"
  35                :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
  36                :"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory");
  37        return res;
  38}
  39
  40/**
  41 * find_next_zero_bit - find the first zero bit in a memory region
  42 * @addr: The address to base the search on
  43 * @offset: The bit number to start searching at
  44 * @size: The maximum size to search
  45 */
  46int find_next_zero_bit(const unsigned long *addr, int size, int offset);
  47
  48/**
  49 * __ffs - find first bit in word.
  50 * @word: The word to search
  51 *
  52 * Undefined if no bit exists, so code should check against 0 first.
  53 */
  54static inline unsigned long __ffs(unsigned long word)
  55{
  56        __asm__("bsfl %1,%0"
  57                :"=r" (word)
  58                :"rm" (word));
  59        return word;
  60}
  61
  62/**
  63 * find_first_bit - find the first set bit in a memory region
  64 * @addr: The address to start the search at
  65 * @size: The maximum size to search
  66 *
  67 * Returns the bit number of the first set bit, not the number of the byte
  68 * containing a bit.
  69 */
  70static inline unsigned find_first_bit(const unsigned long *addr, unsigned size)
  71{
  72        unsigned x = 0;
  73
  74        while (x < size) {
  75                unsigned long val = *addr++;
  76                if (val)
  77                        return __ffs(val) + x;
  78                x += (sizeof(*addr)<<3);
  79        }
  80        return x;
  81}
  82
  83/**
  84 * find_next_bit - find the first set bit in a memory region
  85 * @addr: The address to base the search on
  86 * @offset: The bit number to start searching at
  87 * @size: The maximum size to search
  88 */
  89int find_next_bit(const unsigned long *addr, int size, int offset);
  90
  91/**
  92 * ffz - find first zero in word.
  93 * @word: The word to search
  94 *
  95 * Undefined if no zero exists, so code should check against ~0UL first.
  96 */
  97static inline unsigned long ffz(unsigned long word)
  98{
  99        __asm__("bsfl %1,%0"
 100                :"=r" (word)
 101                :"r" (~word));
 102        return word;
 103}
 104
 105#ifdef __KERNEL__
 106
 107#include <asm-generic/bitops/sched.h>
 108
 109/**
 110 * ffs - find first bit set
 111 * @x: the word to search
 112 *
 113 * This is defined the same way as
 114 * the libc and compiler builtin ffs routines, therefore
 115 * differs in spirit from the above ffz() (man ffs).
 116 */
 117static inline int ffs(int x)
 118{
 119        int r;
 120
 121        __asm__("bsfl %1,%0\n\t"
 122                "jnz 1f\n\t"
 123                "movl $-1,%0\n"
 124                "1:" : "=r" (r) : "rm" (x));
 125        return r+1;
 126}
 127
 128/**
 129 * fls - find last bit set
 130 * @x: the word to search
 131 *
 132 * This is defined the same way as ffs().
 133 */
 134static inline int fls(int x)
 135{
 136        int r;
 137
 138        __asm__("bsrl %1,%0\n\t"
 139                "jnz 1f\n\t"
 140                "movl $-1,%0\n"
 141                "1:" : "=r" (r) : "rm" (x));
 142        return r+1;
 143}
 144
 145#include <asm-generic/bitops/hweight.h>
 146
 147#endif /* __KERNEL__ */
 148
 149#include <asm-generic/bitops/fls64.h>
 150
 151#ifdef __KERNEL__
 152
 153#include <asm-generic/bitops/ext2-non-atomic.h>
 154
 155#define ext2_set_bit_atomic(lock, nr, addr) \
 156                test_and_set_bit((nr), (unsigned long *)addr)
 157#define ext2_clear_bit_atomic(lock, nr, addr) \
 158                test_and_clear_bit((nr), (unsigned long *)addr)
 159
 160#include <asm-generic/bitops/minix.h>
 161
 162#endif /* __KERNEL__ */
 163
 164#endif /* _I386_BITOPS_H */
 165