[lttng-tools.git] / src / common / bitfield.h

#ifndef _LTTNG_BITFIELD_H
#define _LTTNG_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.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <assert.h>
#include <stdint.h>	/* C99 5.2.4.2 Numerical limits */
#include <limits.h>	/* C99 5.2.4.2 Numerical limits */

#include <common/compat/endian.h>	/* Non-standard BIG_ENDIAN, LITTLE_ENDIAN, BYTE_ORDER */

/* We can't shift a int from 32 bit, >> 32 and << 32 on int is undefined */
#define _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 _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 _is_signed_type(type)	((type) -1 < (type) 0)

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

/*
 * 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 _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 = _piecewise_rshift(__v, ts - cshift);		\
		__start += ts - cshift;					\
		this_unit++;						\
	}								\
	for (; this_unit < end_unit - 1; this_unit++) {			\
		__ptr[this_unit] = (type) __v;				\
		__v = _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 _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 = _piecewise_rshift(__v, cshift);		\
		end -= cshift;						\
		this_unit--;						\
	}								\
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		__ptr[this_unit] = (type) __v;				\
		__v = _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)

/*
 * bitfield_write - write integer to a bitfield in native endianness
 * bitfield_write_le - write integer to a bitfield in little endian
 * bitfield_write_be - write integer to a bitfield in big endian
 */

#if (BYTE_ORDER == LITTLE_ENDIAN)

#define bitfield_write(ptr, type, _start, _length, _v)		\
	_bitfield_write_le(ptr, type, _start, _length, _v)

#define bitfield_write_le(ptr, type, _start, _length, _v)		\
	_bitfield_write_le(ptr, type, _start, _length, _v)

#define bitfield_write_be(ptr, type, _start, _length, _v)		\
	_bitfield_write_be(ptr, unsigned char, _start, _length, _v)

#elif (BYTE_ORDER == BIG_ENDIAN)

#define bitfield_write(ptr, type, _start, _length, _v)		\
	_bitfield_write_be(ptr, type, _start, _length, _v)

#define bitfield_write_le(ptr, type, _start, _length, _v)		\
	_bitfield_write_le(ptr, unsigned char, _start, _length, _v)

#define bitfield_write_be(ptr, type, _start, _length, _v)		\
	_bitfield_write_be(ptr, type, _start, _length, _v)

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

#error "Byte order not supported"

#endif

#define _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 (_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 = _piecewise_lshift(__v, end - __start);		\
		__v |= _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 = _piecewise_lshift(__v, cshift);		\
		__v |= _unsigned_cast(typeof(__v), cmask);		\
		end -= cshift;						\
		this_unit--;						\
	}								\
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		__v = _piecewise_lshift(__v, ts);			\
		__v |= _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 = _piecewise_lshift(__v, ts - (__start % ts));	\
		__v |= _unsigned_cast(typeof(__v), cmask);		\
	} else {							\
		__v = _piecewise_lshift(__v, ts);			\
		__v |= _unsigned_cast(typeof(__v), __ptr[this_unit]);\
	}								\
	*__vptr = __v;							\
} while (0)

#define _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 (_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 = _piecewise_lshift(__v, end - __start);		\
		__v |= _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 = _piecewise_lshift(__v, ts - cshift);		\
		__v |= _unsigned_cast(typeof(__v), cmask);		\
		__start += ts - cshift;					\
		this_unit++;						\
	}								\
	for (; this_unit < end_unit - 1; this_unit++) {			\
		__v = _piecewise_lshift(__v, ts);			\
		__v |= _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 = _piecewise_lshift(__v, end % ts);		\
		__v |= _unsigned_cast(typeof(__v), cmask);		\
	} else {							\
		__v = _piecewise_lshift(__v, ts);			\
		__v |= _unsigned_cast(typeof(__v), __ptr[this_unit]);\
	}								\
	*__vptr = __v;							\
} while (0)

/*
 * bitfield_read - read integer from a bitfield in native endianness
 * bitfield_read_le - read integer from a bitfield in little endian
 * bitfield_read_be - read integer from a bitfield in big endian
 */

#if (BYTE_ORDER == LITTLE_ENDIAN)

#define bitfield_read(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_le(_ptr, type, _start, _length, _vptr)

#define bitfield_read_le(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_le(_ptr, type, _start, _length, _vptr)

#define bitfield_read_be(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_be(_ptr, unsigned char, _start, _length, _vptr)

#elif (BYTE_ORDER == BIG_ENDIAN)

#define bitfield_read(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_be(_ptr, type, _start, _length, _vptr)

#define bitfield_read_le(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_le(_ptr, unsigned char, _start, _length, _vptr)

#define bitfield_read_be(_ptr, type, _start, _length, _vptr)		\
	_bitfield_read_be(_ptr, type, _start, _length, _vptr)

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

#error "Byte order not supported"

#endif

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