Subversion Repositories open8_urisc

// Free Software Foundation, Inc.

// Integer manipulation functions used by various targets when

// performing relocations.

template<int bits>

class Bits

{

 public:

  // Sign extend an n-bit unsigned integer stored in a uint32_t into

  // an int32_t.  BITS must be between 1 and 32.

  static inline int32_t

  sign_extend32(uint32_t val)

  {

    gold_assert(bits > 0 && bits <= 32);

    if (bits == 32)

      return static_cast<int32_t>(val);

    uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);

    val &= mask;

    uint32_t top_bit = 1U << (bits - 1);

    int32_t as_signed = static_cast<int32_t>(val);

    if ((val & top_bit) != 0)

      as_signed -= static_cast<int32_t>(top_bit * 2);

    return as_signed;

  }

  // Return true if VAL (stored in a uint32_t) has overflowed a signed

  // value with BITS bits.

  static inline bool

  has_overflow32(uint32_t val)

  {

    gold_assert(bits > 0 && bits <= 32);

    if (bits == 32)

      return false;

    int32_t max = (1 << (bits - 1)) - 1;

    int32_t min = -(1 << (bits - 1));

    int32_t as_signed = static_cast<int32_t>(val);

    return as_signed > max || as_signed < min;

  }

  // Return true if VAL (stored in a uint32_t) has overflowed both a

  // signed and an unsigned value.  E.g.,

  // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <

  // 255.

  static inline bool

  has_signed_unsigned_overflow32(uint32_t val)

  {

    gold_assert(bits > 0 && bits <= 32);

    if (bits == 32)

      return false;

    int32_t max = static_cast<int32_t>((1U << bits) - 1);

    int32_t min = -(1 << (bits - 1));

    int32_t as_signed = static_cast<int32_t>(val);

    return as_signed > max || as_signed < min;

  }

  // Select bits from A and B using bits in MASK.  For each n in

  // [0..31], the n-th bit in the result is chosen from the n-th bits

  // of A and B.  A zero selects A and a one selects B.

  static inline uint32_t

  bit_select32(uint32_t a, uint32_t b, uint32_t mask)

  { return (a & ~mask) | (b & mask); }

  // Sign extend an n-bit unsigned integer stored in a uint64_t into

  // an int64_t.  BITS must be between 1 and 64.

  static inline int64_t

  sign_extend(uint64_t val)

  {

    gold_assert(bits > 0 && bits <= 64);

    if (bits == 64)

      return static_cast<int64_t>(val);

    uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);

    val &= mask;

    uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);

    int64_t as_signed = static_cast<int64_t>(val);

    if ((val & top_bit) != 0)

      as_signed -= static_cast<int64_t>(top_bit * 2);

    return as_signed;

  }

  // Return true if VAL (stored in a uint64_t) has overflowed a signed

  // value with BITS bits.

  static inline bool

  has_overflow(uint64_t val)

  {

    gold_assert(bits > 0 && bits <= 64);

    if (bits == 64)

      return false;

    int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;

    int64_t min = -(static_cast<int64_t>(1) << (bits - 1));

    int64_t as_signed = static_cast<int64_t>(val);

    return as_signed > max || as_signed < min;

  }

  // Return true if VAL (stored in a uint64_t) has overflowed both a

  // signed and an unsigned value.  E.g.,

  // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <

  // 255.

  static inline bool

  has_signed_unsigned_overflow64(uint64_t val)

  {

    gold_assert(bits > 0 && bits <= 64);

    if (bits == 64)

      return false;

    int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);

    int64_t min = -(static_cast<int64_t>(1) << (bits - 1));

    int64_t as_signed = static_cast<int64_t>(val);

    return as_signed > max || as_signed < min;

  }

  // Select bits from A and B using bits in MASK.  For each n in

  // [0..31], the n-th bit in the result is chosen from the n-th bits

  // of A and B.  A zero selects A and a one selects B.

  static inline uint64_t

  bit_select64(uint64_t a, uint64_t b, uint64_t mask)

  { return (a & ~mask) | (b & mask); }

};