bit_manip.h

#pragma once
#include "libmicroemu/internal/utils/traits.h"
#include "libmicroemu/types.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace libmicroemu::internal {
 
template <typename T> class BitManip {
  // clang-format off
    static_assert(
        std::is_same<T, u64>::value ||
        std::is_same<T, u32>::value ||
        std::is_same<T, u16>::value || 
        std::is_same<T, u8>::value,
        "BitManip only works for u32, u16 and u8");
  // clang-format on
public:
  template <T alignment> static constexpr T AlignDown(const T &address) {
    if (alignment == 0U)
      return address;
    return address & ~(alignment - 1U);
  }

  template <T alignment> static constexpr T AlignUp(const T &address) {
    if (alignment == 0U) {
      return address;
    }
    return (address + (alignment - 1U)) & ~(alignment - 1U);
  }

  template <unsigned bit> static constexpr T GenerateBitMask() {
    return static_cast<T>(static_cast<T>(1U) << bit);
  }

  template <unsigned last_bit, unsigned first_bit> static constexpr T GenerateBitMask() {
 
    if constexpr (last_bit == sizeof(T) * 8U - 1U) {
      T constexpr msk = ~static_cast<T>(0U);
      return static_cast<T>(msk << first_bit);
    } else {
      auto constexpr shift_range = last_bit - first_bit + 1U;
      T constexpr one = static_cast<T>(1U);
      T constexpr msk = (one << shift_range) - one;
      return static_cast<T>(msk << first_bit);
    }
  }

  static constexpr T GenerateBitMask(unsigned last_bit, unsigned first_bit) {
    if (last_bit == sizeof(T) * 8U - 1U) {
      T constexpr msk = ~static_cast<T>(0U);
      return static_cast<T>(msk << first_bit);
    } else {
      auto shift_range = last_bit - first_bit + 1U;
      T constexpr one = static_cast<T>(1U);
      T msk = (one << shift_range) - one;
      return static_cast<T>(msk << first_bit);
    }
  }

  template <unsigned bit> static constexpr T IsolateBit(const T &value) {
    return (value & (static_cast<T>(1U) << bit)) >> bit;
  }

  template <unsigned bit> static constexpr bool IsBitSet(const T &value) {
    return (value & (static_cast<T>(1U) << bit)) != 0;
  }

  template <unsigned last_bit, unsigned first_bit>
  static constexpr T ExtractBits1R(const T &value) {
    return (value & GenerateBitMask<last_bit, first_bit>()) >> first_bit;
  }

  template <typename U> static U ExtractType(T value, u32 start_byte) {
    assert(start_byte >= 0U && start_byte <= (sizeof(T) - 1U));
    auto bitpos = start_byte * 8U;
    auto constexpr bitmask = GenerateBitMask<sizeof(U) * 8U - 1U, 0U>() - 1U;
    return static_cast<U>((value >> bitpos) & bitmask);
  }

  template <typename U> static T InsertType(T value, u32 start_byte, U insert_val) {
    assert(start_byte >= 0U && start_byte <= (sizeof(T) - 1U));
    auto start_pos = start_byte * 8U;
    auto end_pos = start_pos + sizeof(U) * 8 - 1U;
 
    auto mask = GenerateBitMask(end_pos, start_pos);
    auto shifted_bits = static_cast<T>(insert_val) << start_pos;
    return (value & (~mask)) | (shifted_bits & mask);
  }

  template <unsigned r2_last_bit, unsigned r2_first_bit, unsigned r1_last_bit,
            unsigned r1_first_bit>
  static constexpr T ExtractBits2R(const T &value) {
    return ((value & GenerateBitMask<r2_last_bit, r2_first_bit>()) >>
            (r2_first_bit - r1_last_bit + r1_first_bit - 1U)) +
           ((value & GenerateBitMask<r1_last_bit, r1_first_bit>()) >> (r1_first_bit));
  }

  template <typename U> static inline U ZeroExtend(const T &value) {
    static_assert(std::is_same<U, u32>::value || std::is_same<U, u16>::value ||
                      std::is_same<U, u8>::value,
                  "ZeroExtend only works for u32, u16 and u8");
    return static_cast<U>(value);
  }

  template <typename U, unsigned top_bit> static inline U SignExtend(const T &value) {
    static_assert(std::is_same<U, u32>::value || std::is_same<U, u16>::value ||
                      std::is_same<U, u8>::value,
                  "ZeroExtend only works for u32, u16 and u8");
    T s = (value >> top_bit) & 0x1U;
    U bitmask = BitManip<U>::template GenerateBitMask<no_of_bits<U>::N, top_bit>();
    U value_u = static_cast<U>(value);
    if (s) {
      value_u = value_u | bitmask;
    } else {
      value_u = value_u & ~bitmask;
    }
    return value_u;
  }

  static T IsZeroBit(const T &value) {
    return value == static_cast<T>(0U) ? static_cast<T>(1U) : static_cast<T>(0U);
  }

  static T BitCount(const T &value) {
    T v{value};
    T c{0U}; // c accumulates the total bits set in v
    for (; v; c++) {
      v &= v - 1U; // clear the least significant bit set
    }
    return c;
  }

  static T LowestBitSet(const T &value) {
    T x{value};
    if (x == 0)
      return no_of_bits<T>::N;
 
    T result = 0;
    while ((x & 1) == 0) {
      x >>= 1;
      result++;
    }
 
    return result;
  }
  static T CountLeadingZeros(const T &value) {
    int n{32U};
    u32 y{0U};
    u32 x{value};
 
    y = x >> 16U;
    if (y != 0U) {
      n = n - 16U;
      x = y;
    }
    y = x >> 8U;
    if (y != 0U) {
      n = n - 8U;
      x = y;
    }
    y = x >> 4U;
    if (y != 0U) {
      n = n - 4U;
      x = y;
    }
    y = x >> 2U;
    if (y != 0U) {
      n = n - 2U;
      x = y;
    }
    y = x >> 1U;
    if (y != 0U) {
      return n - 2U;
    }
 
    return n - x;
  }
 
private:
  BitManip() = delete;

  ~BitManip() = delete;

  BitManip(const BitManip &r_src) = delete;

  BitManip &operator=(const BitManip &r_src) = delete;

  BitManip(BitManip &&r_src) = delete;

  BitManip &operator=(BitManip &&r_src) = delete;
};
 
using Bm8 = BitManip<u8>;
using Bm16 = BitManip<u16>;
using Bm32 = BitManip<u32>;
 
} // namespace libmicroemu::internal