diff options
-rw-r--r-- | drivers/staging/lttng/lib/bitfield.h | 400 |
1 files changed, 400 insertions, 0 deletions
diff --git a/drivers/staging/lttng/lib/bitfield.h b/drivers/staging/lttng/lib/bitfield.h new file mode 100644 index 00000000000..861e6dcd810 --- /dev/null +++ b/drivers/staging/lttng/lib/bitfield.h | |||
@@ -0,0 +1,400 @@ | |||
1 | #ifndef _BABELTRACE_BITFIELD_H | ||
2 | #define _BABELTRACE_BITFIELD_H | ||
3 | |||
4 | /* | ||
5 | * BabelTrace | ||
6 | * | ||
7 | * Bitfields read/write functions. | ||
8 | * | ||
9 | * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com> | ||
10 | * | ||
11 | * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
12 | * of this software and associated documentation files (the "Software"), to deal | ||
13 | * in the Software without restriction, including without limitation the rights | ||
14 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
15 | * copies of the Software, and to permit persons to whom the Software is | ||
16 | * furnished to do so, subject to the following conditions: | ||
17 | * | ||
18 | * The above copyright notice and this permission notice shall be included in | ||
19 | * all copies or substantial portions of the Software. | ||
20 | */ | ||
21 | |||
22 | #include "../ltt-endian.h" | ||
23 | |||
24 | #ifndef CHAR_BIT | ||
25 | #define CHAR_BIT 8 | ||
26 | #endif | ||
27 | |||
28 | /* We can't shift a int from 32 bit, >> 32 and << 32 on int is undefined */ | ||
29 | #define _bt_piecewise_rshift(_v, _shift) \ | ||
30 | ({ \ | ||
31 | typeof(_v) ___v = (_v); \ | ||
32 | typeof(_shift) ___shift = (_shift); \ | ||
33 | unsigned long sb = (___shift) / (sizeof(___v) * CHAR_BIT - 1); \ | ||
34 | unsigned long final = (___shift) % (sizeof(___v) * CHAR_BIT - 1); \ | ||
35 | \ | ||
36 | for (; sb; sb--) \ | ||
37 | ___v >>= sizeof(___v) * CHAR_BIT - 1; \ | ||
38 | ___v >>= final; \ | ||
39 | }) | ||
40 | |||
41 | #define _bt_piecewise_lshift(_v, _shift) \ | ||
42 | ({ \ | ||
43 | typeof(_v) ___v = (_v); \ | ||
44 | typeof(_shift) ___shift = (_shift); \ | ||
45 | unsigned long sb = (___shift) / (sizeof(___v) * CHAR_BIT - 1); \ | ||
46 | unsigned long final = (___shift) % (sizeof(___v) * CHAR_BIT - 1); \ | ||
47 | \ | ||
48 | for (; sb; sb--) \ | ||
49 | ___v <<= sizeof(___v) * CHAR_BIT - 1; \ | ||
50 | ___v <<= final; \ | ||
51 | }) | ||
52 | |||
53 | #define _bt_is_signed_type(type) (((type)(-1)) < 0) | ||
54 | |||
55 | #define _bt_unsigned_cast(type, v) \ | ||
56 | ({ \ | ||
57 | (sizeof(v) < sizeof(type)) ? \ | ||
58 | ((type) (v)) & (~(~(type) 0 << (sizeof(v) * CHAR_BIT))) : \ | ||
59 | (type) (v); \ | ||
60 | }) | ||
61 | |||
62 | /* | ||
63 | * bt_bitfield_write - write integer to a bitfield in native endianness | ||
64 | * | ||
65 | * Save integer to the bitfield, which starts at the "start" bit, has "len" | ||
66 | * bits. | ||
67 | * The inside of a bitfield is from high bits to low bits. | ||
68 | * Uses native endianness. | ||
69 | * For unsigned "v", pad MSB with 0 if bitfield is larger than v. | ||
70 | * For signed "v", sign-extend v if bitfield is larger than v. | ||
71 | * | ||
72 | * On little endian, bytes are placed from the less significant to the most | ||
73 | * significant. Also, consecutive bitfields are placed from lower bits to higher | ||
74 | * bits. | ||
75 | * | ||
76 | * On big endian, bytes are places from most significant to less significant. | ||
77 | * Also, consecutive bitfields are placed from higher to lower bits. | ||
78 | */ | ||
79 | |||
80 | #define _bt_bitfield_write_le(_ptr, type, _start, _length, _v) \ | ||
81 | do { \ | ||
82 | typeof(_v) __v = (_v); \ | ||
83 | type *__ptr = (void *) (_ptr); \ | ||
84 | unsigned long __start = (_start), __length = (_length); \ | ||
85 | type mask, cmask; \ | ||
86 | unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ | ||
87 | unsigned long start_unit, end_unit, this_unit; \ | ||
88 | unsigned long end, cshift; /* cshift is "complement shift" */ \ | ||
89 | \ | ||
90 | if (!__length) \ | ||
91 | break; \ | ||
92 | \ | ||
93 | end = __start + __length; \ | ||
94 | start_unit = __start / ts; \ | ||
95 | end_unit = (end + (ts - 1)) / ts; \ | ||
96 | \ | ||
97 | /* Trim v high bits */ \ | ||
98 | if (__length < sizeof(__v) * CHAR_BIT) \ | ||
99 | __v &= ~((~(typeof(__v)) 0) << __length); \ | ||
100 | \ | ||
101 | /* We can now append v with a simple "or", shift it piece-wise */ \ | ||
102 | this_unit = start_unit; \ | ||
103 | if (start_unit == end_unit - 1) { \ | ||
104 | mask = ~((~(type) 0) << (__start % ts)); \ | ||
105 | if (end % ts) \ | ||
106 | mask |= (~(type) 0) << (end % ts); \ | ||
107 | cmask = (type) __v << (__start % ts); \ | ||
108 | cmask &= ~mask; \ | ||
109 | __ptr[this_unit] &= mask; \ | ||
110 | __ptr[this_unit] |= cmask; \ | ||
111 | break; \ | ||
112 | } \ | ||
113 | if (__start % ts) { \ | ||
114 | cshift = __start % ts; \ | ||
115 | mask = ~((~(type) 0) << cshift); \ | ||
116 | cmask = (type) __v << cshift; \ | ||
117 | cmask &= ~mask; \ | ||
118 | __ptr[this_unit] &= mask; \ | ||
119 | __ptr[this_unit] |= cmask; \ | ||
120 | __v = _bt_piecewise_rshift(__v, ts - cshift); \ | ||
121 | __start += ts - cshift; \ | ||
122 | this_unit++; \ | ||
123 | } \ | ||
124 | for (; this_unit < end_unit - 1; this_unit++) { \ | ||
125 | __ptr[this_unit] = (type) __v; \ | ||
126 | __v = _bt_piecewise_rshift(__v, ts); \ | ||
127 | __start += ts; \ | ||
128 | } \ | ||
129 | if (end % ts) { \ | ||
130 | mask = (~(type) 0) << (end % ts); \ | ||
131 | cmask = (type) __v; \ | ||
132 | cmask &= ~mask; \ | ||
133 | __ptr[this_unit] &= mask; \ | ||
134 | __ptr[this_unit] |= cmask; \ | ||
135 | } else \ | ||
136 | __ptr[this_unit] = (type) __v; \ | ||
137 | } while (0) | ||
138 | |||
139 | #define _bt_bitfield_write_be(_ptr, type, _start, _length, _v) \ | ||
140 | do { \ | ||
141 | typeof(_v) __v = (_v); \ | ||
142 | type *__ptr = (void *) (_ptr); \ | ||
143 | unsigned long __start = (_start), __length = (_length); \ | ||
144 | type mask, cmask; \ | ||
145 | unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ | ||
146 | unsigned long start_unit, end_unit, this_unit; \ | ||
147 | unsigned long end, cshift; /* cshift is "complement shift" */ \ | ||
148 | \ | ||
149 | if (!__length) \ | ||
150 | break; \ | ||
151 | \ | ||
152 | end = __start + __length; \ | ||
153 | start_unit = __start / ts; \ | ||
154 | end_unit = (end + (ts - 1)) / ts; \ | ||
155 | \ | ||
156 | /* Trim v high bits */ \ | ||
157 | if (__length < sizeof(__v) * CHAR_BIT) \ | ||
158 | __v &= ~((~(typeof(__v)) 0) << __length); \ | ||
159 | \ | ||
160 | /* We can now append v with a simple "or", shift it piece-wise */ \ | ||
161 | this_unit = end_unit - 1; \ | ||
162 | if (start_unit == end_unit - 1) { \ | ||
163 | mask = ~((~(type) 0) << ((ts - (end % ts)) % ts)); \ | ||
164 | if (__start % ts) \ | ||
165 | mask |= (~((type) 0)) << (ts - (__start % ts)); \ | ||
166 | cmask = (type) __v << ((ts - (end % ts)) % ts); \ | ||
167 | cmask &= ~mask; \ | ||
168 | __ptr[this_unit] &= mask; \ | ||
169 | __ptr[this_unit] |= cmask; \ | ||
170 | break; \ | ||
171 | } \ | ||
172 | if (end % ts) { \ | ||
173 | cshift = end % ts; \ | ||
174 | mask = ~((~(type) 0) << (ts - cshift)); \ | ||
175 | cmask = (type) __v << (ts - cshift); \ | ||
176 | cmask &= ~mask; \ | ||
177 | __ptr[this_unit] &= mask; \ | ||
178 | __ptr[this_unit] |= cmask; \ | ||
179 | __v = _bt_piecewise_rshift(__v, cshift); \ | ||
180 | end -= cshift; \ | ||
181 | this_unit--; \ | ||
182 | } \ | ||
183 | for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \ | ||
184 | __ptr[this_unit] = (type) __v; \ | ||
185 | __v = _bt_piecewise_rshift(__v, ts); \ | ||
186 | end -= ts; \ | ||
187 | } \ | ||
188 | if (__start % ts) { \ | ||
189 | mask = (~(type) 0) << (ts - (__start % ts)); \ | ||
190 | cmask = (type) __v; \ | ||
191 | cmask &= ~mask; \ | ||
192 | __ptr[this_unit] &= mask; \ | ||
193 | __ptr[this_unit] |= cmask; \ | ||
194 | } else \ | ||
195 | __ptr[this_unit] = (type) __v; \ | ||
196 | } while (0) | ||
197 | |||
198 | /* | ||
199 | * bt_bitfield_write - write integer to a bitfield in native endianness | ||
200 | * bt_bitfield_write_le - write integer to a bitfield in little endian | ||
201 | * bt_bitfield_write_be - write integer to a bitfield in big endian | ||
202 | */ | ||
203 | |||
204 | #if (__BYTE_ORDER == __LITTLE_ENDIAN) | ||
205 | |||
206 | #define bt_bitfield_write(ptr, type, _start, _length, _v) \ | ||
207 | _bt_bitfield_write_le(ptr, type, _start, _length, _v) | ||
208 | |||
209 | #define bt_bitfield_write_le(ptr, type, _start, _length, _v) \ | ||
210 | _bt_bitfield_write_le(ptr, type, _start, _length, _v) | ||
211 | |||
212 | #define bt_bitfield_write_be(ptr, type, _start, _length, _v) \ | ||
213 | _bt_bitfield_write_be(ptr, unsigned char, _start, _length, _v) | ||
214 | |||
215 | #elif (__BYTE_ORDER == __BIG_ENDIAN) | ||
216 | |||
217 | #define bt_bitfield_write(ptr, type, _start, _length, _v) \ | ||
218 | _bt_bitfield_write_be(ptr, type, _start, _length, _v) | ||
219 | |||
220 | #define bt_bitfield_write_le(ptr, type, _start, _length, _v) \ | ||
221 | _bt_bitfield_write_le(ptr, unsigned char, _start, _length, _v) | ||
222 | |||
223 | #define bt_bitfield_write_be(ptr, type, _start, _length, _v) \ | ||
224 | _bt_bitfield_write_be(ptr, type, _start, _length, _v) | ||
225 | |||
226 | #else /* (BYTE_ORDER == PDP_ENDIAN) */ | ||
227 | |||
228 | #error "Byte order not supported" | ||
229 | |||
230 | #endif | ||
231 | |||
232 | #define _bt_bitfield_read_le(_ptr, type, _start, _length, _vptr) \ | ||
233 | do { \ | ||
234 | typeof(*(_vptr)) *__vptr = (_vptr); \ | ||
235 | typeof(*__vptr) __v; \ | ||
236 | type *__ptr = (void *) (_ptr); \ | ||
237 | unsigned long __start = (_start), __length = (_length); \ | ||
238 | type mask, cmask; \ | ||
239 | unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ | ||
240 | unsigned long start_unit, end_unit, this_unit; \ | ||
241 | unsigned long end, cshift; /* cshift is "complement shift" */ \ | ||
242 | \ | ||
243 | if (!__length) { \ | ||
244 | *__vptr = 0; \ | ||
245 | break; \ | ||
246 | } \ | ||
247 | \ | ||
248 | end = __start + __length; \ | ||
249 | start_unit = __start / ts; \ | ||
250 | end_unit = (end + (ts - 1)) / ts; \ | ||
251 | \ | ||
252 | this_unit = end_unit - 1; \ | ||
253 | if (_bt_is_signed_type(typeof(__v)) \ | ||
254 | && (__ptr[this_unit] & ((type) 1 << ((end % ts ? : ts) - 1)))) \ | ||
255 | __v = ~(typeof(__v)) 0; \ | ||
256 | else \ | ||
257 | __v = 0; \ | ||
258 | if (start_unit == end_unit - 1) { \ | ||
259 | cmask = __ptr[this_unit]; \ | ||
260 | cmask >>= (__start % ts); \ | ||
261 | if ((end - __start) % ts) { \ | ||
262 | mask = ~((~(type) 0) << (end - __start)); \ | ||
263 | cmask &= mask; \ | ||
264 | } \ | ||
265 | __v = _bt_piecewise_lshift(__v, end - __start); \ | ||
266 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
267 | *__vptr = __v; \ | ||
268 | break; \ | ||
269 | } \ | ||
270 | if (end % ts) { \ | ||
271 | cshift = end % ts; \ | ||
272 | mask = ~((~(type) 0) << cshift); \ | ||
273 | cmask = __ptr[this_unit]; \ | ||
274 | cmask &= mask; \ | ||
275 | __v = _bt_piecewise_lshift(__v, cshift); \ | ||
276 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
277 | end -= cshift; \ | ||
278 | this_unit--; \ | ||
279 | } \ | ||
280 | for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \ | ||
281 | __v = _bt_piecewise_lshift(__v, ts); \ | ||
282 | __v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\ | ||
283 | end -= ts; \ | ||
284 | } \ | ||
285 | if (__start % ts) { \ | ||
286 | mask = ~((~(type) 0) << (ts - (__start % ts))); \ | ||
287 | cmask = __ptr[this_unit]; \ | ||
288 | cmask >>= (__start % ts); \ | ||
289 | cmask &= mask; \ | ||
290 | __v = _bt_piecewise_lshift(__v, ts - (__start % ts)); \ | ||
291 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
292 | } else { \ | ||
293 | __v = _bt_piecewise_lshift(__v, ts); \ | ||
294 | __v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\ | ||
295 | } \ | ||
296 | *__vptr = __v; \ | ||
297 | } while (0) | ||
298 | |||
299 | #define _bt_bitfield_read_be(_ptr, type, _start, _length, _vptr) \ | ||
300 | do { \ | ||
301 | typeof(*(_vptr)) *__vptr = (_vptr); \ | ||
302 | typeof(*__vptr) __v; \ | ||
303 | type *__ptr = (void *) (_ptr); \ | ||
304 | unsigned long __start = (_start), __length = (_length); \ | ||
305 | type mask, cmask; \ | ||
306 | unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ | ||
307 | unsigned long start_unit, end_unit, this_unit; \ | ||
308 | unsigned long end, cshift; /* cshift is "complement shift" */ \ | ||
309 | \ | ||
310 | if (!__length) { \ | ||
311 | *__vptr = 0; \ | ||
312 | break; \ | ||
313 | } \ | ||
314 | \ | ||
315 | end = __start + __length; \ | ||
316 | start_unit = __start / ts; \ | ||
317 | end_unit = (end + (ts - 1)) / ts; \ | ||
318 | \ | ||
319 | this_unit = start_unit; \ | ||
320 | if (_bt_is_signed_type(typeof(__v)) \ | ||
321 | && (__ptr[this_unit] & ((type) 1 << (ts - (__start % ts) - 1)))) \ | ||
322 | __v = ~(typeof(__v)) 0; \ | ||
323 | else \ | ||
324 | __v = 0; \ | ||
325 | if (start_unit == end_unit - 1) { \ | ||
326 | cmask = __ptr[this_unit]; \ | ||
327 | cmask >>= (ts - (end % ts)) % ts; \ | ||
328 | if ((end - __start) % ts) { \ | ||
329 | mask = ~((~(type) 0) << (end - __start)); \ | ||
330 | cmask &= mask; \ | ||
331 | } \ | ||
332 | __v = _bt_piecewise_lshift(__v, end - __start); \ | ||
333 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
334 | *__vptr = __v; \ | ||
335 | break; \ | ||
336 | } \ | ||
337 | if (__start % ts) { \ | ||
338 | cshift = __start % ts; \ | ||
339 | mask = ~((~(type) 0) << (ts - cshift)); \ | ||
340 | cmask = __ptr[this_unit]; \ | ||
341 | cmask &= mask; \ | ||
342 | __v = _bt_piecewise_lshift(__v, ts - cshift); \ | ||
343 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
344 | __start += ts - cshift; \ | ||
345 | this_unit++; \ | ||
346 | } \ | ||
347 | for (; this_unit < end_unit - 1; this_unit++) { \ | ||
348 | __v = _bt_piecewise_lshift(__v, ts); \ | ||
349 | __v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\ | ||
350 | __start += ts; \ | ||
351 | } \ | ||
352 | if (end % ts) { \ | ||
353 | mask = ~((~(type) 0) << (end % ts)); \ | ||
354 | cmask = __ptr[this_unit]; \ | ||
355 | cmask >>= ts - (end % ts); \ | ||
356 | cmask &= mask; \ | ||
357 | __v = _bt_piecewise_lshift(__v, end % ts); \ | ||
358 | __v |= _bt_unsigned_cast(typeof(__v), cmask); \ | ||
359 | } else { \ | ||
360 | __v = _bt_piecewise_lshift(__v, ts); \ | ||
361 | __v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\ | ||
362 | } \ | ||
363 | *__vptr = __v; \ | ||
364 | } while (0) | ||
365 | |||
366 | /* | ||
367 | * bt_bitfield_read - read integer from a bitfield in native endianness | ||
368 | * bt_bitfield_read_le - read integer from a bitfield in little endian | ||
369 | * bt_bitfield_read_be - read integer from a bitfield in big endian | ||
370 | */ | ||
371 | |||
372 | #if (__BYTE_ORDER == __LITTLE_ENDIAN) | ||
373 | |||
374 | #define bt_bitfield_read(_ptr, type, _start, _length, _vptr) \ | ||
375 | _bt_bitfield_read_le(_ptr, type, _start, _length, _vptr) | ||
376 | |||
377 | #define bt_bitfield_read_le(_ptr, type, _start, _length, _vptr) \ | ||
378 | _bt_bitfield_read_le(_ptr, type, _start, _length, _vptr) | ||
379 | |||
380 | #define bt_bitfield_read_be(_ptr, type, _start, _length, _vptr) \ | ||
381 | _bt_bitfield_read_be(_ptr, unsigned char, _start, _length, _vptr) | ||
382 | |||
383 | #elif (__BYTE_ORDER == __BIG_ENDIAN) | ||
384 | |||
385 | #define bt_bitfield_read(_ptr, type, _start, _length, _vptr) \ | ||
386 | _bt_bitfield_read_be(_ptr, type, _start, _length, _vptr) | ||
387 | |||
388 | #define bt_bitfield_read_le(_ptr, type, _start, _length, _vptr) \ | ||
389 | _bt_bitfield_read_le(_ptr, unsigned char, _start, _length, _vptr) | ||
390 | |||
391 | #define bt_bitfield_read_be(_ptr, type, _start, _length, _vptr) \ | ||
392 | _bt_bitfield_read_be(_ptr, type, _start, _length, _vptr) | ||
393 | |||
394 | #else /* (__BYTE_ORDER == __PDP_ENDIAN) */ | ||
395 | |||
396 | #error "Byte order not supported" | ||
397 | |||
398 | #endif | ||
399 | |||
400 | #endif /* _BABELTRACE_BITFIELD_H */ | ||