bits.hpp

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <limits>
#include <stdint.h>
#include <assert.h>
 
 
namespace microstrain
{
 
//
// bitmaskXXX
//
 
template<typename T>
constexpr T bitmaskFirstN(unsigned int nbits)
{
    static_assert(std::is_unsigned<T>::value, "Register type must be unsigned.");
    assert(nbits <= std::numeric_limits<T>::digits);
 
    nbits &= std::numeric_limits<T>::digits - 1;
    return T( T(1u) << nbits ) - 1;
}
 
template<typename T>
constexpr T bitmaskN(unsigned int bitI, unsigned int nbits)
{
    assert(bitI < std::numeric_limits<T>::digits);
    return bitmaskFirstN<T>(nbits) << bitI;
}
 
template<typename T>
constexpr T bitmaskItoJ(unsigned int bitI, unsigned int bitJ)
{
    assert(bitI <= bitJ);
    return bitmaskFirstN<T>(bitJ) & ~bitmaskFirstN<T>(bitI);
}
 
template<typename T>
constexpr T bitmaskIthruJ(unsigned int bitI, unsigned int bitJ)
{
    return bitmaskFirstN<T>(bitJ+1) & ~bitmaskFirstN<T>(bitI);
}
 
 
//
// testBit
//
 
 
template<typename RegType>
constexpr bool testBit(RegType reg, unsigned int bit)
{
    assert(bit < std::numeric_limits<RegType>::digits);  // bit must be less than the number of bits in T.
 
    return (reg >> bit) & 1u;
}
 
template<typename RegType>
constexpr void setBit(RegType& reg, unsigned int bit, bool value=true)
{
    assert(bit < std::numeric_limits<RegType>::digits);  // bit must be less than the number of bits in T.
 
    using T = typename std::remove_volatile<RegType>::type;
    T tmp = reg;
    tmp &= ~T(T(1) << bit);
    tmp |= T(value) << bit;
    reg = tmp;
}
 
//
// getRegisterBitXXX
//
 
 
template<typename RegType>
constexpr RegType getBitsN(RegType reg, unsigned int bitI, unsigned int nbits)
{
    assert(bitI < std::numeric_limits<RegType>::digits);  // BitI must be less than the number of bits in T.
 
    return (reg >> bitI) & bitmaskFirstN<RegType>(nbits);
}
 
template<typename RegType>
constexpr RegType getBitsItoJ(RegType reg, unsigned int bitI, unsigned int bitJ)
{
    assert(bitI < std::numeric_limits<RegType>::digits);  // BitI must be less than the number of bits in T.
 
    return (reg >> bitI) & bitmaskItoJ<RegType>(bitI, bitJ);
}
 
template<typename RegType>
constexpr RegType getBitsIthruJ(RegType reg, unsigned int bitI, unsigned int bitJ)
{
    assert(bitI < std::numeric_limits<RegType>::digits);  // BitI must be less than the number of bits in T.
 
    return (reg >> bitI) & bitmaskIthruJ<RegType>(bitI, bitJ);
}
 
 
//
// setRegisterBitXXX
//
 
 
template<typename RegType>
constexpr void setBitsN(RegType& reg, unsigned int bitI, unsigned int nbits)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp |= bitmaskN<T>(bitI, nbits);
    reg = tmp;
}
 
template<typename RegType>
constexpr void setBitsItoJ(RegType& reg, unsigned int bitI, unsigned int bitJ)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp |= bitmaskItoJ<T>(bitI, bitJ);
    reg = tmp;
}
 
template<typename RegType>
constexpr void setBitsIthruJ(RegType& reg, unsigned int bitI, unsigned int bitJ)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp |= bitmaskIthruJ<T>(bitI, bitJ);
    reg = tmp;
}
 
 
//
// clearRegisterBitXXX
//
 
 
template<typename RegType>
constexpr void clearBitsN(RegType& reg, unsigned int bitI, unsigned int nbits)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp &= ~bitmaskN<T>(bitI, nbits);
    reg = tmp;
}
 
template<typename RegType>
constexpr void clearBitsItoJ(RegType& reg, unsigned int bitI, unsigned int bitJ)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp &= ~bitmaskItoJ<T>(bitI, bitJ);
    reg = tmp;
}
 
