[babeltrace.git] / include / ctf / bitfield.h

#ifndef _CTF_BITFIELD_H
#define _CTF_BITFIELD_H

/*
 * Common Trace Format
 *
 * 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 <stdint.h>	/* C99 5.2.4.2 Numerical limits */
#include <limits.h>	/* C99 5.2.4.2 Numerical limits */
#include <endian.h>	/* Non-standard BIG_ENDIAN, LITTLE_ENDIAN, BYTE_ORDER */
#include <assert.h>

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

#define _ctf_piecewise_lshift(v, shift)					\
({									\
	unsigned long sb = (shift) / (sizeof(v) * CHAR_BIT - 1);	\
	unsigned long final = (shift) % (sizeof(v) * CHAR_BIT - 1);	\
	typeof(v) _v = (v);						\
									\
	for (; sb; sb--)						\
		_v <<= sizeof(v) * CHAR_BIT - 1;			\
	_v <<= final;							\
})

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

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

/*
 * ctf_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 _ctf_bitfield_write_le(ptr, _start, _length, _v)		\
do {									\
	typeof(_v) v = (_v);						\
	typeof(*(ptr)) mask, cmask;					\
	unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \
	unsigned long start = (_start), length = (_length);		\
	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 = ~((~(typeof(*(ptr))) 0) << (start % ts));	\
		if (end % ts)						\
			mask |= (~(typeof(*(ptr))) 0) << (end % ts);	\
		cmask = (typeof(*(ptr))) v << (start % ts);		\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
		break;							\
	}								\
	if (start % ts) {						\
		cshift = start % ts;					\
		mask = ~((~(typeof(*(ptr))) 0) << cshift);		\
		cmask = (typeof(*(ptr))) v << cshift;			\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
		v = _ctf_piecewise_rshift(v, ts - cshift);		\
		start += ts - cshift;					\
		this_unit++;						\
	}								\
	for (; this_unit < end_unit - 1; this_unit++) {			\
		(ptr)[this_unit] = (typeof(*(ptr))) v;			\
		v = _ctf_piecewise_rshift(v, ts);			\
		start += ts;						\
	}								\
	if (end % ts) {							\
		mask = (~(typeof(*(ptr))) 0) << (end % ts);		\
		cmask = (typeof(*(ptr))) v;				\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
	} else								\
		(ptr)[this_unit] = (typeof(*(ptr))) v;			\
} while (0)

#define _ctf_bitfield_write_be(ptr, _start, _length, _v)		\
do {									\
	typeof(_v) v = (_v);						\
	typeof(*(ptr)) mask, cmask;					\
	unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \
	unsigned long start = _start, length = _length;			\
	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 = ~((~(typeof(*(ptr))) 0) << ((ts - (end % ts)) % ts)); \
		if (start % ts)						\
			mask |= (~((typeof(*(ptr))) 0)) << (ts - (start % ts)); \
		cmask = (typeof(*(ptr))) v << ((ts - (end % ts)) % ts);	\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
		break;							\
	}								\
	if (end % ts) {							\
		cshift = end % ts;					\
		mask = ~((~(typeof(*(ptr))) 0) << (ts - cshift));	\
		cmask = (typeof(*(ptr))) v << (ts - cshift);		\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
		v = _ctf_piecewise_rshift(v, cshift);			\
		end -= cshift;						\
		this_unit--;						\
	}								\
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		(ptr)[this_unit] = (typeof(*(ptr))) v;			\
		v = _ctf_piecewise_rshift(v, ts);			\
		end -= ts;						\
	}								\
	if (start % ts) {						\
		mask = (~(typeof(*(ptr))) 0) << (ts - (start % ts));	\
		cmask = (typeof(*(ptr))) v;				\
		cmask &= ~mask;						\
		(ptr)[this_unit] &= mask;				\
		(ptr)[this_unit] |= cmask;				\
	} else								\
		(ptr)[this_unit] = (typeof(*(ptr))) v;			\
} while (0)

/*
 * ctf_bitfield_write - write integer to a bitfield in native endianness
 * ctf_bitfield_write_le - write integer to a bitfield in little endian
 * ctf_bitfield_write_be - write integer to a bitfield in big endian
 */

#if (BYTE_ORDER == LITTLE_ENDIAN)

#define ctf_bitfield_write(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_le(ptr, _start, _length, _v)

#define ctf_bitfield_write_le(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_le(ptr, _start, _length, _v)
	
#define ctf_bitfield_write_be(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_be((uint8_t *) (ptr), _start, _length, _v)

#elif (BYTE_ORDER == BIG_ENDIAN)

#define ctf_bitfield_write(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_be(ptr, _start, _length, _v)

#define ctf_bitfield_write_le(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_le((uint8_t *) (ptr), _start, _length, _v)
	
#define ctf_bitfield_write_be(ptr, _start, _length, _v)			\
	_ctf_bitfield_write_be(ptr, _start, _length, _v)

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

