bitfield.h File Reference

#include <linux/build_bug.h>
#include <linux/compiler.h>
#include <linux/typecheck.h>
#include <asm/byteorder.h>

Include dependency graph for bitfield.h:

Go to the source code of this file.

Macros
#define	__bf_shf   __builtin_ctzll
#define	__scalar_type_to_unsigned_cases(type)
#define	__unsigned_scalar_typeof(x)
#define	__bf_cast_unsigned(type, x)   ((__unsigned_scalar_typeof(type))(x))
#define	__BF_FIELD_CHECK_MASK(_mask, _val, _pfx)
#define	__BF_FIELD_CHECK_REG(mask, reg, pfx)
#define	__BF_FIELD_CHECK(mask, reg, val, pfx)
#define	__FIELD_PREP(mask, val, pfx)
#define	__FIELD_GET(mask, reg, pfx)
#define	FIELD_MAX(_mask)
#define	FIELD_FIT(_mask, _val)
#define	FIELD_PREP(_mask, _val)
#define	__BF_CHECK_POW2(n)   BUILD_BUG_ON_ZERO(((n) & ((n) - 1)) != 0)
#define	FIELD_PREP_CONST(_mask, _val)
#define	FIELD_GET(_mask, _reg)
#define	FIELD_GET_SIGNED(mask, reg)
#define	FIELD_MODIFY(_mask, _reg_p, _val)
#define	field_max(field)   ((typeof(field))field_mask(field))
#define	____MAKE_OP(type, base, to, from)
#define	__MAKE_OP(size)
#define	__field_prep(mask, val)
#define	__field_get(mask, reg)
#define	field_prep(mask, val)
#define	field_get(mask, reg)

Functions
void	__compiletime_error ("value doesn't fit into mask") __field_overflow(void)
void	__compiletime_error ("bad bitfield mask") __bad_mask(void)

Macro Definition Documentation

____MAKE_OP

#define ____MAKE_OP	(		type,
			base,
			to,
			from
	)

Value:

static __always_inline __##type __must_check type##_encode_bits(base v, base field) \
{                                   \
    if (__builtin_constant_p(v) && (v & ~field_mask(field)))    \
        __field_overflow();                 \
    return to((v & field_mask(field)) * field_multiplier(field));   \
}                                   \
static __always_inline __##type __must_check type##_replace_bits(__##type old,  \
                            base val, base field)   \
{                                   \
    return (old & ~to(field)) | type##_encode_bits(val, field); \
}                                   \
static __always_inline void type##p_replace_bits(__##type *p,       \
                    base val, base field)       \
{                                   \
    *p = (*p & ~to(field)) | type##_encode_bits(val, field);    \
}                                   \
static __always_inline base __must_check type##_get_bits(__##type v, base field)    \
{                                   \
    return (from(v) & field)/field_multiplier(field);       \
}

__bf_cast_unsigned

#define __bf_cast_unsigned	(		type,
			x
	)		((__unsigned_scalar_typeof(type))(x))

__BF_CHECK_POW2

#define __BF_CHECK_POW2

(

n

)

BUILD_BUG_ON_ZERO(((n) & ((n) - 1)) != 0)

__BF_FIELD_CHECK

#define __BF_FIELD_CHECK	(		mask,
			reg,
			val,
			pfx
	)

Value:

    ({                              \
        __BF_FIELD_CHECK_MASK(mask, val, pfx);          \
        __BF_FIELD_CHECK_REG(mask, reg, pfx);           \
    })

__BF_FIELD_CHECK_MASK

#define __BF_FIELD_CHECK_MASK	(		_mask,
			_val,
			_pfx
	)

Value:

    ({                              \
        BUILD_BUG_ON_MSG(!__builtin_constant_p(_mask),      \
                 _pfx "mask is not constant");      \
        BUILD_BUG_ON_MSG((_mask) == 0, _pfx "mask is zero");    \
        BUILD_BUG_ON_MSG(__builtin_constant_p(_val) ?       \
                 ~((_mask) >> __bf_shf(_mask)) &    \
                    (0 + (_val)) : 0,       \
                 _pfx "value too large for the field"); \
        __BUILD_BUG_ON_NOT_POWER_OF_2((_mask) +         \
                          (1ULL << __bf_shf(_mask))); \
    })

__BF_FIELD_CHECK_REG

#define __BF_FIELD_CHECK_REG	(		mask,
			reg,
			pfx
	)

