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