template<typename RegType>
constexpr void clearBitsIthruJ(RegType& reg, unsigned int bitI, unsigned int bitJ)
{
    using T = typename std::remove_volatile<RegType>::type;
 
    T tmp = reg;
    tmp &= ~bitmaskIthruJ<T>(bitI, bitJ);
    reg = tmp;
}
 
 
//
// modifyBitsXXX
//
 
 
template<typename RegType, typename ValType>
constexpr void setBitsN(RegType& reg, unsigned int bitI, unsigned int nbits, ValType value)
{
    static_assert(std::is_unsigned<RegType>::value, "Register type must be unsigned.");
 
    using T = typename std::remove_volatile<RegType>::type;
 
    T valueT = value;
 
    assert(bitI < std::numeric_limits<T>::digits);         // bit I is within T
    assert(nbits <= std::numeric_limits<T>::digits-bitI);  // Sane number of bits
    assert((valueT & ~bitmaskFirstN<T>(nbits)) == 0);      // Value has no bits outside the window
 
    T tmp = reg;  // Do all operations on a local copy, in case T is volatile.
 
    const T mask = bitmaskN<T>(bitI, nbits);
 
    tmp &= ~mask;
    tmp |= (valueT << bitI) & mask;
 
    reg = tmp;  // Write back to register.
}
 
template<typename RegType, typename ValType>
constexpr void setBitsItoJ(RegType& reg, unsigned int bitI, unsigned int bitJ, ValType value)
{
    assert(bitJ >= bitI);  // J comes after I (non-negative number of bits)
 
    return setBitsN(reg, bitI, bitJ-bitI, value);
}
 
template<typename RegType, typename ValType>
constexpr void modifyBitsIthruJ(RegType& reg, unsigned int bitI, unsigned int bitJ, ValType value)
{
    return setBitsItoJ(reg, bitI, bitJ+1, value);
}
 
 
//
// BitfieldMemberXXX
//
 
 
namespace detail
{
    template<class TestType, bool IsEnum = std::is_enum<TestType>::value>
    struct BaseIntegerType
    {
        static_assert(std::is_integral<TestType>::value, "Type must be an integer.");
 
        using type = TestType;
    };
 
    template<class TestType>
    struct BaseIntegerType<TestType, true>
    {
        static_assert(std::is_enum<TestType>::value, "Expected an enum.");
 
        using type = typename std::underlying_type<TestType>::type;
    };
}
 
 
template<class T, unsigned int BitI, unsigned int Nbits>
struct BitfieldMemberN
{
    using Type = T;
    using BaseType = typename detail::BaseIntegerType<T>::type;
    static constexpr inline unsigned int bitI = BitI;
    static constexpr inline unsigned int nbits = Nbits;
 
    static_assert(std::numeric_limits<BaseType>::digits >= nbits, "T doesn't have enough bits");
 
    template<typename RegType>
    static constexpr T get(RegType reg) { return static_cast<Type>(getBitsN(reg, bitI, nbits)); }
 
    template<typename RegType>
    static constexpr void set(RegType& reg, Type value) { setBitsN(reg, bitI, nbits, static_cast<BaseType>(value)); }
 
    template<typename RegType>
    static constexpr void clear(RegType& reg) { clearBitsN(reg, bitI, nbits); }
};
 
 
template<class T, unsigned int BitI, unsigned int BitJ>
struct BitfieldMemberItoJ : public BitfieldMemberN<T, BitI, BitJ-BitI> {};
 
 
template<class T, unsigned int BitI, unsigned int BitJ>
struct BitfieldMemberIthruJ : public BitfieldMemberItoJ<T, BitI, BitJ+1> {};
 
 
 
template<unsigned int nbytes>
struct IntegerWithBytes {};
 
template<> struct IntegerWithBytes<8>
{
    using Unsigned = uint64_t;
    using Signed   = int64_t;
};
template<> struct IntegerWithBytes<7> : IntegerWithBytes<8> {};
template<> struct IntegerWithBytes<6> : IntegerWithBytes<8> {};
template<> struct IntegerWithBytes<5> : IntegerWithBytes<8> {};
template<> struct IntegerWithBytes<4>
{
    using Unsigned = uint32_t;
    using Signed   = int32_t;
};
template<> struct IntegerWithBytes<3> : IntegerWithBytes<4> {};
template<> struct IntegerWithBytes<2>
{
    using Unsigned = uint16_t;
    using Signed   = int16_t;
};
template<> struct IntegerWithBytes<1>
{
    using Unsigned = uint8_t;
    using Signed   = int8_t;
};
 
 
template<unsigned int nbits>
struct IntegerWithBits : IntegerWithBytes< (nbits+7)/8 > {};
 
 
}  // namespace microstrain::common