Value:

    BUILD_BUG_ON_MSG(__bf_cast_unsigned(mask, mask) >       \
             __bf_cast_unsigned(reg, ~0ull),        \
             pfx "type of reg too small for mask")

__bf_shf

#define __bf_shf   __builtin_ctzll

__field_get

#define __field_get	(		mask,
			reg
	)

Value:

    ({                              \
        auto __mask = (mask);                   \
        typeof(__mask) __reg =  (reg);              \
        unsigned int __shift = BITS_PER_TYPE(__mask) <= 32 ?    \
                       __ffs(__mask) : __ffs64(__mask); \
        (__reg & __mask) >> __shift;                \
    })

__FIELD_GET

#define __FIELD_GET	(		mask,
			reg,
			pfx
	)

Value:

    ({                              \
        __BF_FIELD_CHECK_MASK(mask, 0U, pfx);           \
        (typeof(mask))(((reg) & (mask)) >> __bf_shf(mask)); \
    })

__field_prep

#define __field_prep	(		mask,
			val
	)

Value:

    ({                              \
        auto __mask = (mask);                   \
        typeof(__mask) __val = (val);               \
        unsigned int __shift = BITS_PER_TYPE(__mask) <= 32 ?    \
                       __ffs(__mask) : __ffs64(__mask); \
        (__val << __shift) & __mask;                \
    })

__FIELD_PREP

#define __FIELD_PREP	(		mask,
			val,
			pfx
	)

Value:

    ({                              \
        __BF_FIELD_CHECK_MASK(mask, val, pfx);          \
        ((typeof(mask))(val) << __bf_shf(mask)) & (mask);   \
    })

__MAKE_OP

#define __MAKE_OP

(

size

)

Value:

    ____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu) \
    ____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu) \
    ____MAKE_OP(u##size,u##size,,)

__scalar_type_to_unsigned_cases

#define __scalar_type_to_unsigned_cases

(

type

)

Value:

        unsigned type:  (unsigned type)0,           \
        signed type:    (unsigned type)0

__unsigned_scalar_typeof

#define __unsigned_scalar_typeof

(

x

)

Value:

        typeof(             \
        _Generic((x),                       \
            char:   (unsigned char)0,           \
            __scalar_type_to_unsigned_cases(char),      \
            __scalar_type_to_unsigned_cases(short),     \
            __scalar_type_to_unsigned_cases(int),       \
            __scalar_type_to_unsigned_cases(long),      \
            __scalar_type_to_unsigned_cases(long long), \
            default: (x)))

FIELD_FIT

#define FIELD_FIT	(		_mask,
			_val
	)

Value:

    ({                              \
        __BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_FIT: "); \
        !((((typeof(_mask))_val) << __bf_shf(_mask)) & ~(_mask)); \
    })

FIELD_FIT() - check if value fits in the field @_mask: shifted mask defining the field's length and position @_val: value to test against the field

Return: true if @_val can fit inside @_mask, false if @_val is too big.

FIELD_GET

#define FIELD_GET	(		_mask,
			_reg
	)

Value:

    ({                              \
        __BF_FIELD_CHECK_REG(_mask, _reg, "FIELD_GET: ");   \
        __FIELD_GET(_mask, _reg, "FIELD_GET: ");        \
    })

FIELD_GET() - extract a bitfield element @_mask: shifted mask defining the field's length and position @_reg: value of entire bitfield

FIELD_GET() extracts the field specified by @_mask from the bitfield passed in as @_reg by masking and shifting it down.

field_get

#define field_get	(		mask,
			reg
	)

Value:

    (__builtin_constant_p(mask) ? __FIELD_GET(mask, reg, "field_get: ") \
                    : __field_get(mask, reg))

field_get() - extract a bitfield element @mask: shifted mask defining the field's length and position, must be non-zero @reg: value of entire bitfield

Return: extracted field value

field_get() extracts the field specified by @mask from the bitfield passed in as @reg by masking and shifting it down. Unlike FIELD_GET(), @mask is not limited to a compile-time constant. Typical usage patterns are a value stored in a table, or calculated by shifting a constant by a variable number of bits. If you want to ensure that @mask is a compile-time constant, please use FIELD_GET() directly instead.

FIELD_GET_SIGNED

#define FIELD_GET_SIGNED	(		mask,
			reg
	)

