xref: /third_party/vixl/src/utils-vixl.h

113 constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
375 inline uint64_t RotateRight(uint64_t value,
382     value &= width_mask;
383     value = (value << (width - rotate)) | (value >> rotate);
385   return value & width_mask;
395   friend uint16_t Float16ToRawbits(Float16 value);
403 uint16_t Float16ToRawbits(Float16 value);
406 uint32_t FloatToRawbits(float value);
408                 inline uint32_t float_to_rawbits(float value)) {
409   return FloatToRawbits(value);
412 uint64_t DoubleToRawbits(double value);
414                 inline uint64_t double_to_rawbits(double value)) {
415   return DoubleToRawbits(value);
435 T UnsignedNegate(T value) {
436   VIXL_STATIC_ASSERT(std::is_unsigned<T>::value);
437   return ~value + 1;
447   VIXL_STATIC_ASSERT(std::is_signed<T>::value && std::is_integral<T>::value);
494 uint32_t Float16Sign(internal::SimFloat16 value);
496 uint32_t Float16Exp(internal::SimFloat16 value);
498 uint32_t Float16Mantissa(internal::SimFloat16 value);
500 uint32_t FloatSign(float value);
501 VIXL_DEPRECATED("FloatSign", inline uint32_t float_sign(float value)) {
502   return FloatSign(value);
505 uint32_t FloatExp(float value);
506 VIXL_DEPRECATED("FloatExp", inline uint32_t float_exp(float value)) {
507   return FloatExp(value);
510 uint32_t FloatMantissa(float value);
511 VIXL_DEPRECATED("FloatMantissa", inline uint32_t float_mantissa(float value)) {
512   return FloatMantissa(value);
515 uint32_t DoubleSign(double value);
516 VIXL_DEPRECATED("DoubleSign", inline uint32_t double_sign(double value)) {
517   return DoubleSign(value);
520 uint32_t DoubleExp(double value);
521 VIXL_DEPRECATED("DoubleExp", inline uint32_t double_exp(double value)) {
522   return DoubleExp(value);
525 uint64_t DoubleMantissa(double value);
527                 inline uint64_t double_mantissa(double value)) {
528   return DoubleMantissa(value);
552 int Float16Classify(Float16 value);
553 VIXL_DEPRECATED("Float16Classify", inline int float16classify(uint16_t value)) {
554   return Float16Classify(RawbitsToFloat16(value));
557 bool IsZero(Float16 value);
559 inline bool IsPositiveZero(double value) {
560   return (value == 0.0) && (copysign(1.0, value) > 0.0);
563 inline bool IsNaN(float value) { return std::isnan(value); }
565 inline bool IsNaN(double value) { return std::isnan(value); }
567 inline bool IsNaN(Float16 value) { return Float16Classify(value) == FP_NAN; }
569 inline bool IsInf(float value) { return std::isinf(value); }
571 inline bool IsInf(double value) { return std::isinf(value); }
573 inline bool IsInf(Float16 value) {
574   return Float16Classify(value) == FP_INFINITE;
645 inline uint64_t LowestSetBit(uint64_t value) {
646   return value & UnsignedNegate(value);
651 inline int HighestSetBitPosition(T value) {
652   VIXL_ASSERT(value != 0);
653   return (sizeof(value) * 8 - 1) - CountLeadingZeros(value);
658 inline int WhichPowerOf2(V value) {
659   VIXL_ASSERT(IsPowerOf2(value));
660   return CountTrailingZeros(value);
667 int BitCount(uint64_t value);
671 T ReverseBits(T value) {
672   VIXL_ASSERT((sizeof(value) == 1) || (sizeof(value) == 2) ||
673               (sizeof(value) == 4) || (sizeof(value) == 8));
675   for (unsigned i = 0; i < (sizeof(value) * 8); i++) {
676     result = (result << 1) | (value & 1);
677     value >>= 1;
695 T ReverseBytes(T value, int block_bytes_log2) {
696   VIXL_ASSERT((sizeof(value) == 4) || (sizeof(value) == 8));
697   VIXL_ASSERT((1U << block_bytes_log2) <= sizeof(value));
698   // Split the 64-bit value into an 8-bit array, where b[0] is the least
703     bytes[i] = (static_cast<uint64_t>(value) & mask) >> (i * 8);
728 inline bool IsMultiple(T value) {
730   return (value & (MULTIPLE - 1)) == 0;
734 inline bool IsMultiple(T value, unsigned multiple) {
736   return (value & (multiple - 1)) == 0;
799 inline T ExtractBit(T value, unsigned bit) {
800   return (value >> bit) & T(1);
804 inline Td ExtractBits(Ts value, int least_significant_bit, Td mask) {
805   return Td((value >> least_significant_bit) & Ts(mask));
811                       Ts value) {
812   VIXL_ASSERT((value == Ts(0)) || (value == Ts(1)));
817   dst |= Td(value) << bit;
824                        Ts value) {
829   VIXL_ASSERT((value & mask) == value);
831   dst |= Td(value) << least_significant_bit;
1011   bool operator==(Uint32 value) const { return data_ == value.data_; }
1012   bool operator!=(Uint32 value) const { return data_ != value.data_; }
1013   bool operator>(Uint32 value) const { return data_ > value.data_; }
1014   Uint32 operator+(Uint32 value) const { return Uint32(data_ + value.data_); }
1015   Uint32 operator-(Uint32 value) const { return Uint32(data_ - value.data_); }
1016   Uint32 operator&(Uint32 value) const { return Uint32(data_ & value.data_); }
1017   Uint32 operator&=(Uint32 value) {
1018     data_ &= value.data_;
1021   Uint32 operator^(Uint32 value) const { return Uint32(data_ ^ value.data_); }
1022   Uint32 operator^=(Uint32 value) {
1023     data_ ^= value.data_;
1026   Uint32 operator|(Uint32 value) const { return Uint32(data_ | value.data_); }
1027   Uint32 operator|=(Uint32 value) {
1028     data_ |= value.data_;
1079   bool operator==(Uint64 value) const { return data_ == value.data_; }
1080   bool operator!=(Uint64 value) const { return data_ != value.data_; }
1081   Uint64 operator+(Uint64 value) const { return Uint64(data_ + value.data_); }
1082   Uint64 operator-(Uint64 value) const { return Uint64(data_ - value.data_); }
1083   Uint64 operator&(Uint64 value) const { return Uint64(data_ & value.data_); }
1084   Uint64 operator&=(Uint64 value) {
1085     data_ &= value.data_;
1088   Uint64 operator^(Uint64 value) const { return Uint64(data_ ^ value.data_); }
1089   Uint64 operator^=(Uint64 value) {
1090     data_ ^= value.data_;
1093   Uint64 operator|(Uint64 value) const { return Uint64(data_ | value.data_); }
1094   Uint64 operator|=(Uint64 value) {
1095     data_ |= value.data_;
1142   bool operator==(Uint128 value) const {
1143     return (data_high_ == value.data_high_) && (data_low_ == value.data_low_);
1145   Uint128 operator&(Uint128 value) const {
1146     return Uint128(data_high_ & value.data_high_, data_low_ & value.data_low_);
1148   Uint128 operator&=(Uint128 value) {
1149     data_high_ &= value.data_high_;
1150     data_low_ &= value.data_low_;
1153   Uint128 operator|=(Uint128 value) {
1154     data_high_ |= value.data_high_;
1155     data_low_ |= value.data_low_;
1181 Int64 BitCount(Uint32 value);
1213   uint64_t value = u1 * v1 + w2 + w1;
1215   memcpy(&result, &value, sizeof(result));
1267 //            value 'pow(2, exponent)'.
1269 // The input value is assumed to be a normalized value. That is, the input may
1270 // not be infinity or NaN. If the source value is subnormal, it must be
1272 // mantissa has the value 'pow(2, exponent)'.
1289   // could make it overflow. With ties-to-even rounding, this value would become
1296   // the value '1'. Similarly, the highest-order bit that won't fit into
1297   // the result ('halfbit') has the value '0.5'. The 'point' sits between
1347   // If all bits in the exponent are set, the value is infinite or NaN.
1382     // is necessary because the exponent of a subnormal value (encoded as 0) is
1383     // the same as the exponent of the smallest normal value (encoded as 1).
1399         // non-zero return the next "odd" value.
1435       // This also handles cases where a very large finite value overflows to
1436       // infinity, or where a very large subnormal value overflows to become
1502 float FPToFloat(Float16 value, UseDefaultNaN DN, bool* exception = NULL);
1503 float FPToFloat(double value,
1508 double FPToDouble(Float16 value, UseDefaultNaN DN, bool* exception = NULL);
1509 double FPToDouble(float value, UseDefaultNaN DN, bool* exception = NULL);
1511 Float16 FPToFloat16(float value,
1516 Float16 FPToFloat16(double value,
1521 // Like static_cast<T>(value), but with specialisations for the Float16 type.
1523 T StaticCastFPTo(F value) {
1524   return static_cast<T>(value);
1528 inline float StaticCastFPTo<float, Float16>(Float16 value) {
1529   return FPToFloat(value, kIgnoreDefaultNaN);
1533 inline double StaticCastFPTo<double, Float16>(Float16 value) {
1534   return FPToDouble(value, kIgnoreDefaultNaN);
1538 inline Float16 StaticCastFPTo<Float16, float>(float value) {
1539   return FPToFloat16(value, FPTieEven, kIgnoreDefaultNaN);
1543 inline Float16 StaticCastFPTo<Float16, double>(double value) {
1544   return FPToFloat16(value, FPTieEven, kIgnoreDefaultNaN);
1548 uint64_t FPToRawbitsWithSize(unsigned size_in_bits, T value) {
1551       return Float16ToRawbits(StaticCastFPTo<Float16>(value));
1553       return FloatToRawbits(StaticCastFPTo<float>(value));
1555       return DoubleToRawbits(StaticCastFPTo<double>(value));
1562 T RawbitsWithSizeToFP(unsigned size_in_bits, uint64_t value) {
1563   VIXL_ASSERT(IsUintN(size_in_bits, value));
1566       return StaticCastFPTo<T>(RawbitsToFloat16(static_cast<uint16_t>(value)));
1568       return StaticCastFPTo<T>(RawbitsToFloat(static_cast<uint32_t>(value)));
1570       return StaticCastFPTo<T>(RawbitsToDouble(value));

Indexes created Thu Nov 07 10:32:03 CST 2024