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

/* SPDX-License-Identifier: MIT
 *
 * Copyright 2010-2019 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#ifndef _BABELTRACE_BITFIELD_H
#define _BABELTRACE_BITFIELD_H

#include <linux/types.h>
#include <lttng-endian.h>

#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif

/*
 * This header strictly follows the C99 standard, except for use of the
 * compiler-specific __typeof__.
 */

/*
 * This bitfield header requires the compiler representation of signed
 * integers to be two's complement.
 */
#if (-1 != ~0)
#error "bitfield.h requires the compiler representation of signed integers to be two's complement."
#endif

/*
 * _bt_is_signed_type() willingly generates comparison of unsigned
 * expression < 0, which is always false. Silence compiler warnings.
 */
#ifdef __GNUC__
# define _BT_DIAG_PUSH			_Pragma("GCC diagnostic push")
# define _BT_DIAG_POP			_Pragma("GCC diagnostic pop")

# define _BT_DIAG_STRINGIFY_1(x)	#x
# define _BT_DIAG_STRINGIFY(x)		_BT_DIAG_STRINGIFY_1(x)

# define _BT_DIAG_IGNORE(option)	\
	_Pragma(_BT_DIAG_STRINGIFY(GCC diagnostic ignored option))
# define _BT_DIAG_IGNORE_TYPE_LIMITS	_BT_DIAG_IGNORE("-Wtype-limits")
#else
# define _BT_DIAG_PUSH
# define _BT_DIAG_POP
# define _BT_DIAG_IGNORE
#endif

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

/*
 * Produce a build-time error if the condition `cond` is non-zero.
 * Evaluates as a size_t expression.
 */
#define _BT_BUILD_ASSERT(cond)					\
	sizeof(struct { int f:(2 * !!(cond) - 1); })

/*
 * Cast value `v` to an unsigned integer of the same size as `v`.
 */
#define _bt_cast_value_to_unsigned(v)					\
	(sizeof(v) == sizeof(uint8_t) ? (uint8_t) (v) :			\
	sizeof(v) == sizeof(uint16_t) ? (uint16_t) (v) :		\
	sizeof(v) == sizeof(uint32_t) ? (uint32_t) (v) :		\
	sizeof(v) == sizeof(uint64_t) ? (uint64_t) (v) :		\
	_BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t)))

/*
 * Cast value `v` to an unsigned integer type of the size of type `type`
 * *without* sign-extension.
 *
 * The unsigned cast ensures that we're not shifting a negative value,
 * which is undefined in C. However, this limits the maximum type size
 * of `type` to 64-bit. Generate a compile-time error if the size of
 * `type` is larger than 64-bit.
 */
#define _bt_cast_value_to_unsigned_type(type, v)			\
	(sizeof(type) == sizeof(uint8_t) ?				\
		(uint8_t) _bt_cast_value_to_unsigned(v) :		\
	sizeof(type) == sizeof(uint16_t) ?				\
		(uint16_t) _bt_cast_value_to_unsigned(v) :		\
	sizeof(type) == sizeof(uint32_t) ?				\
		(uint32_t) _bt_cast_value_to_unsigned(v) :		\
	sizeof(type) == sizeof(uint64_t) ?				\
		(uint64_t) _bt_cast_value_to_unsigned(v) :		\
	_BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t)))

/*
 * _bt_fill_mask evaluates to a "type" integer with all bits set.
 */
#define _bt_fill_mask(type)	((type) ~(type) 0)

/*
 * Left shift a value `v` of `shift` bits.
 *
 * The type of `v` can be signed or unsigned integer.
 * The value of `shift` must be less than the size of `v` (in bits),
 * otherwise the behavior is undefined.
 * Evaluates to the result of the shift operation.
 *
 * According to the C99 standard, left shift of a left hand-side signed
 * type is undefined if it has a negative value or if the result cannot
 * be represented in the result type. This bitfield header discards the
 * bits that are left-shifted beyond the result type representation,
 * which is the behavior of an unsigned type left shift operation.
 * Therefore, always perform left shift on an unsigned type.
 *
 * This macro should not be used if `shift` can be greater or equal than
 * the bitwidth of `v`. See `_bt_safe_lshift`.
 */
#define _bt_lshift(v, shift)						\
	((__typeof__(v)) (_bt_cast_value_to_unsigned(v) << (shift)))

/*
 * Generate a mask of type `type` with the `length` least significant bits
 * cleared, and the most significant bits set.
 */
#define _bt_make_mask_complement(type, length)				\
	_bt_lshift(_bt_fill_mask(type), length)

/*
 * Generate a mask of type `type` with the `length` least significant bits
 * set, and the most significant bits cleared.
 */
#define _bt_make_mask(type, length)					\
	((type) ~_bt_make_mask_complement(type, length))

/*
 * Right shift a value `v` of `shift` bits.
 *
 * The type of `v` can be signed or unsigned integer.
 * The value of `shift` must be less than the size of `v` (in bits),
 * otherwise the behavior is undefined.
 * Evaluates to the result of the shift operation.
 *
 * According to the C99 standard, right shift of a left hand-side signed
 * type which has a negative value is implementation defined. This
 * bitfield header relies on the right shift implementation carrying the
 * sign bit. If the compiler implementation has a different behavior,
 * emulate carrying the sign bit.
 *
 * This macro should not be used if `shift` can be greater or equal than
 * the bitwidth of `v`. See `_bt_safe_rshift`.
 */
