+ Addendtype addend,
+ Address address)
+ { This::template pcrela<64>(view, object, psymval, addend, address,
+ CHECK_NONE); }
+};
+
+// Convenience class for min and max values of a given BITS length.
+
+template<int bits>
+class Limits
+{
+ public:
+ static const uint64_t MAX_UNSIGNED = (1ULL << bits) - 1;
+ static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
+ static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
+};
+
+template<>
+class Limits<64>
+{
+ public:
+ static const uint64_t MAX_UNSIGNED = ~0ULL;
+ static const int64_t MAX_SIGNED = MAX_UNSIGNED >> 1;
+ static const int64_t MIN_SIGNED = -MAX_SIGNED - 1;
+};
+
+// 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;
+ const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_SIGNED);
+ const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
+ 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 an unsigned
+ // value with BITS bits.
+ static inline bool
+ has_unsigned_overflow32(uint32_t val)
+ {
+ gold_assert(bits > 0 && bits <= 32);
+ if (bits == 32)
+ return false;
+ const uint32_t max = static_cast<uint32_t>(Limits<bits>::MAX_UNSIGNED);
+ return val > max;
+ }
+
+ // 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;
+ const int32_t max = static_cast<int32_t>(Limits<bits>::MAX_UNSIGNED);
+ const int32_t min = static_cast<int32_t>(Limits<bits>::MIN_SIGNED);
+ 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;
+ const int64_t max = Limits<bits>::MAX_SIGNED;
+ const int64_t min = Limits<bits>::MIN_SIGNED;
+ 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 an unsigned
+ // value with BITS bits.
+ static inline bool
+ has_unsigned_overflow(uint64_t val)
+ {
+ gold_assert(bits > 0 && bits <= 64);
+ if (bits == 64)
+ return false;
+ const uint64_t max = Limits<bits>::MAX_UNSIGNED;
+ return val > max;
+ }
+
+ // 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;
+ const int64_t max = static_cast<int64_t>(Limits<bits>::MAX_UNSIGNED);
+ const int64_t min = Limits<bits>::MIN_SIGNED;
+ 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); }