Bitmanip.h

Go to the documentation of this file.

//===-- temu-c/Bitmanip.h - Low level bit/byte manipulation -----*- C++ -*-===//
//
// T-EMU: The Terma Emulator
// (c) Terma 2015
// Authors: Mattias Holm <maho (at) terma.com>
//
//===----------------------------------------------------------------------===//

#ifndef TEMU_BITMANIP_H
#define TEMU_BITMANIP_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

// Swap half words inside 32 bit word
static inline uint32_t
temu_swap32Half(uint32_t Word)
{
  uint32_t Res = Word << 16 | Word >> 16;
  return Res;
}

// Swap words inside 64 bit word
static inline uint64_t
temu_swap64Word(uint64_t DWord)
{
  uint64_t Res = DWord << 32 | DWord >> 32;
  return Res;
}


// Swap bytes in 16 bit word
static inline uint16_t
temu_swap16(uint16_t HWord)
{
#if 1
  uint16_t Res = __builtin_bswap16(HWord);
#else
  uint16_t Res = HWord << 8 | HWord >> 8;
#endif
  return Res;
}

// Swap bytes in 32 bit word
static inline uint32_t
temu_swap32(uint32_t Word)
{
#if 1
  uint32_t Res = __builtin_bswap32(Word);
#else
  uint32_t Res = (((uint32_t)temu_swap16(Word)) << 16)
    | (uint32_t)temu_swap16(Word >> 16);
#endif
  return Res;
}

// Swap bytes in 64 bit word
static inline uint64_t
temu_swap64(uint64_t DWord)
{
#if 1
  uint64_t Res = __builtin_bswap64(DWord);
#else
  uint64_t Res = (((uint64_t)temu_swap32(DWord)) << 32)
    | (uint64_t)temu_swap32(DWord >> 32);
#endif
  return Res;
}

// Swap between big endian and host endian. Note that at present we
// only have little endian hosts, so these functions simply
// wrap. However, they declare intent and it is recommended that you
// use these for swapping when you want to go between little<->host
// and big<->host.

static inline uint32_t
temu_swapBigHost32Half(uint32_t Word)
{
  return temu_swap32Half(Word);
}


static inline uint64_t
temu_swapBigHost64Word(uint64_t DWord)
{
  return temu_swap64Word(DWord);
}


static inline uint32_t
temu_swapLittleHost32Half(uint32_t Word)
{
  return Word;
}


static inline uint64_t
temu_swapLittleHost64Word(uint64_t DWord)
{
  return DWord;
}


static inline uint16_t
temu_swapBigHost16(uint16_t HWord)
{
  return temu_swap16(HWord);
}

static inline uint32_t
temu_swapBigHost32(uint32_t Word)
{
  return temu_swap32(Word);
}

static inline uint64_t
temu_swapBigHost64(uint64_t DWord)
{
  return temu_swap64(DWord);
}

static inline uint16_t
temu_swapLittleHost16(uint16_t HWord)
{
  return HWord;
}

static inline uint32_t
temu_swapLittleHost32(uint32_t Word)
{
  return Word;
}

static inline uint64_t
temu_swapLittleHost64(uint64_t DWord)
{
  return DWord;
}


// Count trailing zeroes, this can be used as a square root on a power
// of 2 word.
static inline int
temu_ctz32(uint32_t Word)
{
  if (Word == 0) return 32; // Due to semantics of compiler ctz
  int Res = __builtin_ctz(Word);
  return Res;
}

// Count leading zeroes
static inline int
temu_clz32(uint32_t Word)
{
  if (Word == 0) return 32;
  int Res = __builtin_clz(Word);
  return Res;
}

// Count number of bits set in word
static inline int
temu_popcount32(uint32_t Word)
{
  int Res = __builtin_popcount(Word);
  return Res;
}

// Compute parity of word
static inline int
temu_parity32(uint32_t Word)
{
  int Res = __builtin_parity(Word);
  return Res;
}


// Count trailing zeroes
static inline int
temu_ctz64(uint64_t Word)
{
  if (Word == 0) return 64;
  int Res = __builtin_ctzl(Word);
  return Res;
}

// Count leading zeroes
static inline int
temu_clz64(uint64_t Word)
{
  if (Word == 0) return 64;
  int Res = __builtin_clzl(Word);
  return Res;
}

// Count count number of bit set
static inline int
temu_popcount64(uint64_t Word)
{
  int Res = __builtin_popcountl(Word);
  return Res;
}

// Compute parity
static inline int
temu_parity64(uint64_t Word)
{
  int Res = __builtin_parityl(Word);
  return Res;
}

// Predicate for checking if word is a power of 2
// See Hacker's Delight, 1st edition, p11
static inline int
temu_isPow2_32(uint32_t Word)
{
  if (Word) {
    return (Word & (Word - 1)) == 0;
  }
  return 0;
}

// Predicate for checking if word is a power of 2
//
static inline int
temu_isPow2_64(uint64_t Word)
{
  if (Word) {
    return (Word & (Word - 1)) == 0;
  }
  return 0;
}

// Clear lower set bit in word
static inline uint32_t
temu_clearLeftmostBit32(uint32_t Word)
{
  return Word & (Word - 1);
}

static inline uint64_t
temu_clearLeftmostBit64(uint64_t Word)
{
  return Word & (Word - 1);
}

// Set right most bit that is zero
static inline uint32_t
temu_setRightmostZeroBit32(uint32_t Word)
{
  return Word | (Word + 1);
}

static inline uint64_t
temu_setRightmostZeoroBit64(uint64_t Word)
{
  return Word | (Word + 1);
}

// Isolate left most bit
static inline uint32_t
temu_isolateLeftmostBit32(uint32_t Word)
{
  return Word & -Word;
}

static inline uint64_t
temu_isolateLeftmostBit64(uint64_t Word)
{
  return Word & -Word;

}

// Isolate right most bit with value zero (it will be 1 in the result)
static inline uint32_t
temu_isolateRightMostZeroBit32(uint32_t Word)
{
  return (~Word) & (Word+1);
}
static inline uint64_t
temu_isolateRightMostZeroBit64(uint64_t Word)
{
  return (~Word) & (Word+1);
}

// Get word with all trailing zeroes set
static inline uint32_t
temu_identifyTrailingZeroes32(uint32_t Word)
{
  return (~Word) & (Word-1);
}


static inline uint64_t
temu_identifyTrailingZeroes64(uint64_t Word)
{
  return (~Word) & (Word-1);
}

// Get word with all trailing zeroes set, and the fist bit set
static inline uint32_t
temu_identifyTrailingZeroesAndFirst32(uint32_t Word)
{
  return Word ^ (Word-1);
}


static inline uint64_t
temu_identifyTrailingZeroesAndFirst64(uint64_t Word)
{
  return Word ^ (Word-1);
}


static inline uint32_t
temu_propagateRightMostBit32(uint32_t Word)
{
  return Word | (Word-1);
}

static inline uint64_t
temu_propagateRightMostBit64(uint64_t Word)
{
  return Word | (Word-1);
}

static inline uint32_t
temu_clearRightMostBits32(uint32_t Word)
{
  return ((Word | (Word-1)) + 1) & Word;
}

static inline uint64_t
temu_clearRightMostBits64(uint64_t Word)
{
  return ((Word | (Word-1)) + 1) & Word;
}



#ifdef __cplusplus
}
#endif

#endif /* !TEMU_BITMANIP_H */