#if ((-1 >> 1) == -1)
#define _bt_rshift(v, shift)	((v) >> (shift))
#else
#define _bt_rshift(v, shift)						\
	((__typeof__(v)) ((_bt_cast_value_to_unsigned(v) >> (shift)) |	\
		((v) < 0 ? _bt_make_mask_complement(__typeof__(v),	\
			sizeof(v) * CHAR_BIT - (shift)) : 0)))
#endif

/*
 * Right shift a signed or unsigned integer with `shift` value being an
 * arbitrary number of bits. `v` is modified by this macro. The shift
 * is transformed into a sequence of `_nr_partial_shifts` consecutive
 * shift operations, each of a number of bits smaller than the bitwidth
 * of `v`, ending with a shift of the number of left over bits.
 */
#define _bt_safe_rshift(v, shift)					\
do {									\
	unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \
	unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \
									\
	for (; _nr_partial_shifts; _nr_partial_shifts--)		\
		(v) = _bt_rshift(v, sizeof(v) * CHAR_BIT - 1);		\
	(v) = _bt_rshift(v, _leftover_bits);				\
} while (0)

/*
 * Left shift a signed or unsigned integer with `shift` value being an
 * arbitrary number of bits. `v` is modified by this macro. The shift
 * is transformed into a sequence of `_nr_partial_shifts` consecutive
 * shift operations, each of a number of bits smaller than the bitwidth
 * of `v`, ending with a shift of the number of left over bits.
 */
#define _bt_safe_lshift(v, shift)					\
do {									\
	unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \
	unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \
									\
	for (; _nr_partial_shifts; _nr_partial_shifts--)		\
		(v) = _bt_lshift(v, sizeof(v) * CHAR_BIT - 1);		\
	(v) = _bt_lshift(v, _leftover_bits);				\
} while (0)

/*
 * 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 &= _bt_make_mask(__typeof__(_v), _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 = _bt_make_mask(type, _start % _ts);		\
		if (_end % _ts)						\
			_mask |= _bt_make_mask_complement(type, _end % _ts); \
		_cmask = _bt_lshift((type) (_v), _start % _ts);		\
		_cmask &= ~_mask;					\
		_ptr[_this_unit] &= _mask;				\
		_ptr[_this_unit] |= _cmask;				\
		break;							\
	}								\
	if (_start % _ts) {						\
		_cshift = _start % _ts;					\
		_mask = _bt_make_mask(type, _cshift);			\
		_cmask = _bt_lshift((type) (_v), _cshift);		\
		_cmask &= ~_mask;					\
		_ptr[_this_unit] &= _mask;				\
		_ptr[_this_unit] |= _cmask;				\
		_bt_safe_rshift(_v, _ts - _cshift);			\
		_start += _ts - _cshift;				\
		_this_unit++;						\
	}								\
	for (; _this_unit < _end_unit - 1; _this_unit++) {		\
		_ptr[_this_unit] = (type) _v;				\
		_bt_safe_rshift(_v, _ts);				\
		_start += _ts;						\
	}								\
	if (_end % _ts) {						\
		_mask = _bt_make_mask_complement(type, _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 &= _bt_make_mask(__typeof__(_v), _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 = _bt_make_mask(type, (_ts - (_end % _ts)) % _ts); \
		if (_start % _ts)					\
			_mask |= _bt_make_mask_complement(type, _ts - (_start % _ts)); \
		_cmask = _bt_lshift((type) (_v), (_ts - (_end % _ts)) % _ts); \
		_cmask &= ~_mask;					\
		_ptr[_this_unit] &= _mask;				\
		_ptr[_this_unit] |= _cmask;				\
		break;							\
	}								\
	if (_end % _ts) {						\
		_cshift = _end % _ts;					\
		_mask = _bt_make_mask(type, _ts - _cshift);		\
		_cmask = _bt_lshift((type) (_v), _ts - _cshift);	\
		_cmask &= ~_mask;					\
		_ptr[_this_unit] &= _mask;				\
		_ptr[_this_unit] |= _cmask;				\
		_bt_safe_rshift(_v, _cshift);				\
		_end -= _cshift;					\
		_this_unit--;						\
	}								\
	for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \
		_ptr[_this_unit] = (type) _v;				\
		_bt_safe_rshift(_v, _ts);				\
		_end -= _ts;						\
	}								\
	if (_start % _ts) {						\
		_mask = _bt_make_mask_complement(type, _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" */ \
	bool _is_signed_type;						\
									\
	if (!_length) {							\
		*_vptr = 0;						\
		break;							\
	}								\
									\
	_end = _start + _length;					\
	_start_unit = _start / _ts;					\
	_end_unit = (_end + (_ts - 1)) / _ts;				\
									\
	_this_unit = _end_unit - 1;					\
	_BT_DIAG_PUSH							\
	_BT_DIAG_IGNORE_TYPE_LIMITS					\
	_is_signed_type = _bt_is_signed_type(__typeof__(_v));		\
	_BT_DIAG_POP							\
	if (_is_signed_type						\
	    && (_ptr[_this_unit] & _bt_lshift((type) 1, (_end % _ts ? _end % _ts : _ts) - 1))) \
		_v = ~(__typeof__(_v)) 0;				\
	else								\
		_v = 0;							\
	if (_start_unit == _end_unit - 1) {				\
		_cmask = _ptr[_this_unit];				\
		_cmask = _bt_rshift(_cmask, _start % _ts);		\
		if ((_end - _start) % _ts) {				\
			_mask = _bt_make_mask(type, _end - _start);	\
			_cmask &= _mask;				\
		}							\
		_bt_safe_lshift(_v, _end - _start);			\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
		*_vptr = _v;						\
		break;							\
	}								\
	if (_end % _ts) {						\
		_cshift = _end % _ts;					\
		_mask = _bt_make_mask(type, _cshift);			\
		_cmask = _ptr[_this_unit];				\
		_cmask &= _mask;					\
		_bt_safe_lshift(_v, _cshift);				\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
		_end -= _cshift;					\
		_this_unit--;						\
	}								\
	for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \
		_bt_safe_lshift(_v, _ts);				\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
		_end -= _ts;						\
	}								\
	if (_start % _ts) {						\
		_mask = _bt_make_mask(type, _ts - (_start % _ts));	\
		_cmask = _ptr[_this_unit];				\
		_cmask = _bt_rshift(_cmask, _start % _ts);		\
		_cmask &= _mask;					\
		_bt_safe_lshift(_v, _ts - (_start % _ts));		\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	} else {							\
		_bt_safe_lshift(_v, _ts);				\
		_v |= _bt_cast_value_to_unsigned_type(__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" */ \
	bool _is_signed_type;						\
									\
	if (!_length) {							\
		*_vptr = 0;						\
		break;							\
	}								\
									\
	_end = _start + _length;					\
	_start_unit = _start / _ts;					\
	_end_unit = (_end + (_ts - 1)) / _ts;				\
									\
	_this_unit = _start_unit;					\
	_BT_DIAG_PUSH							\
	_BT_DIAG_IGNORE_TYPE_LIMITS					\
	_is_signed_type = _bt_is_signed_type(__typeof__(_v));		\
	_BT_DIAG_POP							\
	if (_is_signed_type						\
	    && (_ptr[_this_unit] & _bt_lshift((type) 1, _ts - (_start % _ts) - 1))) \
		_v = ~(__typeof__(_v)) 0;				\
	else								\
		_v = 0;							\
	if (_start_unit == _end_unit - 1) {				\
		_cmask = _ptr[_this_unit];				\
		_cmask = _bt_rshift(_cmask, (_ts - (_end % _ts)) % _ts); \
		if ((_end - _start) % _ts) {				\
			_mask = _bt_make_mask(type, _end - _start);	\
			_cmask &= _mask;				\
		}							\
		_bt_safe_lshift(_v, _end - _start);			\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
		*_vptr = _v;						\
		break;							\
	}								\
	if (_start % _ts) {						\
		_cshift = _start % _ts;					\
		_mask = _bt_make_mask(type, _ts - _cshift);		\
		_cmask = _ptr[_this_unit];				\
		_cmask &= _mask;					\
		_bt_safe_lshift(_v, _ts - _cshift);			\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
		_start += _ts - _cshift;				\
		_this_unit++;						\
	}								\
	for (; _this_unit < _end_unit - 1; _this_unit++) {		\
		_bt_safe_lshift(_v, _ts);				\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
		_start += _ts;						\
	}								\
	if (_end % _ts) {						\
		_mask = _bt_make_mask(type, _end % _ts);		\
		_cmask = _ptr[_this_unit];				\
		_cmask = _bt_rshift(_cmask, _ts - (_end % _ts));	\
		_cmask &= _mask;					\
		_bt_safe_lshift(_v, _end % _ts);			\
		_v |= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	} else {							\
		_bt_safe_lshift(_v, _ts);				\
		_v |= _bt_cast_value_to_unsigned_type(__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
9f36eaed MJ	1	/* SPDX-License-Identifier: MIT
9f36eaed MJ	2	*
73ca4981	3	* Copyright 2010-2019 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9115fbdc MD	4	*/
9115fbdc MD	5
9f36eaed MJ	6	#ifndef _BABELTRACE_BITFIELD_H
	7	#define _BABELTRACE_BITFIELD_H
	8
73ca4981	9	#include <linux/types.h>
5671a661	10	#include <lttng-endian.h>
9115fbdc MD	11
	12	#ifndef CHAR_BIT
	13	#define CHAR_BIT 8
	14	#endif
	15
73ca4981 MD	16	/*
	17	* This header strictly follows the C99 standard, except for use of the
	18	* compiler-specific __typeof__.
	19	*/
	20
	21	/*
	22	* This bitfield header requires the compiler representation of signed
	23	* integers to be two's complement.
	24	*/
	25	#if (-1 != ~0)
	26	#error "bitfield.h requires the compiler representation of signed integers to be two's complement."
	27	#endif
	28
9282620c MD	29	/*
	30	* _bt_is_signed_type() willingly generates comparison of unsigned
	31	* expression < 0, which is always false. Silence compiler warnings.
	32	*/
	33	#ifdef __GNUC__
	34	# define _BT_DIAG_PUSH _Pragma("GCC diagnostic push")
	35	# define _BT_DIAG_POP _Pragma("GCC diagnostic pop")
	36
	37	# define _BT_DIAG_STRINGIFY_1(x) #x
	38	# define _BT_DIAG_STRINGIFY(x) _BT_DIAG_STRINGIFY_1(x)
	39
	40	# define _BT_DIAG_IGNORE(option) \
	41	_Pragma(_BT_DIAG_STRINGIFY(GCC diagnostic ignored option))
	42	# define _BT_DIAG_IGNORE_TYPE_LIMITS _BT_DIAG_IGNORE("-Wtype-limits")
	43	#else
	44	# define _BT_DIAG_PUSH
	45	# define _BT_DIAG_POP
	46	# define _BT_DIAG_IGNORE
	47	#endif
	48
73ca4981 MD	49	#define _bt_is_signed_type(type) ((type) -1 < (type) 0)
	50
	51	/*
	52	* Produce a build-time error if the condition `cond` is non-zero.
	53	* Evaluates as a size_t expression.
	54	*/
	55	#define _BT_BUILD_ASSERT(cond) \
	56	sizeof(struct { int f:(2 * !!(cond) - 1); })
	57
	58	/*
	59	* Cast value `v` to an unsigned integer of the same size as `v`.
	60	*/
	61	#define _bt_cast_value_to_unsigned(v) \
	62	(sizeof(v) == sizeof(uint8_t) ? (uint8_t) (v) : \
	63	sizeof(v) == sizeof(uint16_t) ? (uint16_t) (v) : \
	64	sizeof(v) == sizeof(uint32_t) ? (uint32_t) (v) : \
	65	sizeof(v) == sizeof(uint64_t) ? (uint64_t) (v) : \
	66	_BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t)))
	67
	68	/*
	69	* Cast value `v` to an unsigned integer type of the size of type `type`
	70	* without sign-extension.
	71	*
	72	* The unsigned cast ensures that we're not shifting a negative value,
	73	* which is undefined in C. However, this limits the maximum type size
	74	* of `type` to 64-bit. Generate a compile-time error if the size of
	75	* `type` is larger than 64-bit.
	76	*/
	77	#define _bt_cast_value_to_unsigned_type(type, v) \
	78	(sizeof(type) == sizeof(uint8_t) ? \
	79	(uint8_t) _bt_cast_value_to_unsigned(v) : \
	80	sizeof(type) == sizeof(uint16_t) ? \
	81	(uint16_t) _bt_cast_value_to_unsigned(v) : \
	82	sizeof(type) == sizeof(uint32_t) ? \
	83	(uint32_t) _bt_cast_value_to_unsigned(v) : \
	84	sizeof(type) == sizeof(uint64_t) ? \
	85	(uint64_t) _bt_cast_value_to_unsigned(v) : \
	86	_BT_BUILD_ASSERT(sizeof(v) <= sizeof(uint64_t)))
	87
	88	/*
	89	* _bt_fill_mask evaluates to a "type" integer with all bits set.
	90	*/
	91	#define _bt_fill_mask(type) ((type) ~(type) 0)
	92
	93	/*
	94	* Left shift a value `v` of `shift` bits.
	95	*
	96	* The type of `v` can be signed or unsigned integer.
	97	* The value of `shift` must be less than the size of `v` (in bits),
	98	* otherwise the behavior is undefined.
	99	* Evaluates to the result of the shift operation.
	100	*
	101	* According to the C99 standard, left shift of a left hand-side signed
	102	* type is undefined if it has a negative value or if the result cannot
	103	* be represented in the result type. This bitfield header discards the
	104	* bits that are left-shifted beyond the result type representation,
	105	* which is the behavior of an unsigned type left shift operation.
	106	* Therefore, always perform left shift on an unsigned type.
	107	*
	108	* This macro should not be used if `shift` can be greater or equal than
	109	* the bitwidth of `v`. See `_bt_safe_lshift`.
	110	*/
	111	#define _bt_lshift(v, shift) \
	112	((__typeof__(v)) (_bt_cast_value_to_unsigned(v) << (shift)))
9115fbdc	113
73ca4981 MD	114	/*
	115	* Generate a mask of type `type` with the `length` least significant bits
	116	* cleared, and the most significant bits set.
	117	*/
	118	#define _bt_make_mask_complement(type, length) \
	119	_bt_lshift(_bt_fill_mask(type), length)
9115fbdc	120
73ca4981 MD	121	/*
	122	* Generate a mask of type `type` with the `length` least significant bits
	123	* set, and the most significant bits cleared.
	124	*/
	125	#define _bt_make_mask(type, length) \
	126	((type) ~_bt_make_mask_complement(type, length))
	127
	128	/*
	129	* Right shift a value `v` of `shift` bits.
	130	*
	131	* The type of `v` can be signed or unsigned integer.
	132	* The value of `shift` must be less than the size of `v` (in bits),
	133	* otherwise the behavior is undefined.
	134	* Evaluates to the result of the shift operation.
	135	*
	136	* According to the C99 standard, right shift of a left hand-side signed
	137	* type which has a negative value is implementation defined. This
	138	* bitfield header relies on the right shift implementation carrying the
	139	* sign bit. If the compiler implementation has a different behavior,
	140	* emulate carrying the sign bit.
	141	*
	142	* This macro should not be used if `shift` can be greater or equal than
	143	* the bitwidth of `v`. See `_bt_safe_rshift`.
	144	*/
	145	#if ((-1 >> 1) == -1)
	146	#define _bt_rshift(v, shift) ((v) >> (shift))
	147	#else
	148	#define _bt_rshift(v, shift) \
	149	((__typeof__(v)) ((_bt_cast_value_to_unsigned(v) >> (shift)) \| \
	150	((v) < 0 ? _bt_make_mask_complement(__typeof__(v), \
	151	sizeof(v) * CHAR_BIT - (shift)) : 0)))
	152	#endif
	153
	154	/*
	155	* Right shift a signed or unsigned integer with `shift` value being an
	156	* arbitrary number of bits. `v` is modified by this macro. The shift
	157	* is transformed into a sequence of `_nr_partial_shifts` consecutive
	158	* shift operations, each of a number of bits smaller than the bitwidth
	159	* of `v`, ending with a shift of the number of left over bits.
	160	*/
	161	#define _bt_safe_rshift(v, shift) \
	162	do { \
	163	unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \
	164	unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \
	165	\
	166	for (; _nr_partial_shifts; _nr_partial_shifts--) \
	167	(v) = _bt_rshift(v, sizeof(v) * CHAR_BIT - 1); \
	168	(v) = _bt_rshift(v, _leftover_bits); \
	169	} while (0)
	170
	171	/*
	172	* Left shift a signed or unsigned integer with `shift` value being an
	173	* arbitrary number of bits. `v` is modified by this macro. The shift
	174	* is transformed into a sequence of `_nr_partial_shifts` consecutive
	175	* shift operations, each of a number of bits smaller than the bitwidth
	176	* of `v`, ending with a shift of the number of left over bits.
	177	*/
	178	#define _bt_safe_lshift(v, shift) \
	179	do { \
	180	unsigned long _nr_partial_shifts = (shift) / (sizeof(v) * CHAR_BIT - 1); \
	181	unsigned long _leftover_bits = (shift) % (sizeof(v) * CHAR_BIT - 1); \
	182	\
	183	for (; _nr_partial_shifts; _nr_partial_shifts--) \
	184	(v) = _bt_lshift(v, sizeof(v) * CHAR_BIT - 1); \
185	(v) = _bt_lshift(v, _leftover_bits); \
186	} while (0)
9115fbdc MD	187
	188	/*
	189	* bt_bitfield_write - write integer to a bitfield in native endianness
	190	*
	191	* Save integer to the bitfield, which starts at the "start" bit, has "len"
	192	* bits.
	193	* The inside of a bitfield is from high bits to low bits.
	194	* Uses native endianness.
	195	* For unsigned "v", pad MSB with 0 if bitfield is larger than v.
	196	* For signed "v", sign-extend v if bitfield is larger than v.
	197	*
	198	* On little endian, bytes are placed from the less significant to the most
	199	* significant. Also, consecutive bitfields are placed from lower bits to higher
	200	* bits.
	201	*
	202	* On big endian, bytes are places from most significant to less significant.
	203	* Also, consecutive bitfields are placed from higher to lower bits.
	204	*/
	205
437f89c7	206	#define _bt_bitfield_write_le(ptr, type, start, length, v) \
9115fbdc	207	do { \
437f89c7 MD	208	__typeof__(v) _v = (v); \
	209	type _ptr = (void ) (ptr); \
	210	unsigned long _start = (start), _length = (length); \
	211	type _mask, _cmask; \
	212	unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \
	213	unsigned long _start_unit, _end_unit, _this_unit; \
	214	unsigned long _end, _cshift; /* _cshift is "complement shift" */ \
9115fbdc	215	\
437f89c7	216	if (!_length) \
9115fbdc MD	217	break; \
9115fbdc MD	218	\
437f89c7 MD	219	_end = _start + _length; \
	220	_start_unit = _start / _ts; \
	221	_end_unit = (_end + (_ts - 1)) / _ts; \
9115fbdc MD	222	\
9115fbdc MD	223	/* Trim v high bits */ \
437f89c7 MD	224	if (_length < sizeof(_v) * CHAR_BIT) \
437f89c7 MD	225	_v &= _bt_make_mask(__typeof__(_v), _length); \
9115fbdc MD	226	\
9115fbdc MD	227	/* We can now append v with a simple "or", shift it piece-wise */ \
437f89c7 MD	228	_this_unit = _start_unit; \
	229	if (_start_unit == _end_unit - 1) { \
	230	_mask = _bt_make_mask(type, _start % _ts); \
	231	if (_end % _ts) \
	232	_mask \|= _bt_make_mask_complement(type, _end % _ts); \
	233	_cmask = _bt_lshift((type) (_v), _start % _ts); \
	234	_cmask &= ~_mask; \
	235	_ptr[_this_unit] &= _mask; \
	236	_ptr[_this_unit] \|= _cmask; \
9115fbdc MD	237	break; \
9115fbdc MD	238	} \
437f89c7 MD	239	if (_start % _ts) { \
	240	_cshift = _start % _ts; \
	241	_mask = _bt_make_mask(type, _cshift); \
	242	_cmask = _bt_lshift((type) (_v), _cshift); \
	243	_cmask &= ~_mask; \
	244	_ptr[_this_unit] &= _mask; \
	245	_ptr[_this_unit] \|= _cmask; \
	246	_bt_safe_rshift(_v, _ts - _cshift); \
	247	_start += _ts - _cshift; \
	248	_this_unit++; \
9115fbdc	249	} \
437f89c7 MD	250	for (; _this_unit < _end_unit - 1; _this_unit++) { \
	251	_ptr[_this_unit] = (type) _v; \
	252	_bt_safe_rshift(_v, _ts); \
	253	_start += _ts; \
9115fbdc	254	} \
437f89c7 MD	255	if (_end % _ts) { \
	256	_mask = _bt_make_mask_complement(type, _end % _ts); \
	257	_cmask = (type) _v; \
	258	_cmask &= ~_mask; \
	259	_ptr[_this_unit] &= _mask; \
	260	_ptr[_this_unit] \|= _cmask; \
9115fbdc	261	} else \
437f89c7	262	_ptr[_this_unit] = (type) _v; \
9115fbdc MD	263	} while (0)
9115fbdc MD	264
437f89c7	265	#define _bt_bitfield_write_be(ptr, type, start, length, v) \
9115fbdc	266	do { \
437f89c7 MD	267	__typeof__(v) _v = (v); \
	268	type _ptr = (void ) (ptr); \
	269	unsigned long _start = (start), _length = (length); \
	270	type _mask, _cmask; \
	271	unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \
	272	unsigned long _start_unit, _end_unit, _this_unit; \
	273	unsigned long _end, _cshift; /* _cshift is "complement shift" */ \
9115fbdc	274	\
437f89c7	275	if (!_length) \
9115fbdc MD	276	break; \
9115fbdc MD	277	\
437f89c7 MD	278	_end = _start + _length; \
	279	_start_unit = _start / _ts; \
	280	_end_unit = (_end + (_ts - 1)) / _ts; \
9115fbdc MD	281	\
9115fbdc MD	282	/* Trim v high bits */ \
437f89c7 MD	283	if (_length < sizeof(_v) * CHAR_BIT) \
437f89c7 MD	284	_v &= _bt_make_mask(__typeof__(_v), _length); \
9115fbdc MD	285	\
9115fbdc MD	286	/* We can now append v with a simple "or", shift it piece-wise */ \
437f89c7 MD	287	_this_unit = _end_unit - 1; \
	288	if (_start_unit == _end_unit - 1) { \
	289	_mask = _bt_make_mask(type, (_ts - (_end % _ts)) % _ts); \
	290	if (_start % _ts) \
	291	_mask \|= _bt_make_mask_complement(type, _ts - (_start % _ts)); \
	292	_cmask = _bt_lshift((type) (_v), (_ts - (_end % _ts)) % _ts); \
	293	_cmask &= ~_mask; \
	294	_ptr[_this_unit] &= _mask; \
	295	_ptr[_this_unit] \|= _cmask; \
9115fbdc MD	296	break; \
9115fbdc MD	297	} \
437f89c7 MD	298	if (_end % _ts) { \
	299	_cshift = _end % _ts; \
	300	_mask = _bt_make_mask(type, _ts - _cshift); \
	301	_cmask = _bt_lshift((type) (_v), _ts - _cshift); \
	302	_cmask &= ~_mask; \
	303	_ptr[_this_unit] &= _mask; \
	304	_ptr[_this_unit] \|= _cmask; \
	305	_bt_safe_rshift(_v, _cshift); \
	306	_end -= _cshift; \
	307	_this_unit--; \
9115fbdc	308	} \
437f89c7 MD	309	for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \
	310	_ptr[_this_unit] = (type) _v; \
	311	_bt_safe_rshift(_v, _ts); \
	312	_end -= _ts; \
9115fbdc	313	} \
437f89c7 MD	314	if (_start % _ts) { \
	315	_mask = _bt_make_mask_complement(type, _ts - (_start % _ts)); \
	316	_cmask = (type) _v; \
	317	_cmask &= ~_mask; \
	318	_ptr[_this_unit] &= _mask; \
	319	_ptr[_this_unit] \|= _cmask; \
9115fbdc	320	} else \
437f89c7	321	_ptr[_this_unit] = (type) _v; \
9115fbdc MD	322	} while (0)
	323
	324	/*
	325	* bt_bitfield_write - write integer to a bitfield in native endianness
	326	* bt_bitfield_write_le - write integer to a bitfield in little endian
	327	* bt_bitfield_write_be - write integer to a bitfield in big endian
	328	*/
	329
	330	#if (__BYTE_ORDER == __LITTLE_ENDIAN)
	331
437f89c7 MD	332	#define bt_bitfield_write(ptr, type, start, length, v) \
437f89c7 MD	333	_bt_bitfield_write_le(ptr, type, start, length, v)
9115fbdc	334
437f89c7 MD	335	#define bt_bitfield_write_le(ptr, type, start, length, v) \
437f89c7 MD	336	_bt_bitfield_write_le(ptr, type, start, length, v)
73ca4981	337
437f89c7 MD	338	#define bt_bitfield_write_be(ptr, type, start, length, v) \
437f89c7 MD	339	_bt_bitfield_write_be(ptr, unsigned char, start, length, v)
9115fbdc MD	340
	341	#elif (__BYTE_ORDER == __BIG_ENDIAN)
	342
437f89c7 MD	343	#define bt_bitfield_write(ptr, type, start, length, v) \
437f89c7 MD	344	_bt_bitfield_write_be(ptr, type, start, length, v)
9115fbdc	345
437f89c7 MD	346	#define bt_bitfield_write_le(ptr, type, start, length, v) \
437f89c7 MD	347	_bt_bitfield_write_le(ptr, unsigned char, start, length, v)
73ca4981	348
437f89c7 MD	349	#define bt_bitfield_write_be(ptr, type, start, length, v) \
437f89c7 MD	350	_bt_bitfield_write_be(ptr, type, start, length, v)
9115fbdc	351
73ca4981	352	#else /* (__BYTE_ORDER == __PDP_ENDIAN) */
9115fbdc MD	353
	354	#error "Byte order not supported"
	355
	356	#endif
	357
