1 /* $Id: bitops.h,v 1.31 2000/09/23 02:09:21 davem Exp $
2 * bitops.h: Bit string operations on the V9.
3 *
4 * Copyright 1996, 1997 David S. Miller (davem@caip.rutgers.edu)
5 */
6
7 #ifndef _SPARC64_BITOPS_H
8 #define _SPARC64_BITOPS_H
9
10 #include <asm/byteorder.h>
11
12 extern long __test_and_set_bit(unsigned long nr, volatile void *addr);
13 extern long __test_and_clear_bit(unsigned long nr, volatile void *addr);
14 extern long __test_and_change_bit(unsigned long nr, volatile void *addr);
15
16 #define test_and_set_bit(nr,addr) (__test_and_set_bit(nr,addr)!=0)
17 #define test_and_clear_bit(nr,addr) (__test_and_clear_bit(nr,addr)!=0)
18 #define test_and_change_bit(nr,addr) (__test_and_change_bit(nr,addr)!=0)
19 #define set_bit(nr,addr) ((void)__test_and_set_bit(nr,addr))
20 #define clear_bit(nr,addr) ((void)__test_and_clear_bit(nr,addr))
21 #define change_bit(nr,addr) ((void)__test_and_change_bit(nr,addr))
22
23 #define smp_mb__before_clear_bit() do { } while(0)
24 #define smp_mb__after_clear_bit() do { } while(0)
25
26 extern __inline__ int test_bit(int nr, __const__ void *addr)
27 {
28 return (1UL & (((__const__ long *) addr)[nr >> 6] >> (nr & 63))) != 0UL;
29 }
30
31 /* The easy/cheese version for now. */
32 extern __inline__ unsigned long ffz(unsigned long word)
33 {
34 unsigned long result;
35
36 #ifdef ULTRA_HAS_POPULATION_COUNT /* Thanks for nothing Sun... */
37 __asm__ __volatile__("
38 brz,pn %0, 1f
39 neg %0, %%g1
40 xnor %0, %%g1, %%g2
41 popc %%g2, %0
42 1: " : "=&r" (result)
43 : "" (word)
44 : "g1", "g2");
45 #else
46 #if 1 /* def EASY_CHEESE_VERSION */
47 result = 0;
48 while(word & 1) {
49 result++;
50 word >>= 1;
51 }
52 #else
53 unsigned long tmp;
54
55 result = 0;
56 tmp = ~word & -~word;
57 if (!(unsigned)tmp) {
58 tmp >>= 32;
59 result = 32;
60 }
61 if (!(unsigned short)tmp) {
62 tmp >>= 16;
63 result += 16;
64 }
65 if (!(unsigned char)tmp) {
66 tmp >>= 8;
67 result += 8;
68 }
69 if (tmp & 0xf0) result += 4;
70 if (tmp & 0xcc) result += 2;
71 if (tmp & 0xaa) result ++;
72 #endif
73 #endif
74 return result;
75 }
76
77 #ifdef __KERNEL__
78
79 /*
80 * ffs: find first bit set. This is defined the same way as
81 * the libc and compiler builtin ffs routines, therefore
82 * differs in spirit from the above ffz (man ffs).
83 */
84
85 #define ffs(x) generic_ffs(x)
86
87 /*
88 * hweightN: returns the hamming weight (i.e. the number
89 * of bits set) of a N-bit word
90 */
91
92 #ifdef ULTRA_HAS_POPULATION_COUNT
93
94 extern __inline__ unsigned int hweight32(unsigned int w)
95 {
96 unsigned int res;
97
98 __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xffffffff));
99 return res;
100 }
101
102 extern __inline__ unsigned int hweight16(unsigned int w)
103 {
104 unsigned int res;
105
106 __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xffff));
107 return res;
108 }
109
110 extern __inline__ unsigned int hweight8(unsigned int w)
111 {
112 unsigned int res;
113
114 __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xff));
115 return res;
116 }
117
118 #else
119
120 #define hweight32(x) generic_hweight32(x)
121 #define hweight16(x) generic_hweight16(x)
122 #define hweight8(x) generic_hweight8(x)
123
124 #endif
125 #endif /* __KERNEL__ */
126
127 /* find_next_zero_bit() finds the first zero bit in a bit string of length
128 * 'size' bits, starting the search at bit 'offset'. This is largely based
129 * on Linus's ALPHA routines, which are pretty portable BTW.
130 */
131
132 extern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
133 {
134 unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
135 unsigned long result = offset & ~63UL;
136 unsigned long tmp;
137
138 if (offset >= size)
139 return size;
140 size -= result;
141 offset &= 63UL;
142 if (offset) {
143 tmp = *(p++);
144 tmp |= ~0UL >> (64-offset);
145 if (size < 64)
146 goto found_first;
147 if (~tmp)
148 goto found_middle;
149 size -= 64;
150 result += 64;
151 }
152 while (size & ~63UL) {
153 if (~(tmp = *(p++)))
154 goto found_middle;
155 result += 64;
156 size -= 64;
157 }
158 if (!size)
159 return result;
160 tmp = *p;
161
162 found_first:
163 tmp |= ~0UL << size;
164 if (tmp == ~0UL) /* Are any bits zero? */
165 return result + size; /* Nope. */
166 found_middle:
167 return result + ffz(tmp);
168 }
169
170 #define find_first_zero_bit(addr, size) \
171 find_next_zero_bit((addr), (size), 0)
172
173 extern long __test_and_set_le_bit(int nr, volatile void *addr);
174 extern long __test_and_clear_le_bit(int nr, volatile void *addr);
175
176 #define test_and_set_le_bit(nr,addr) (__test_and_set_le_bit(nr,addr)!=0)
177 #define test_and_clear_le_bit(nr,addr) (__test_and_clear_le_bit(nr,addr)!=0)
178 #define set_le_bit(nr,addr) ((void)__test_and_set_le_bit(nr,addr))
179 #define clear_le_bit(nr,addr) ((void)__test_and_clear_le_bit(nr,addr))
180
181 extern __inline__ int test_le_bit(int nr, __const__ void * addr)
182 {
183 int mask;
184 __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
185
186 ADDR += nr >> 3;
187 mask = 1 << (nr & 0x07);
188 return ((mask & *ADDR) != 0);
189 }
190
191 #define find_first_zero_le_bit(addr, size) \
192 find_next_zero_le_bit((addr), (size), 0)
193
194 extern __inline__ unsigned long find_next_zero_le_bit(void *addr, unsigned long size, unsigned long offset)
195 {
196 unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
197 unsigned long result = offset & ~63UL;
198 unsigned long tmp;
199
200 if (offset >= size)
201 return size;
202 size -= result;
203 offset &= 63UL;
204 if(offset) {
205 tmp = __swab64p(p++);
206 tmp |= (~0UL >> (64-offset));
207 if(size < 64)
208 goto found_first;
209 if(~tmp)
210 goto found_middle;
211 size -= 64;
212 result += 64;
213 }
214 while(size & ~63) {
215 if(~(tmp = __swab64p(p++)))
216 goto found_middle;
217 result += 64;
218 size -= 64;
219 }
220 if(!size)
221 return result;
222 tmp = __swab64p(p);
223 found_first:
224 tmp |= (~0UL << size);
225 if (tmp == ~0UL) /* Are any bits zero? */
226 return result + size; /* Nope. */
227 found_middle:
228 return result + ffz(tmp);
229 }
230
231 #ifdef __KERNEL__
232
233 #define ext2_set_bit test_and_set_le_bit
234 #define ext2_clear_bit test_and_clear_le_bit
235 #define ext2_test_bit test_le_bit
236 #define ext2_find_first_zero_bit find_first_zero_le_bit
237 #define ext2_find_next_zero_bit find_next_zero_le_bit
238
239 /* Bitmap functions for the minix filesystem. */
240 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
241 #define minix_set_bit(nr,addr) set_bit(nr,addr)
242 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
243 #define minix_test_bit(nr,addr) test_bit(nr,addr)
244 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
245
246 #endif /* __KERNEL__ */
247
248 #endif /* defined(_SPARC64_BITOPS_H) */
249
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.