Value:

    ({                              \
        __BF_FIELD_CHECK(mask, reg, 0U, "FIELD_GET_SIGNED: ");  \
         ((__signed_scalar_typeof(mask))            \
          (((long long)(reg) << __builtin_clzll(mask)) >>   \
           (__builtin_clzll(mask) + __builtin_ctzll(mask))));   \
    })

FIELD_GET_SIGNED() - extract a signed bitfield element @mask: shifted mask defining the field's length and position @reg: value of entire bitfield

Returns the sign-extended field specified by @_mask from the bitfield passed in as @reg by masking and shifting it down.

FIELD_MAX

#define FIELD_MAX

(

_mask

)

Value:

    ({                              \
        __BF_FIELD_CHECK(_mask, 0ULL, 0ULL, "FIELD_MAX: "); \
        (typeof(_mask))((_mask) >> __bf_shf(_mask));        \
    })

FIELD_MAX() - produce the maximum value representable by a field @_mask: shifted mask defining the field's length and position

FIELD_MAX() returns the maximum value that can be held in the field specified by @_mask.

field_max

#define field_max

(

field

)

((typeof(field))field_mask(field))

FIELD_MODIFY

#define FIELD_MODIFY	(		_mask,
			_reg_p,
			_val
	)

Value:

    ({                                      \
        typecheck_pointer(_reg_p);                      \
        __BF_FIELD_CHECK(_mask, *(_reg_p), _val, "FIELD_MODIFY: ");     \
        *(_reg_p) &= ~(_mask);                          \
        *(_reg_p) |= (((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask));    \
    })

FIELD_MODIFY() - modify a bitfield element @_mask: shifted mask defining the field's length and position @_reg_p: pointer to the memory that should be updated @_val: value to store in the bitfield

FIELD_MODIFY() modifies the set of bits in @_reg_p specified by @_mask, by replacing them with the bitfield value passed in as @_val.

FIELD_PREP

#define FIELD_PREP	(		_mask,
			_val
	)

Value:

    ({                              \
        __BF_FIELD_CHECK_REG(_mask, 0ULL, "FIELD_PREP: ");  \
        __FIELD_PREP(_mask, _val, "FIELD_PREP: ");      \
    })

FIELD_PREP() - prepare a bitfield element @_mask: shifted mask defining the field's length and position @_val: value to put in the field

FIELD_PREP() masks and shifts up the value. The result should be combined with other fields of the bitfield using logical OR.

field_prep

#define field_prep	(		mask,
			val
	)

Value:

    (__builtin_constant_p(mask) ? __FIELD_PREP(mask, val, "field_prep: ") \
                    : __field_prep(mask, val))

field_prep() - prepare a bitfield element @mask: shifted mask defining the field's length and position, must be non-zero @val: value to put in the field

Return: field value masked and shifted to its final destination

field_prep() masks and shifts up the value. The result should be combined with other fields of the bitfield using logical OR. Unlike FIELD_PREP(), @mask is not limited to a compile-time constant. Typical usage patterns are a value stored in a table, or calculated by shifting a constant by a variable number of bits. If you want to ensure that @mask is a compile-time constant, please use FIELD_PREP() directly instead.

FIELD_PREP_CONST

#define FIELD_PREP_CONST	(		_mask,
			_val
	)

Value:

    (                               \
        /* mask must be non-zero */             \
        BUILD_BUG_ON_ZERO((_mask) == 0) +           \
        /* check if value fits */               \
        BUILD_BUG_ON_ZERO(~((_mask) >> __bf_shf(_mask)) & (_val)) + \
        /* check if mask is contiguous */           \
        __BF_CHECK_POW2((_mask) + (1ULL << __bf_shf(_mask))) +  \
        /* and create the value */              \
        (((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask))  \
    )

FIELD_PREP_CONST() - prepare a constant bitfield element @_mask: shifted mask defining the field's length and position @_val: value to put in the field

FIELD_PREP_CONST() masks and shifts up the value. The result should be combined with other fields of the bitfield using logical OR.

Unlike FIELD_PREP() this is a constant expression and can therefore be used in initializers. Error checking is less comfortable for this version, and non-constant masks cannot be used.

Function Documentation

__compiletime_error() [1/2]

void __compiletime_error ( "bad bitfield mask"  )

extern

__compiletime_error() [2/2]

void __compiletime_error ( "value doesn't fit into mask"  )

extern