437f89c7	358	#define _bt_bitfield_read_le(ptr, type, start, length, vptr) \
9115fbdc	359	do { \
437f89c7 MD	360	__typeof__((vptr)) _vptr = (vptr); \
	361	__typeof__(*_vptr) _v; \
	362	type _ptr = (void ) (ptr); \
	363	unsigned long _start = (start), _length = (length); \
	364	type _mask, _cmask; \
	365	unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \
	366	unsigned long _start_unit, _end_unit, _this_unit; \
	367	unsigned long _end, _cshift; /* _cshift is "complement shift" */ \
	368	bool _is_signed_type; \
9115fbdc	369	\
437f89c7 MD	370	if (!_length) { \
437f89c7 MD	371	*_vptr = 0; \
9115fbdc MD	372	break; \
	373	} \
	374	\
437f89c7 MD	375	_end = _start + _length; \
	376	_start_unit = _start / _ts; \
	377	_end_unit = (_end + (_ts - 1)) / _ts; \
9115fbdc	378	\
437f89c7	379	_this_unit = _end_unit - 1; \
9282620c MD	380	_BT_DIAG_PUSH \
9282620c MD	381	_BT_DIAG_IGNORE_TYPE_LIMITS \
437f89c7	382	_is_signed_type = _bt_is_signed_type(__typeof__(_v)); \
9282620c	383	_BT_DIAG_POP \
437f89c7 MD	384	if (_is_signed_type \
	385	&& (_ptr[_this_unit] & _bt_lshift((type) 1, (_end % _ts ? _end % _ts : _ts) - 1))) \
	386	_v = ~(__typeof__(_v)) 0; \
9115fbdc	387	else \
437f89c7 MD	388	_v = 0; \
	389	if (_start_unit == _end_unit - 1) { \
	390	_cmask = _ptr[_this_unit]; \
	391	_cmask = _bt_rshift(_cmask, _start % _ts); \
	392	if ((_end - _start) % _ts) { \
	393	_mask = _bt_make_mask(type, _end - _start); \
	394	_cmask &= _mask; \
9115fbdc	395	} \
437f89c7 MD	396	_bt_safe_lshift(_v, _end - _start); \
	397	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	398	*_vptr = _v; \
9115fbdc MD	399	break; \
9115fbdc MD	400	} \
437f89c7 MD	401	if (_end % _ts) { \
	402	_cshift = _end % _ts; \
	403	_mask = _bt_make_mask(type, _cshift); \
	404	_cmask = _ptr[_this_unit]; \
	405	_cmask &= _mask; \
	406	_bt_safe_lshift(_v, _cshift); \
	407	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	408	_end -= _cshift; \
	409	_this_unit--; \
9115fbdc	410	} \
437f89c7 MD	411	for (; (long) _this_unit >= (long) _start_unit + 1; _this_unit--) { \
	412	_bt_safe_lshift(_v, _ts); \
	413	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
	414	_end -= _ts; \
9115fbdc	415	} \
437f89c7 MD	416	if (_start % _ts) { \
	417	_mask = _bt_make_mask(type, _ts - (_start % _ts)); \
	418	_cmask = _ptr[_this_unit]; \
	419	_cmask = _bt_rshift(_cmask, _start % _ts); \
	420	_cmask &= _mask; \
	421	_bt_safe_lshift(_v, _ts - (_start % _ts)); \
	422	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
9115fbdc	423	} else { \
437f89c7 MD	424	_bt_safe_lshift(_v, _ts); \
437f89c7 MD	425	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
9115fbdc	426	} \
437f89c7	427	*_vptr = _v; \
9115fbdc MD	428	} while (0)
9115fbdc MD	429
437f89c7	430	#define _bt_bitfield_read_be(ptr, type, start, length, vptr) \
9115fbdc	431	do { \
437f89c7 MD	432	__typeof__((vptr)) _vptr = (vptr); \
	433	__typeof__(*_vptr) _v; \
	434	type _ptr = (void ) (ptr); \
	435	unsigned long _start = (start), _length = (length); \
	436	type _mask, _cmask; \
	437	unsigned long _ts = sizeof(type) * CHAR_BIT; /* type size */ \
	438	unsigned long _start_unit, _end_unit, _this_unit; \
	439	unsigned long _end, _cshift; /* _cshift is "complement shift" */ \
	440	bool _is_signed_type; \
9115fbdc	441	\
437f89c7 MD	442	if (!_length) { \
437f89c7 MD	443	*_vptr = 0; \
9115fbdc MD	444	break; \
	445	} \
	446	\
437f89c7 MD	447	_end = _start + _length; \
	448	_start_unit = _start / _ts; \
	449	_end_unit = (_end + (_ts - 1)) / _ts; \
9115fbdc	450	\
437f89c7	451	_this_unit = _start_unit; \
9282620c MD	452	_BT_DIAG_PUSH \
9282620c MD	453	_BT_DIAG_IGNORE_TYPE_LIMITS \
437f89c7	454	_is_signed_type = _bt_is_signed_type(__typeof__(_v)); \
9282620c	455	_BT_DIAG_POP \
437f89c7 MD	456	if (_is_signed_type \
	457	&& (_ptr[_this_unit] & _bt_lshift((type) 1, _ts - (_start % _ts) - 1))) \
	458	_v = ~(__typeof__(_v)) 0; \
9115fbdc	459	else \
437f89c7 MD	460	_v = 0; \
	461	if (_start_unit == _end_unit - 1) { \
	462	_cmask = _ptr[_this_unit]; \
	463	_cmask = _bt_rshift(_cmask, (_ts - (_end % _ts)) % _ts); \
	464	if ((_end - _start) % _ts) { \
	465	_mask = _bt_make_mask(type, _end - _start); \
	466	_cmask &= _mask; \
9115fbdc	467	} \
437f89c7 MD	468	_bt_safe_lshift(_v, _end - _start); \
	469	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	470	*_vptr = _v; \
9115fbdc MD	471	break; \
9115fbdc MD	472	} \
437f89c7 MD	473	if (_start % _ts) { \
	474	_cshift = _start % _ts; \
	475	_mask = _bt_make_mask(type, _ts - _cshift); \
	476	_cmask = _ptr[_this_unit]; \
	477	_cmask &= _mask; \
	478	_bt_safe_lshift(_v, _ts - _cshift); \
	479	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
	480	_start += _ts - _cshift; \
	481	_this_unit++; \
9115fbdc	482	} \
437f89c7 MD	483	for (; _this_unit < _end_unit - 1; _this_unit++) { \
	484	_bt_safe_lshift(_v, _ts); \
	485	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
	486	_start += _ts; \
9115fbdc	487	} \
437f89c7 MD	488	if (_end % _ts) { \
	489	_mask = _bt_make_mask(type, _end % _ts); \
	490	_cmask = _ptr[_this_unit]; \
	491	_cmask = _bt_rshift(_cmask, _ts - (_end % _ts)); \
	492	_cmask &= _mask; \
	493	_bt_safe_lshift(_v, _end % _ts); \
	494	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _cmask); \
9115fbdc	495	} else { \
437f89c7 MD	496	_bt_safe_lshift(_v, _ts); \
437f89c7 MD	497	_v \|= _bt_cast_value_to_unsigned_type(__typeof__(_v), _ptr[_this_unit]); \
9115fbdc	498	} \
437f89c7	499	*_vptr = _v; \
9115fbdc MD	500	} while (0)
	501
	502	/*
	503	* bt_bitfield_read - read integer from a bitfield in native endianness
	504	* bt_bitfield_read_le - read integer from a bitfield in little endian
	505	* bt_bitfield_read_be - read integer from a bitfield in big endian
	506	*/
	507
	508	#if (__BYTE_ORDER == __LITTLE_ENDIAN)
	509
