Export of internal Abseil changes
-- d447fdcb801036cf08197eece193a5a706661120 by Gennadiy Rozental <rogeeff@google.com>: Eliminate the need for static function holding help message. This decreases the cost of ABSL_FLAG abstraction by 120 bytes under clang. PiperOrigin-RevId: 281107806 -- 0aa6b91189f0e8b2381438c33465673a7ae02487 by Derek Mauro <dmauro@google.com>: Disable the weak symbol CCTZ extension in the time test_util on MinGW, which does not support it. PiperOrigin-RevId: 280719769 -- 67322c41c3e776eb541de90fa4526bdb49422eb6 by Abseil Team <absl-team@google.com>: Tune PeriodicSampler implementation (for internal-use only) PiperOrigin-RevId: 280708943 -- 3a48c346340c7ed03816645cd327e1ff07729aa4 by Abseil Team <absl-team@google.com>: Clean up public headers not to have warnings for "-Wcomma" PiperOrigin-RevId: 280695373 -- 981acd1ef3b13a83a84f04f11c8931f4ed4451c9 by Matthew Brown <matthewbr@google.com>: Release absl::int128. PiperOrigin-RevId: 280690817 -- d30fae9d2ec30b81322d2eb5afe7e13e45b4b422 by Derek Mauro <dmauro@google.com>: Fix -Wundef warnings in random platform detection PiperOrigin-RevId: 280669598 GitOrigin-RevId: d447fdcb801036cf08197eece193a5a706661120 Change-Id: Ie5e10e567c54b7de211833607689f233d4ddf734
This commit is contained in:
Abseil Team
Gennadiy Civil
parent
3df7b52a6a
commit
2103fd9acd
23 changed files with 2800 additions and 136 deletions
|
|
@ -17,10 +17,7 @@
|
|||
// File: int128.h
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// This header file defines 128-bit integer types.
|
||||
//
|
||||
// Currently, this file defines `uint128`, an unsigned 128-bit integer;
|
||||
// a signed 128-bit integer is forthcoming.
|
||||
// This header file defines 128-bit integer types, `uint128` and `int128`.
|
||||
|
||||
#ifndef ABSL_NUMERIC_INT128_H_
|
||||
#define ABSL_NUMERIC_INT128_H_
|
||||
|
|
@ -53,6 +50,8 @@
|
|||
|
||||
namespace absl {
|
||||
|
||||
class int128;
|
||||
|
||||
// uint128
|
||||
//
|
||||
// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
|
||||
|
|
@ -116,6 +115,7 @@ class
|
|||
constexpr uint128(__int128 v); // NOLINT(runtime/explicit)
|
||||
constexpr uint128(unsigned __int128 v); // NOLINT(runtime/explicit)
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr uint128(int128 v); // NOLINT(runtime/explicit)
|
||||
explicit uint128(float v);
|
||||
explicit uint128(double v);
|
||||
explicit uint128(long double v);
|
||||
|
|
@ -131,6 +131,7 @@ class
|
|||
uint128& operator=(__int128 v);
|
||||
uint128& operator=(unsigned __int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
uint128& operator=(int128 v);
|
||||
|
||||
// Conversion operators to other arithmetic types
|
||||
constexpr explicit operator bool() const;
|
||||
|
|
@ -291,7 +292,238 @@ class numeric_limits<absl::uint128> {
|
|||
};
|
||||
} // namespace std
|
||||
|
||||
// TODO(absl-team): Implement signed 128-bit type
|
||||
namespace absl {
|
||||
|
||||
// int128
|
||||
//
|
||||
// A signed 128-bit integer type. The API is meant to mimic an intrinsic
|
||||
// integral type as closely as is practical, including exhibiting undefined
|
||||
// behavior in analogous cases (e.g. division by zero).
|
||||
//
|
||||
// An `int128` supports the following:
|
||||
//
|
||||
// * Implicit construction from integral types
|
||||
// * Explicit conversion to integral types
|
||||
//
|
||||
// However, an `int128` differs from intrinsic integral types in the following
|
||||
// ways:
|
||||
//
|
||||
// * It is not implicitly convertible to other integral types.
|
||||
// * Requires explicit construction from and conversion to floating point
|
||||
// types.
|
||||
|
||||
// Additionally, if your compiler supports `__int128`, `int128` is
|
||||
// interoperable with that type. (Abseil checks for this compatibility through
|
||||
// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
|
||||
//
|
||||
// The design goal for `int128` is that it will be compatible with a future
|
||||
// `int128_t`, if that type becomes a part of the standard.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// float y = absl::int128(17); // Error. int128 cannot be implicitly
|
||||
// // converted to float.
|
||||
//
|
||||
// absl::int128 v;
|
||||
// int64_t i = v; // Error
|
||||
// int64_t i = static_cast<int64_t>(v); // OK
|
||||
//
|
||||
class int128 {
|
||||
public:
|
||||
int128() = default;
|
||||
|
||||
// Constructors from arithmetic types
|
||||
constexpr int128(int v); // NOLINT(runtime/explicit)
|
||||
constexpr int128(unsigned int v); // NOLINT(runtime/explicit)
|
||||
constexpr int128(long v); // NOLINT(runtime/int)
|
||||
constexpr int128(unsigned long v); // NOLINT(runtime/int)
|
||||
constexpr int128(long long v); // NOLINT(runtime/int)
|
||||
constexpr int128(unsigned long long v); // NOLINT(runtime/int)
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr int128(__int128 v); // NOLINT(runtime/explicit)
|
||||
constexpr explicit int128(unsigned __int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr explicit int128(uint128 v);
|
||||
explicit int128(float v);
|
||||
explicit int128(double v);
|
||||
explicit int128(long double v);
|
||||
|
||||
// Assignment operators from arithmetic types
|
||||
int128& operator=(int v);
|
||||
int128& operator=(unsigned int v);
|
||||
int128& operator=(long v); // NOLINT(runtime/int)
|
||||
int128& operator=(unsigned long v); // NOLINT(runtime/int)
|
||||
int128& operator=(long long v); // NOLINT(runtime/int)
|
||||
int128& operator=(unsigned long long v); // NOLINT(runtime/int)
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
int128& operator=(__int128 v);
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
// Conversion operators to other arithmetic types
|
||||
constexpr explicit operator bool() const;
|
||||
constexpr explicit operator char() const;
|
||||
constexpr explicit operator signed char() const;
|
||||
constexpr explicit operator unsigned char() const;
|
||||
constexpr explicit operator char16_t() const;
|
||||
constexpr explicit operator char32_t() const;
|
||||
constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
|
||||
constexpr explicit operator short() const; // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned short() const;
|
||||
constexpr explicit operator int() const;
|
||||
constexpr explicit operator unsigned int() const;
|
||||
constexpr explicit operator long() const; // NOLINT(runtime/int)
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned long() const;
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator long long() const;
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
constexpr explicit operator unsigned long long() const;
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
constexpr explicit operator __int128() const;
|
||||
constexpr explicit operator unsigned __int128() const;
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
explicit operator float() const;
|
||||
explicit operator double() const;
|
||||
explicit operator long double() const;
|
||||
|
||||
// Trivial copy constructor, assignment operator and destructor.
|
||||
|
||||
// Arithmetic operators
|
||||
int128& operator+=(int128 other);
|
||||
int128& operator-=(int128 other);
|
||||
int128& operator*=(int128 other);
|
||||
int128& operator/=(int128 other);
|
||||
int128& operator%=(int128 other);
|
||||
int128 operator++(int); // postfix increment: i++
|
||||
int128 operator--(int); // postfix decrement: i--
|
||||
int128& operator++(); // prefix increment: ++i
|
||||
int128& operator--(); // prefix decrement: --i
|
||||
int128& operator&=(int128 other);
|
||||
int128& operator|=(int128 other);
|
||||
int128& operator^=(int128 other);
|
||||
int128& operator<<=(int amount);
|
||||
int128& operator>>=(int amount);
|
||||
|
||||
// Int128Low64()
|
||||
//
|
||||
// Returns the lower 64-bit value of a `int128` value.
|
||||
friend constexpr uint64_t Int128Low64(int128 v);
|
||||
|
||||
// Int128High64()
|
||||
//
|
||||
// Returns the higher 64-bit value of a `int128` value.
|
||||
friend constexpr int64_t Int128High64(int128 v);
|
||||
|
||||
// MakeInt128()
|
||||
//
|
||||
// Constructs a `int128` numeric value from two 64-bit integers. Note that
|
||||
// signedness is conveyed in the upper `high` value.
|
||||
//
|
||||
// (absl::int128(1) << 64) * high + low
|
||||
//
|
||||
// Note that this factory function is the only way to construct a `int128`
|
||||
// from integer values greater than 2^64 or less than -2^64.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// absl::int128 big = absl::MakeInt128(1, 0);
|
||||
// absl::int128 big_n = absl::MakeInt128(-1, 0);
|
||||
friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
|
||||
|
||||
// Int128Max()
|
||||
//
|
||||
// Returns the maximum value for a 128-bit signed integer.
|
||||
friend constexpr int128 Int128Max();
|
||||
|
||||
// Int128Min()
|
||||
//
|
||||
// Returns the minimum value for a 128-bit signed integer.
|
||||
friend constexpr int128 Int128Min();
|
||||
|
||||
// Support for absl::Hash.
|
||||
template <typename H>
|
||||
friend H AbslHashValue(H h, int128 v) {
|
||||
return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
|
||||
}
|
||||
|
||||
private:
|
||||
constexpr int128(int64_t high, uint64_t low);
|
||||
|
||||
#if defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
__int128 v_;
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
#if defined(ABSL_IS_LITTLE_ENDIAN)
|
||||
uint64_t lo_;
|
||||
int64_t hi_;
|
||||
#elif defined(ABSL_IS_BIG_ENDIAN)
|
||||
int64_t hi_;
|
||||
uint64_t lo_;
|
||||
#else // byte order
|
||||
#error "Unsupported byte order: must be little-endian or big-endian."
|
||||
#endif // byte order
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, int128 v);
|
||||
|
||||
// TODO(absl-team) add operator>>(std::istream&, int128)
|
||||
|
||||
constexpr int128 Int128Max() {
|
||||
return int128((std::numeric_limits<int64_t>::max)(),
|
||||
(std::numeric_limits<uint64_t>::max)());
|
||||
}
|
||||
|
||||
constexpr int128 Int128Min() {
|
||||
return int128((std::numeric_limits<int64_t>::min)(), 0);
|
||||
}
|
||||
|
||||
} // namespace absl
|
||||
|
||||
// Specialized numeric_limits for int128.
|
||||
namespace std {
|
||||
template <>
|
||||
class numeric_limits<absl::int128> {
|
||||
public:
|
||||
static constexpr bool is_specialized = true;
|
||||
static constexpr bool is_signed = true;
|
||||
static constexpr bool is_integer = true;
|
||||
static constexpr bool is_exact = true;
|
||||
static constexpr bool has_infinity = false;
|
||||
static constexpr bool has_quiet_NaN = false;
|
||||
static constexpr bool has_signaling_NaN = false;
|
||||
static constexpr float_denorm_style has_denorm = denorm_absent;
|
||||
static constexpr bool has_denorm_loss = false;
|
||||
static constexpr float_round_style round_style = round_toward_zero;
|
||||
static constexpr bool is_iec559 = false;
|
||||
static constexpr bool is_bounded = true;
|
||||
static constexpr bool is_modulo = false;
|
||||
static constexpr int digits = 127;
|
||||
static constexpr int digits10 = 38;
|
||||
static constexpr int max_digits10 = 0;
|
||||
static constexpr int radix = 2;
|
||||
static constexpr int min_exponent = 0;
|
||||
static constexpr int min_exponent10 = 0;
|
||||
static constexpr int max_exponent = 0;
|
||||
static constexpr int max_exponent10 = 0;
|
||||
#ifdef ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool traps = numeric_limits<__int128>::traps;
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool traps = numeric_limits<uint64_t>::traps;
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
static constexpr bool tinyness_before = false;
|
||||
|
||||
static constexpr absl::int128 (min)() { return absl::Int128Min(); }
|
||||
static constexpr absl::int128 lowest() { return absl::Int128Min(); }
|
||||
static constexpr absl::int128 (max)() { return absl::Int128Max(); }
|
||||
static constexpr absl::int128 epsilon() { return 0; }
|
||||
static constexpr absl::int128 round_error() { return 0; }
|
||||
static constexpr absl::int128 infinity() { return 0; }
|
||||
static constexpr absl::int128 quiet_NaN() { return 0; }
|
||||
static constexpr absl::int128 signaling_NaN() { return 0; }
|
||||
static constexpr absl::int128 denorm_min() { return 0; }
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// Implementation details follow
|
||||
|
|
@ -339,6 +571,10 @@ inline uint128& uint128::operator=(unsigned __int128 v) {
|
|||
}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
inline uint128& uint128::operator=(int128 v) {
|
||||
return *this = uint128(v);
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
uint128 operator<<(uint128 lhs, int amount);
|
||||
|
|
@ -420,6 +656,9 @@ constexpr uint128::uint128(unsigned __int128 v)
|
|||
hi_{static_cast<uint64_t>(v >> 64)} {}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
constexpr uint128::uint128(int128 v)
|
||||
: lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
|
||||
|
||||
#elif defined(ABSL_IS_BIG_ENDIAN)
|
||||
|
||||
constexpr uint128::uint128(uint64_t high, uint64_t low)
|
||||
|
|
@ -450,6 +689,9 @@ constexpr uint128::uint128(unsigned __int128 v)
|
|||
lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
|
||||
#endif // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
||||
constexpr uint128::uint128(int128 v)
|
||||
: hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
|
||||
|
||||
#else // byte order
|
||||
#error "Unsupported byte order: must be little-endian or big-endian."
|
||||
#endif // byte order
|
||||
|
|
@ -719,6 +961,117 @@ inline uint128& uint128::operator--() {
|
|||
return *this;
|
||||
}
|
||||
|
||||
constexpr int128 MakeInt128(int64_t high, uint64_t low) {
|
||||
return int128(high, low);
|
||||
}
|
||||
|
||||
// Assignment from integer types.
|
||||
inline int128& int128::operator=(int v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
inline int128& int128::operator=(unsigned int v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
inline int128& int128::operator=(long v) { // NOLINT(runtime/int)
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(unsigned long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(long long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(runtime/int)
|
||||
inline int128& int128::operator=(unsigned long long v) {
|
||||
return *this = int128(v);
|
||||
}
|
||||
|
||||
// Arithmetic operators.
|
||||
|
||||
int128 operator+(int128 lhs, int128 rhs);
|
||||
int128 operator-(int128 lhs, int128 rhs);
|
||||
int128 operator*(int128 lhs, int128 rhs);
|
||||
int128 operator/(int128 lhs, int128 rhs);
|
||||
int128 operator%(int128 lhs, int128 rhs);
|
||||
int128 operator|(int128 lhs, int128 rhs);
|
||||
int128 operator&(int128 lhs, int128 rhs);
|
||||
int128 operator^(int128 lhs, int128 rhs);
|
||||
int128 operator<<(int128 lhs, int amount);
|
||||
int128 operator>>(int128 lhs, int amount);
|
||||
|
||||
inline int128& int128::operator+=(int128 other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator-=(int128 other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator*=(int128 other) {
|
||||
*this = *this * other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator/=(int128 other) {
|
||||
*this = *this / other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator%=(int128 other) {
|
||||
*this = *this % other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator|=(int128 other) {
|
||||
*this = *this | other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator&=(int128 other) {
|
||||
*this = *this & other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator^=(int128 other) {
|
||||
*this = *this ^ other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator<<=(int amount) {
|
||||
*this = *this << amount;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline int128& int128::operator>>=(int amount) {
|
||||
*this = *this >> amount;
|
||||
return *this;
|
||||
}
|
||||
|
||||
namespace int128_internal {
|
||||
|
||||
// Casts from unsigned to signed while preserving the underlying binary
|
||||
// representation.
|
||||
constexpr int64_t BitCastToSigned(uint64_t v) {
|
||||
// Casting an unsigned integer to a signed integer of the same
|
||||
// width is implementation defined behavior if the source value would not fit
|
||||
// in the destination type. We step around it with a roundtrip bitwise not
|
||||
// operation to make sure this function remains constexpr. Clang, GCC, and
|
||||
// MSVC optimize this to a no-op on x86-64.
|
||||
return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
|
||||
: static_cast<int64_t>(v);
|
||||
}
|
||||
|
||||
} // namespace int128_internal
|
||||
|
||||
#if defined(ABSL_HAVE_INTRINSIC_INT128)
|
||||
#include "absl/numeric/int128_have_intrinsic.inc" // IWYU pragma: export
|
||||
#else // ABSL_HAVE_INTRINSIC_INT128
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue