[deliverable/lttng-modules.git] / lib / bitfield.h

#ifndef _BABELTRACE_BITFIELD_H
#define _BABELTRACE_BITFIELD_H

/*
 * BabelTrace
 *
 * Bitfields read/write functions.
 *
 * Copyright 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 */

#include "../lttng-endian.h"

#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif

/* We can't shift a int from 32 bit, >> 32 and << 32 on int is undefined */
#define _bt_piecewise_rshift(_v, _shift)				\
({									\
	typeof(_v) ___v = (_v);						\
	typeof(_shift) ___shift = (_shift);				\
	unsigned long sb = (___shift) / (sizeof(___v) * CHAR_BIT - 1);	\
	unsigned long final = (___shift) % (sizeof(___v) * CHAR_BIT - 1); \
									\
	for (; sb; sb--)						\
		___v >>= sizeof(___v) * CHAR_BIT - 1;			\
	___v >>= final;							\
})

#define _bt_piecewise_lshift(_v, _shift)				\
({									\
	typeof(_v) ___v = (_v);						\
	typeof(_shift) ___shift = (_shift);				\
	unsigned long sb = (___shift) / (sizeof(___v) * CHAR_BIT - 1);	\
	unsigned long final = (___shift) % (sizeof(___v) * CHAR_BIT - 1); \
									\
	for (; sb; sb--)						\
		___v <<= sizeof(___v) * CHAR_BIT - 1;			\
	___v <<= final;							\
})

#define _bt_is_signed_type(type)	(((type)(-1)) < 0)

#define _bt_unsigned_cast(type, v)					\
({									\
	(sizeof(v) < sizeof(type)) ?					\
		((type) (v)) & (~(~(type) 0 << (sizeof(v) * CHAR_BIT))) : \
		(type) (v);						\
})

/*
 * bt_bitfield_write - write integer to a bitfield in native endianness
 *
 * Save integer to the bitfield, which starts at the "start" bit, has "len"
 * bits.
 * The inside of a bitfield is from high bits to low bits.
 * Uses native endianness.
 * For unsigned "v", pad MSB with 0 if bitfield is larger than v.
 * For signed "v", sign-extend v if bitfield is larger than v.
 *
 * On little endian, bytes are placed from the less significant to the most
 * significant. Also, consecutive bitfields are placed from lower bits to higher
 * bits.
 *
 * On big endian, bytes are places from most significant to less significant.
 * Also, consecutive bitfields are placed from higher to lower bits.
 */

#define _bt_bitfield_write_le(_ptr, type, _start, _length, _v)		\
do {									\
	typeof(_v) __v = (_v);						\
	type *__ptr = (void *) (_ptr);					\
	unsigned long __start = (_start), __length = (_length);		\
	type mask, cmask;						\
	unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */	\
	unsigned long start_unit, end_unit, this_unit;			\
	unsigned long end, cshift; /* cshift is "complement shift" */	\
									\
	if (!__length)							\
		break;							\
									\
	end = __start + __length;					\
	start_unit = __start / ts;					\
	end_unit = (end + (ts - 1)) / ts;				\
									\
	/* Trim v high bits */						\
	if (__length < sizeof(__v) * CHAR_BIT)				\
		__v &= ~((~(typeof(__v)) 0) << __length);		\
									\
	/* We can now append v with a simple "or", shift it piece-wise */ \
	this_unit = start_unit;						\
	if (start_unit == end_unit - 1) {				\
		mask = ~((~(type) 0) << (__start % ts));		\
		if (end % ts)						\
			mask |= (~(type) 0) << (end % ts);		\
		cmask = (type) __v << (__start % ts);			\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
		break;							\
	}								\
	if (__start % ts) {						\
		cshift = __start % ts;					\
		mask = ~((~(type) 0) << cshift);			\
		cmask = (type) __v << cshift;				\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
		__v = _bt_piecewise_rshift(__v, ts - cshift);		\
		__start += ts - cshift;					\
		this_unit++;						\
	}								\
	for (; this_unit < end_unit - 1; this_unit++) {			\
		__ptr[this_unit] = (type) __v;				\
		__v = _bt_piecewise_rshift(__v, ts);			\
		__start += ts;						\
	}								\
	if (end % ts) {							\
		mask = (~(type) 0) << (end % ts);			\
		cmask = (type) __v;					\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
	} else								\
		__ptr[this_unit] = (type) __v;				\
} while (0)

#define _bt_bitfield_write_be(_ptr, type, _start, _length, _v)		\
do {									\
	typeof(_v) __v = (_v);						\
	type *__ptr = (void *) (_ptr);					\
	unsigned long __start = (_start), __length = (_length);		\
	type mask, cmask;						\
	unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */	\
	unsigned long start_unit, end_unit, this_unit;			\
	unsigned long end, cshift; /* cshift is "complement shift" */	\
									\
	if (!__length)							\
		break;							\
									\
	end = __start + __length;					\
	start_unit = __start / ts;					\
	end_unit = (end + (ts - 1)) / ts;				\
									\
	/* Trim v high bits */						\
	if (__length < sizeof(__v) * CHAR_BIT)				\
		__v &= ~((~(typeof(__v)) 0) << __length);		\
									\
	/* We can now append v with a simple "or", shift it piece-wise */ \
	this_unit = end_unit - 1;					\
	if (start_unit == end_unit - 1) {				\
		mask = ~((~(type) 0) << ((ts - (end % ts)) % ts));	\
		if (__start % ts)					\
			mask |= (~((type) 0)) << (ts - (__start % ts));	\
		cmask = (type) __v << ((ts - (end % ts)) % ts);		\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
		break;							\
	}								\
	if (end % ts) {							\
		cshift = end % ts;					\
		mask = ~((~(type) 0) << (ts - cshift));			\
		cmask = (type) __v << (ts - cshift);			\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
		__v = _bt_piecewise_rshift(__v, cshift);		\
		end -= cshift;						\
		this_unit--;						\
	}								\
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		__ptr[this_unit] = (type) __v;				\
		__v = _bt_piecewise_rshift(__v, ts);			\
		end -= ts;						\
	}								\
	if (__start % ts) {						\
		mask = (~(type) 0) << (ts - (__start % ts));		\
		cmask = (type) __v;					\
		cmask &= ~mask;						\
		__ptr[this_unit] &= mask;				\
		__ptr[this_unit] |= cmask;				\
	} else								\
		__ptr[this_unit] = (type) __v;				\
} while (0)

/*
 * bt_bitfield_write - write integer to a bitfield in native endianness
 * bt_bitfield_write_le - write integer to a bitfield in little endian
 * bt_bitfield_write_be - write integer to a bitfield in big endian
 */

#if (__BYTE_ORDER == __LITTLE_ENDIAN)

#define bt_bitfield_write(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_le(ptr, type, _start, _length, _v)

#define bt_bitfield_write_le(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_le(ptr, type, _start, _length, _v)
	
#define bt_bitfield_write_be(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_be(ptr, unsigned char, _start, _length, _v)

#elif (__BYTE_ORDER == __BIG_ENDIAN)

#define bt_bitfield_write(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_be(ptr, type, _start, _length, _v)

#define bt_bitfield_write_le(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_le(ptr, unsigned char, _start, _length, _v)
	
#define bt_bitfield_write_be(ptr, type, _start, _length, _v)		\
	_bt_bitfield_write_be(ptr, type, _start, _length, _v)

#else /* (BYTE_ORDER == PDP_ENDIAN) */

#error "Byte order not supported"

#endif

#define _bt_bitfield_read_le(_ptr, type, _start, _length, _vptr)	\
do {									\
	typeof(*(_vptr)) *__vptr = (_vptr);				\
	typeof(*__vptr) __v;						\
	type *__ptr = (void *) (_ptr);					\
	unsigned long __start = (_start), __length = (_length);		\
	type mask, cmask;						\
	unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */	\
	unsigned long start_unit, end_unit, this_unit;			\
	unsigned long end, cshift; /* cshift is "complement shift" */	\
									\
	if (!__length) {						\
		*__vptr = 0;						\
		break;							\
	}								\
									\
	end = __start + __length;					\
	start_unit = __start / ts;					\
	end_unit = (end + (ts - 1)) / ts;				\
									\
	this_unit = end_unit - 1;					\
	if (_bt_is_signed_type(typeof(__v))				\
	    && (__ptr[this_unit] & ((type) 1 << ((end % ts ? : ts) - 1)))) \
		__v = ~(typeof(__v)) 0;					\
	else								\
		__v = 0;						\
	if (start_unit == end_unit - 1) {				\
		cmask = __ptr[this_unit];				\
		cmask >>= (__start % ts);				\
		if ((end - __start) % ts) {				\
			mask = ~((~(type) 0) << (end - __start));	\
			cmask &= mask;					\
		}							\
		__v = _bt_piecewise_lshift(__v, end - __start);		\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
		*__vptr = __v;						\
		break;							\
	}								\
	if (end % ts) {							\
		cshift = end % ts;					\
		mask = ~((~(type) 0) << cshift);			\
		cmask = __ptr[this_unit];				\
		cmask &= mask;						\
		__v = _bt_piecewise_lshift(__v, cshift);		\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
		end -= cshift;						\
		this_unit--;						\
	}								\
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		__v = _bt_piecewise_lshift(__v, ts);			\
		__v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\
		end -= ts;						\
	}								\
	if (__start % ts) {						\
		mask = ~((~(type) 0) << (ts - (__start % ts)));		\
		cmask = __ptr[this_unit];				\
		cmask >>= (__start % ts);				\
		cmask &= mask;						\
		__v = _bt_piecewise_lshift(__v, ts - (__start % ts));	\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
	} else {							\
		__v = _bt_piecewise_lshift(__v, ts);			\
		__v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\
	}								\
	*__vptr = __v;							\
} while (0)

#define _bt_bitfield_read_be(_ptr, type, _start, _length, _vptr)	\
do {									\
	typeof(*(_vptr)) *__vptr = (_vptr);				\
	typeof(*__vptr) __v;						\
	type *__ptr = (void *) (_ptr);					\
	unsigned long __start = (_start), __length = (_length);		\
	type mask, cmask;						\
	unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */	\
	unsigned long start_unit, end_unit, this_unit;			\
	unsigned long end, cshift; /* cshift is "complement shift" */	\
									\
	if (!__length) {						\
		*__vptr = 0;						\
		break;							\
	}								\
									\
	end = __start + __length;					\
	start_unit = __start / ts;					\
	end_unit = (end + (ts - 1)) / ts;				\
									\
	this_unit = start_unit;						\
	if (_bt_is_signed_type(typeof(__v))				\
	    && (__ptr[this_unit] & ((type) 1 << (ts - (__start % ts) - 1)))) \
		__v = ~(typeof(__v)) 0;					\
	else								\
		__v = 0;						\
	if (start_unit == end_unit - 1) {				\
		cmask = __ptr[this_unit];				\
		cmask >>= (ts - (end % ts)) % ts;			\
		if ((end - __start) % ts) {				\
			mask = ~((~(type) 0) << (end - __start));	\
			cmask &= mask;					\
		}							\
		__v = _bt_piecewise_lshift(__v, end - __start);		\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
		*__vptr = __v;						\
		break;							\
	}								\
	if (__start % ts) {						\
		cshift = __start % ts;					\
		mask = ~((~(type) 0) << (ts - cshift));			\
		cmask = __ptr[this_unit];				\
		cmask &= mask;						\
		__v = _bt_piecewise_lshift(__v, ts - cshift);		\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
		__start += ts - cshift;					\
		this_unit++;						\
	}								\
	for (; this_unit < end_unit - 1; this_unit++) {			\
		__v = _bt_piecewise_lshift(__v, ts);			\
		__v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\
		__start += ts;						\
	}								\
	if (end % ts) {							\
		mask = ~((~(type) 0) << (end % ts));			\
		cmask = __ptr[this_unit];				\
		cmask >>= ts - (end % ts);				\
		cmask &= mask;						\
		__v = _bt_piecewise_lshift(__v, end % ts);		\
		__v |= _bt_unsigned_cast(typeof(__v), cmask);		\
	} else {							\
		__v = _bt_piecewise_lshift(__v, ts);			\
		__v |= _bt_unsigned_cast(typeof(__v), __ptr[this_unit]);\
	}								\
	*__vptr = __v;							\
} while (0)

/*
 * bt_bitfield_read - read integer from a bitfield in native endianness
 * bt_bitfield_read_le - read integer from a bitfield in little endian
 * bt_bitfield_read_be - read integer from a bitfield in big endian
 */

#if (__BYTE_ORDER == __LITTLE_ENDIAN)

#define bt_bitfield_read(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_le(_ptr, type, _start, _length, _vptr)

#define bt_bitfield_read_le(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_le(_ptr, type, _start, _length, _vptr)
	
#define bt_bitfield_read_be(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_be(_ptr, unsigned char, _start, _length, _vptr)

#elif (__BYTE_ORDER == __BIG_ENDIAN)

#define bt_bitfield_read(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_be(_ptr, type, _start, _length, _vptr)

#define bt_bitfield_read_le(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_le(_ptr, unsigned char, _start, _length, _vptr)
	
#define bt_bitfield_read_be(_ptr, type, _start, _length, _vptr)		\
	_bt_bitfield_read_be(_ptr, type, _start, _length, _vptr)

#else /* (__BYTE_ORDER == __PDP_ENDIAN) */

#error "Byte order not supported"

#endif

#endif /* _BABELTRACE_BITFIELD_H */
Commit	Line	Data
9115fbdc MD	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
a90917c3	22	#include "../lttng-endian.h"
9115fbdc MD	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 */