bitfield

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2012 Alexander Warg <warg@os.inf.tu-dresden.de>,
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
 
#pragma once
 
#include "type_list"
 
namespace cxx {
 
template<typename T, unsigned LSB, unsigned MSB>
class Bitfield
{
private:
  static_assert(MSB >= LSB, "boundary mismatch in bit-field definition");
  static_assert(MSB < sizeof(T) * 8, "MSB outside of bit-field type");
  static_assert(LSB < sizeof(T) * 8, "LSB outside of bit-field type");
 
  template<unsigned BITS> struct Best_type
  {
    template< typename TY > struct Cmp { enum { value = (BITS <= sizeof(TY)*8) }; };
    typedef cxx::type_list<
      unsigned char,
      unsigned short,
      unsigned int,
      unsigned long,
      unsigned long long
    > Unsigned_types;
    typedef cxx::find_type_t<Unsigned_types, Cmp> Type;
  };
 
public:
  enum
  {
    Bits  = MSB + 1 - LSB, 
    Lsb = LSB,             
    Msb = MSB,             
  };
 
  enum Masks : T
  {
    Low_mask = ((T)~0ULL) >> (sizeof(T)*8 - Bits),
    Mask     = Low_mask << Lsb,
  };
 
  typedef typename Best_type<Bits>::Type Bits_type;
 
  typedef typename Best_type<Bits + Lsb>::Type Shift_type;
 
private:
  static_assert(sizeof(Bits_type)*8 >= Bits, "error finding the type to store the bits");
  static_assert(sizeof(Shift_type)*8 >= Bits + Lsb, "error finding the type to keep the shifted bits");
  static_assert(sizeof(Bits_type) <= sizeof(T), "size mismatch for Bits_type");
  static_assert(sizeof(Shift_type) <= sizeof(T), "size mismatch for Shift_type");
  static_assert(sizeof(Bits_type) <= sizeof(Shift_type), "size mismacht for Shift_type and Bits_type");
 
public:
  static Bits_type get(Shift_type val)
  { return (val >> Lsb) & Low_mask; }
 
  static T get_unshifted(Shift_type val)
  { return val & Mask; }
 
  static T set_dirty(T dest, Shift_type val)
  {
    //assert (!(val & ~Low_mask));
    return (dest & ~Mask) | (val << Lsb);
  }
 
  static T set_unshifted_dirty(T dest, Shift_type val)
  {
    //assert (!(val & ~Mask));
    return (dest & ~Mask) | val;
  }
 
  static T set(T dest, Bits_type val)
  { return set_dirty(dest, val & Low_mask); }
 
  static T set_unshifted(T dest, Shift_type val)
  { return set_unshifted_dirty(dest, val & Mask); }
 
  static T val_dirty(Shift_type val) { return val << Lsb; }
 
  static T val(Bits_type val) { return val_dirty(val & Low_mask); }
 
  static T val_unshifted(Shift_type val) { return val & Mask; }
 
  template< typename TT >
  class Value_base
  {
  private:
    TT v;
 
  public:
    Value_base(TT t) : v(t) {}
    Bits_type get() const { return Bitfield::get(v); }
    T get_unshifted() const { return Bitfield::get_unshifted(v); }
 
    void set(Bits_type val) { v = Bitfield::set(v, val); }
    void set_dirty(Bits_type val) { v = Bitfield::set_dirty(v, val); }
    void set_unshifted(Shift_type val) { v = Bitfield::set_unshifted(v, val); }
    void set_unshifted_dirty(Shift_type val) { v = Bitfield::set_unshifted_dirty(v, val); }
  };
 
  template< typename TT >
  class Value : public Value_base<TT>
  {
  public:
    Value(TT t) : Value_base<TT>(t) {}
    operator Bits_type () const { return this->get(); }
    Value &operator = (Bits_type val) { this->set(val); return *this; }
    Value &operator = (Value const &o) { this->set(o.get()); return *this; }
    // This copy constructor initializes more bits than necessary but this is
    // usually not a problem.
    Value (Value const &o) = default;
  };
 
  template< typename TT >
  class Value_unshifted : public Value_base<TT>
  {
  public:
    Value_unshifted(TT t) : Value_base<TT>(t) {}
    operator Shift_type () const { return this->get_unshifted(); }
    Value_unshifted &operator = (Shift_type val) { this->set_unshifted(val); return *this; }
    Value_unshifted &operator = (Value_unshifted const &o)
    {
      this->set_unshifted(o.get_unshifted());
      return *this;
    }
    // This copy constructor initializes more bits than necessary but this is
    // usually not a problem.
    Value_unshifted(Value_unshifted const &) = default;
  };
 
  typedef Value<T&> Ref;
  typedef Value<T const> Val;
 
  typedef Value_unshifted<T&> Ref_unshifted;
  typedef Value_unshifted<T const> Val_unshifted;
};
 
#define CXX_BITFIELD_MEMBER(LSB, MSB, name, data_member) \
 \
 \
  typedef cxx::Bitfield<decltype(data_member), LSB, MSB> name ## _bfm_t; \
 \
  typename name ## _bfm_t::Val name() const { return data_member; } \
 \
  typename name ## _bfm_t::Ref name() { return data_member; } \
 
#define CXX_BITFIELD_MEMBER_RO(LSB, MSB, name, data_member) \
 \
 \
  typedef cxx::Bitfield<decltype(data_member), LSB, MSB> name ## _bfm_t; \
 \
  typename name ## _bfm_t::Val name() const { return data_member; } \
 
#define CXX_BITFIELD_MEMBER_UNSHIFTED(LSB, MSB, name, data_member) \
 \
 \
  typedef cxx::Bitfield<decltype(data_member), LSB, MSB> name ## _bfm_t; \
 \
  typename name ## _bfm_t::Val_unshifted name() const { return data_member; } \
 \
  typename name ## _bfm_t::Ref_unshifted name() { return data_member; } \
 
#define CXX_BITFIELD_MEMBER_UNSHIFTED_RO(LSB, MSB, name, data_member) \
 \
 \
  typedef cxx::Bitfield<decltype(data_member), LSB, MSB> name ## _bfm_t; \
 \
  typename name ## _bfm_t::Val_unshifted name() const { return data_member; } \
 
}