/* SPDX-License-Identifier: MIT * * Copyright 2010-2019 - Mathieu Desnoyers */ #ifndef _BABELTRACE_BITFIELD_H #define _BABELTRACE_BITFIELD_H #include #include #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. * GCC versions lower than 4.6.0 do not accept diagnostic pragma inside * functions. */ #if defined(__GNUC__) && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600 # 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 # define _BT_DIAG_IGNORE_TYPE_LIMITS #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 */