#error "Byte order not supported"

#endif

#define _ctf_bitfield_read_le(ptr, _start, _length, vptr)		\
do {									\
	typeof(*(vptr)) v;						\
	typeof(*(ptr)) mask, cmask;					\
	unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \
	unsigned long start = _start, length = _length;			\
	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 (_ctf_is_signed_type(typeof(v)) \
	    && ((ptr)[this_unit] & ((typeof(*(ptr))) 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 = ~((~(typeof(*(ptr))) 0) << (end - start)); \
			cmask &= mask; \
		} \
		v = _ctf_piecewise_lshift(v, end - start); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
		*(vptr) = v; \
		break; \
	} \
	if (end % ts) { \
		cshift = end % ts; \
		mask = ~((~(typeof(*(ptr))) 0) << cshift); \
		cmask = (ptr)[this_unit]; \
		cmask &= mask; \
		v = _ctf_piecewise_lshift(v, cshift); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
		end -= cshift; \
		this_unit--; \
	} \
	for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \
		v = _ctf_piecewise_lshift(v, ts); \
		v |= _ctf_unsigned_cast(typeof(v), (ptr)[this_unit]); \
		end -= ts; \
	} \
	if (start % ts) { \
		mask = ~((~(typeof(*(ptr))) 0) << (ts - (start % ts))); \
		cmask = (ptr)[this_unit]; \
		cmask >>= (start % ts); \
		cmask &= mask; \
		v = _ctf_piecewise_lshift(v, ts - (start % ts)); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
	} else { \
		v = _ctf_piecewise_lshift(v, ts); \
		v |= _ctf_unsigned_cast(typeof(v), (ptr)[this_unit]); \
	} \
	*(vptr) = v; \
} while (0)

#define _ctf_bitfield_read_be(ptr, _start, _length, vptr)		\
do {									\
	typeof(*(vptr)) v;						\
	typeof(*(ptr)) mask, cmask;					\
	unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \
	unsigned long start = _start, length = _length;			\
	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 (_ctf_is_signed_type(typeof(v))				\
	    && ((ptr)[this_unit] & ((typeof(*(ptr))) 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 = ~((~(typeof(*(ptr))) 0) << (end - start)); \
			cmask &= mask; \
		} \
		v = _ctf_piecewise_lshift(v, end - start); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
		*(vptr) = v; \
		break; \
	} \
	if (start % ts) { \
		mask = ~((~(typeof(*(ptr))) 0) << (ts - (start % ts))); \
		cmask = (ptr)[this_unit]; \
		cmask &= mask; \
		v = _ctf_piecewise_lshift(v, ts - (start % ts)); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
		start += ts - (start % ts); \
		this_unit++; \
	} \
	for (; this_unit < end_unit - 1; this_unit++) { \
		v = _ctf_piecewise_lshift(v, ts); \
		v |= _ctf_unsigned_cast(typeof(v), (ptr)[this_unit]); \
		start += ts; \
	} \
	if (end % ts) { \
		mask = ~((~(typeof(*(ptr))) 0) << (end % ts)); \
		cmask = (ptr)[this_unit]; \
		cmask >>= ts - (end % ts); \
		cmask &= mask; \
		v = _ctf_piecewise_lshift(v, end % ts); \
		v |= _ctf_unsigned_cast(typeof(v), cmask); \
	} else { \
		v = _ctf_piecewise_lshift(v, ts); \
		v |= _ctf_unsigned_cast(typeof(v), (ptr)[this_unit]); \
	} \
	*(vptr) = v; \
} while (0)

/*
 * ctf_bitfield_read - read integer from a bitfield in native endianness
 * ctf_bitfield_read_le - read integer from a bitfield in little endian
 * ctf_bitfield_read_be - read integer from a bitfield in big endian
 */

#if (BYTE_ORDER == LITTLE_ENDIAN)

#define ctf_bitfield_read(ptr, _start, _length, _vptr)			\
	_ctf_bitfield_read_le(ptr, _start, _length, _vptr)

#define ctf_bitfield_read_le(ptr, _start, _length, _vptr)		\
	_ctf_bitfield_read_le(ptr, _start, _length, _vptr)
	
#define ctf_bitfield_read_be(ptr, _start, _length, _vptr)		\
	_ctf_bitfield_read_be((const uint8_t *) (ptr), _start, _length, _vptr)

#elif (BYTE_ORDER == BIG_ENDIAN)

#define ctf_bitfield_read(ptr, _start, _length, _vptr)			\
	_ctf_bitfield_read_be(ptr, _start, _length, _vptr)

#define ctf_bitfield_read_le(ptr, _start, _length, _vptr)		\
	_ctf_bitfield_read_le((const uint8_t *) (ptr), _start, _length, _vptr)
	
#define ctf_bitfield_read_be(ptr, _start, _length, _vptr)		\
	_ctf_bitfield_read_be(ptr, _start, _length, _vptr)

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

#error "Byte order not supported"

#endif

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