437f89c7 MD	510	#define bt_bitfield_read(ptr, type, start, length, vptr) \
437f89c7 MD	511	_bt_bitfield_read_le(ptr, type, start, length, vptr)
9115fbdc	512
437f89c7 MD	513	#define bt_bitfield_read_le(ptr, type, start, length, vptr) \
437f89c7 MD	514	_bt_bitfield_read_le(ptr, type, start, length, vptr)
73ca4981	515
437f89c7 MD	516	#define bt_bitfield_read_be(ptr, type, start, length, vptr) \
437f89c7 MD	517	_bt_bitfield_read_be(ptr, unsigned char, start, length, vptr)
9115fbdc MD	518
	519	#elif (__BYTE_ORDER == __BIG_ENDIAN)
	520
437f89c7 MD	521	#define bt_bitfield_read(ptr, type, start, length, vptr) \
437f89c7 MD	522	_bt_bitfield_read_be(ptr, type, start, length, vptr)
9115fbdc	523
437f89c7 MD	524	#define bt_bitfield_read_le(ptr, type, start, length, vptr) \
437f89c7 MD	525	_bt_bitfield_read_le(ptr, unsigned char, start, length, vptr)
73ca4981	526
437f89c7 MD	527	#define bt_bitfield_read_be(ptr, type, start, length, vptr) \
437f89c7 MD	528	_bt_bitfield_read_be(ptr, type, start, length, vptr)
9115fbdc MD	529
	530	#else /* (__BYTE_ORDER == __PDP_ENDIAN) */
	531
	532	#error "Byte order not supported"
	533
	534	#endif
	535
	536	#endif /* _BABELTRACE_BITFIELD_H */