| // Copyright 2019 Google LLC | |
| // SPDX-License-Identifier: Apache-2.0 | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "hwy/base.h" | |
| #include <limits> | |
| #include "hwy/nanobenchmark.h" | |
| #undef HWY_TARGET_INCLUDE | |
| #define HWY_TARGET_INCLUDE "base_test.cc" | |
| #include "hwy/foreach_target.h" // IWYU pragma: keep | |
| #include "hwy/highway.h" | |
| #include "hwy/tests/test_util-inl.h" | |
| HWY_BEFORE_NAMESPACE(); | |
| namespace hwy { | |
| namespace HWY_NAMESPACE { | |
| namespace { | |
| HWY_NOINLINE void TestUnreachable() { | |
| if (!hwy::Unpredictable1()) { | |
| HWY_UNREACHABLE; | |
| } | |
| } | |
| HWY_NOINLINE void TestAllLimits() { | |
| HWY_ASSERT_EQ(uint8_t{0}, LimitsMin<uint8_t>()); | |
| HWY_ASSERT_EQ(uint16_t{0}, LimitsMin<uint16_t>()); | |
| HWY_ASSERT_EQ(uint32_t{0}, LimitsMin<uint32_t>()); | |
| HWY_ASSERT_EQ(uint64_t{0}, LimitsMin<uint64_t>()); | |
| HWY_ASSERT_EQ(int8_t{-128}, LimitsMin<int8_t>()); | |
| HWY_ASSERT_EQ(int16_t{-32768}, LimitsMin<int16_t>()); | |
| HWY_ASSERT_EQ(static_cast<int32_t>(0x80000000u), LimitsMin<int32_t>()); | |
| HWY_ASSERT_EQ(static_cast<int64_t>(0x8000000000000000ull), | |
| LimitsMin<int64_t>()); | |
| HWY_ASSERT_EQ(uint8_t{0xFF}, LimitsMax<uint8_t>()); | |
| HWY_ASSERT_EQ(uint16_t{0xFFFF}, LimitsMax<uint16_t>()); | |
| HWY_ASSERT_EQ(uint32_t{0xFFFFFFFFu}, LimitsMax<uint32_t>()); | |
| HWY_ASSERT_EQ(uint64_t{0xFFFFFFFFFFFFFFFFull}, LimitsMax<uint64_t>()); | |
| HWY_ASSERT_EQ(int8_t{0x7F}, LimitsMax<int8_t>()); | |
| HWY_ASSERT_EQ(int16_t{0x7FFF}, LimitsMax<int16_t>()); | |
| HWY_ASSERT_EQ(int32_t{0x7FFFFFFFu}, LimitsMax<int32_t>()); | |
| HWY_ASSERT_EQ(int64_t{0x7FFFFFFFFFFFFFFFull}, LimitsMax<int64_t>()); | |
| HWY_ASSERT(LimitsMin<signed char>() == LimitsMin<int8_t>()); | |
| HWY_ASSERT(LimitsMin<short>() <= LimitsMin<int16_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMin<int>() <= LimitsMin<int16_t>()); | |
| HWY_ASSERT(LimitsMin<long>() <= LimitsMin<int32_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMin<long long>() <= LimitsMin<int64_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMax<signed char>() == LimitsMax<int8_t>()); | |
| HWY_ASSERT(LimitsMax<short>() >= LimitsMax<int16_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMax<int>() >= LimitsMax<int16_t>()); | |
| HWY_ASSERT(LimitsMax<long>() >= LimitsMax<int32_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMax<long long>() >= LimitsMax<int64_t>()); // NOLINT | |
| HWY_ASSERT_EQ(static_cast<unsigned char>(0), LimitsMin<unsigned char>()); | |
| HWY_ASSERT_EQ(static_cast<unsigned short>(0), LimitsMin<unsigned short>()); | |
| HWY_ASSERT_EQ(0u, LimitsMin<unsigned>()); | |
| HWY_ASSERT_EQ(0ul, LimitsMin<unsigned long>()); // NOLINT | |
| HWY_ASSERT_EQ(0ull, LimitsMin<unsigned long long>()); // NOLINT | |
| HWY_ASSERT(LimitsMax<unsigned char>() == LimitsMax<uint8_t>()); | |
| HWY_ASSERT(LimitsMax<unsigned short>() >= LimitsMax<uint16_t>()); // NOLINT | |
| HWY_ASSERT(LimitsMax<unsigned>() >= LimitsMax<uint16_t>()); | |
| HWY_ASSERT(LimitsMax<unsigned long>() >= LimitsMax<uint32_t>()); // NOLINT | |
| // NOLINTNEXTLINE | |
| HWY_ASSERT(LimitsMax<unsigned long long>() >= LimitsMax<uint64_t>()); | |
| HWY_ASSERT(LimitsMin<char>() == 0 || | |
| LimitsMin<char>() == LimitsMin<int8_t>()); | |
| HWY_ASSERT(LimitsMax<char>() == LimitsMax<int8_t>() || | |
| LimitsMax<char>() == LimitsMax<uint8_t>()); | |
| HWY_ASSERT_EQ(size_t{0}, LimitsMin<size_t>()); | |
| HWY_ASSERT(LimitsMin<ptrdiff_t>() < ptrdiff_t{0}); | |
| HWY_ASSERT(LimitsMin<intptr_t>() < intptr_t{0}); | |
| HWY_ASSERT_EQ(uintptr_t{0}, LimitsMin<uintptr_t>()); | |
| HWY_ASSERT(LimitsMin<wchar_t>() <= wchar_t{0}); | |
| HWY_ASSERT(LimitsMax<size_t>() > size_t{0}); | |
| HWY_ASSERT(LimitsMax<ptrdiff_t>() > ptrdiff_t{0}); | |
| HWY_ASSERT(LimitsMax<intptr_t>() > intptr_t{0}); | |
| HWY_ASSERT(LimitsMax<uintptr_t>() > uintptr_t{0}); | |
| } | |
| // SumWithin, ScalarFits, SumFits, SafeCast, SafeAdd. | |
| HWY_NOINLINE void TestAllSafeArith() { | |
| constexpr uint64_t kMax64 = LimitsMax<uint64_t>(); | |
| constexpr uint64_t kMaxI64 = static_cast<uint64_t>(LimitsMax<int64_t>()); | |
| // SumWithin: exact boundary, overflow, zero. Arguments must be unsigned, but | |
| // may be of mixed widths. | |
| static_assert(SumWithin(0u, 0u, 0u), "0 + 0 <= 0"); | |
| static_assert(SumWithin(10u, 20u, 30u), "exact max"); | |
| static_assert(!SumWithin(10u, 21u, 30u), "exceeds max"); | |
| static_assert(!SumWithin(31u, 0u, 30u), "a alone exceeds max"); | |
| static_assert(SumWithin(kMax64, 0u, kMax64), "max + 0"); | |
| static_assert(SumWithin(0u, kMax64, kMax64), "0 + max"); | |
| static_assert(!SumWithin(kMax64, 1u, kMax64), "wraparound"); | |
| static_assert(!SumWithin(kMax64, kMax64, kMax64), "double wraparound"); | |
| static_assert(!SumWithin(1u, kMax64, kMax64 - 1), "b alone exceeds max"); | |
| static_assert(SumWithin(uint8_t{200}, uint16_t{55}, size_t{255}), "mixed"); | |
| static_assert(!SumWithin(uint8_t{200}, uint16_t{56}, size_t{255}), "mixed"); | |
| // ScalarFits: unsigned to narrower unsigned. | |
| static_assert(ScalarFits<uint8_t>(0u) && ScalarFits<uint8_t>(255u), "u8"); | |
| static_assert(!ScalarFits<uint8_t>(256u), "u8 overflow"); | |
| static_assert(ScalarFits<uint16_t>(65535u) && !ScalarFits<uint16_t>(65536u), | |
| "u16"); | |
| static_assert(ScalarFits<uint32_t>(uint64_t{0xFFFFFFFFu}), "u32 max"); | |
| static_assert(!ScalarFits<uint32_t>(uint64_t{0x100000000u}), "u32 overflow"); | |
| static_assert(ScalarFits<uint64_t>(kMax64), "u64 identity"); | |
| // ScalarFits: signed sources and signed/unsigned TTo. | |
| static_assert(!ScalarFits<uint8_t>(-1), "negative int"); | |
| static_assert(!ScalarFits<uint64_t>(-1), "negative to u64"); | |
| static_assert(!ScalarFits<size_t>(LimitsMin<int64_t>()), "i64 min"); | |
| static_assert(!ScalarFits<uint64_t>(static_cast<int8_t>(-128)), "i8 min"); | |
| static_assert(ScalarFits<int64_t>(int64_t{-1}), "negative to i64"); | |
| static_assert(ScalarFits<int64_t>(LimitsMin<int64_t>()), "i64 min to i64"); | |
| static_assert(!ScalarFits<int32_t>(LimitsMin<int64_t>()), "i64 min to i32"); | |
| static_assert(ScalarFits<int8_t>(-128) && !ScalarFits<int8_t>(-129), | |
| "i8 min"); | |
| static_assert(ScalarFits<uint8_t>(int8_t{127}), "i8 max to u8"); | |
| static_assert(ScalarFits<int8_t>(127) && !ScalarFits<int8_t>(128), "i8"); | |
| static_assert(ScalarFits<int64_t>(LimitsMax<int64_t>()), "i64 max"); | |
| static_assert(ScalarFits<int64_t>(kMaxI64), "u64 to i64 at max"); | |
| static_assert(!ScalarFits<int64_t>(kMaxI64 + 1), "u64 to i64 overflow"); | |
| static_assert(!ScalarFits<int64_t>(kMax64), "u64 max to i64"); | |
| static_assert(ScalarFits<int32_t>(0x7FFFFFFFu), "u32 to i32 max"); | |
| static_assert(!ScalarFits<int32_t>(0x80000000u), "u32 to i32 overflow"); | |
| // ScalarFits: platform types (size_t may be 32 or 64 bits). | |
| static_assert(ScalarFits<size_t>(LimitsMax<size_t>()), "size_t max"); | |
| static_assert(ScalarFits<size_t>(uint64_t{0xFFFFFFFFu}), | |
| "u32 max always fits size_t"); | |
| HWY_ASSERT(ScalarFits<size_t>(kMax64) == (sizeof(size_t) == 8)); | |
| HWY_ASSERT( | |
| ScalarFits<ptrdiff_t>(static_cast<uint64_t>(LimitsMax<ptrdiff_t>()))); | |
| HWY_ASSERT(!ScalarFits<ptrdiff_t>( | |
| static_cast<uint64_t>(LimitsMax<ptrdiff_t>()) + 1)); | |
| static_assert(ScalarFits<unsigned long>(0ul), "ul"); // NOLINT | |
| static_assert(ScalarFits<long>(long{0}), "long"); // NOLINT | |
| static_assert(!ScalarFits<unsigned long>(long{-1}), "ul"); // NOLINT | |
| // cv-qualified and char sources are accepted. | |
| constexpr const int kConst = 42; | |
| static_assert(ScalarFits<uint8_t>(kConst), "const int"); | |
| static_assert(ScalarFits<uint8_t>('a'), "char"); | |
| // SumFits: boundary at LimitsMax<TTo>. | |
| static_assert(SumFits<uint8_t>(200u, 55u) && !SumFits<uint8_t>(200u, 56u), | |
| "SumFits u8"); | |
| static_assert(SumFits<int64_t>(kMaxI64, 0u), "SumFits i64 max"); | |
| static_assert(!SumFits<int64_t>(kMaxI64, 1u), "SumFits i64 overflow"); | |
| static_assert(SumFits<uint64_t>(kMax64, 0u), "SumFits u64 max"); | |
| static_assert(!SumFits<uint64_t>(kMax64, 1u), "SumFits u64 wraparound"); | |
| static_assert(!SumFits<size_t>(kMax64, 1u), "SumFits size_t wraparound"); | |
| HWY_ASSERT(SumFits<size_t>(LimitsMax<size_t>(), 0u)); | |
| HWY_ASSERT(!SumFits<size_t>(LimitsMax<size_t>(), 1u)); | |
| // SafeCast/SafeAdd: values that fit are returned unchanged. Use | |
| // Unpredictable1 so that the checks are not folded away. | |
| const uint64_t one = static_cast<uint64_t>(Unpredictable1()); | |
| const int64_t s_one = static_cast<int64_t>(one); | |
| HWY_ASSERT_EQ(size_t{42}, SafeCast<size_t>(42 * one)); | |
| HWY_ASSERT_EQ(uint8_t{255}, SafeCast<uint8_t>(255 * one)); | |
| HWY_ASSERT_EQ(int64_t{7}, SafeCast<int64_t>(7 * one)); | |
| HWY_ASSERT_EQ(int64_t{-7}, SafeCast<int64_t>(-7 * s_one)); | |
| HWY_ASSERT_EQ(int8_t{-128}, SafeCast<int8_t>(-128 * s_one)); | |
| HWY_ASSERT_EQ(int32_t{0x7FFFFFFF}, SafeCast<int32_t>(0x7FFFFFFFu * one)); | |
| HWY_ASSERT_EQ(uint64_t{30}, SafeAdd<uint64_t>(10 * one, 20u)); | |
| HWY_ASSERT_EQ(int32_t{30}, SafeAdd<int32_t>(10u, 20 * one)); | |
| HWY_ASSERT_EQ(kMax64, SafeAdd<uint64_t>(kMax64 - one, 1u)); | |
| HWY_ASSERT_EQ(LimitsMax<int64_t>(), SafeAdd<int64_t>(kMaxI64 - one, 1u)); | |
| // Mixed argument widths are accepted; the sum is computed in 64 bits. | |
| HWY_ASSERT_EQ(size_t{300}, SafeAdd<size_t>(uint8_t{200}, uint16_t{100})); | |
| // Also constexpr in C++14 and later. | |
| #if HWY_CXX_LANG >= 201402L | |
| static_assert(SafeCast<uint8_t>(200) == 200, "constexpr SafeCast"); | |
| static_assert(SafeAdd<uint16_t>(65000u, 535u) == 65535, "constexpr SafeAdd"); | |
| #endif | |
| HWY_ASSERT(LimitsMax<wchar_t>() > wchar_t{0}); | |
| } | |
| struct TestLowestHighest { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| // numeric_limits<T>::lowest is only guaranteed to be what we expect (-max) | |
| // for built-in floating-point types. | |
| if (!IsSpecialFloat<T>()) { | |
| HWY_ASSERT_EQ(std::numeric_limits<T>::lowest(), LowestValue<T>()); | |
| HWY_ASSERT_EQ(std::numeric_limits<T>::max(), HighestValue<T>()); | |
| if (IsFloat<T>()) { | |
| HWY_ASSERT(ScalarSignBit(NegativeInfOrLowestValue<T>())); | |
| HWY_ASSERT(!ScalarIsFinite(NegativeInfOrLowestValue<T>())); | |
| HWY_ASSERT(!ScalarSignBit(PositiveInfOrHighestValue<T>())); | |
| HWY_ASSERT(!ScalarIsFinite(PositiveInfOrHighestValue<T>())); | |
| HWY_ASSERT(NegativeInfOrLowestValue<T>() < | |
| std::numeric_limits<T>::lowest()); | |
| HWY_ASSERT(PositiveInfOrHighestValue<T>() > | |
| std::numeric_limits<T>::max()); | |
| } else { | |
| HWY_ASSERT_EQ(std::numeric_limits<T>::lowest(), | |
| NegativeInfOrLowestValue<T>()); | |
| HWY_ASSERT_EQ(std::numeric_limits<T>::max(), | |
| PositiveInfOrHighestValue<T>()); | |
| } | |
| } | |
| } | |
| }; | |
| HWY_NOINLINE void TestAllLowestHighest() { ForAllTypes(TestLowestHighest()); } | |
| struct TestIsUnsigned { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| static_assert(!IsFloat<T>(), "Expected !IsFloat"); | |
| static_assert(!IsSigned<T>(), "Expected !IsSigned"); | |
| static_assert(IsUnsigned<T>(), "Expected IsUnsigned"); | |
| static_assert(IsInteger<T>(), "Expected IsInteger"); | |
| } | |
| }; | |
| struct TestIsSigned { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| static_assert(!IsFloat<T>(), "Expected !IsFloat"); | |
| static_assert(IsSigned<T>(), "Expected IsSigned"); | |
| static_assert(!IsUnsigned<T>(), "Expected !IsUnsigned"); | |
| static_assert(IsInteger<T>(), "Expected IsInteger"); | |
| } | |
| }; | |
| struct TestIsFloat { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| static_assert(IsFloat<T>(), "Expected IsFloat"); | |
| static_assert(IsSigned<T>(), "Floats are also considered signed"); | |
| static_assert(!IsUnsigned<T>(), "Expected !IsUnsigned"); | |
| static_assert(!IsInteger<T>(), "Expected !IsInteger"); | |
| } | |
| }; | |
| HWY_NOINLINE void TestAllType() { | |
| const TestIsUnsigned is_unsigned_test; | |
| const TestIsSigned is_signed_test; | |
| ForUnsignedTypes(is_unsigned_test); | |
| ForSignedTypes(is_signed_test); | |
| ForFloatTypes(TestIsFloat()); | |
| is_unsigned_test(static_cast<unsigned char>(0)); | |
| is_unsigned_test(static_cast<unsigned short>(0)); | |
| is_unsigned_test(0u); | |
| is_unsigned_test(0ul); | |
| is_unsigned_test(0ull); | |
| is_unsigned_test(size_t{0}); | |
| is_unsigned_test(uintptr_t{0}); | |
| is_signed_test(static_cast<signed char>(0)); | |
| is_signed_test(static_cast<signed short>(0)); | |
| is_signed_test(0); | |
| is_signed_test(0L); | |
| is_signed_test(0LL); | |
| is_signed_test(ptrdiff_t{0}); | |
| is_signed_test(intptr_t{0}); | |
| static_assert(!IsFloat<char>(), "Expected !IsFloat<char>()"); | |
| static_assert(!IsFloat<wchar_t>(), "Expected !IsFloat<wchar_t>()"); | |
| static_assert(IsInteger<char>(), "Expected IsInteger<char>()"); | |
| static_assert(IsInteger<wchar_t>(), "Expected IsInteger<wchar_t>()"); | |
| static_assert(sizeof(MakeUnsigned<hwy::uint128_t>) == 16, ""); | |
| static_assert(sizeof(MakeWide<uint64_t>) == 16, "Expected uint128_t"); | |
| static_assert(sizeof(MakeNarrow<hwy::uint128_t>) == 8, "Expected uint64_t"); | |
| // IsEnum and UnderlyingType: scoped and unscoped enums, cv/ref qualifiers, | |
| // and the `void` fallback for non-enums. | |
| enum Unscoped : uint16_t { kUnscoped }; | |
| enum class Scoped : int8_t { kScoped }; | |
| static_assert(IsEnum<Unscoped>() && IsEnum<Scoped>(), "IsEnum"); | |
| static_assert(IsEnum<const Scoped&>() && IsEnum<volatile Unscoped>(), | |
| "IsEnum ignores cv/ref"); | |
| static_assert(!IsEnum<int>() && !IsEnum<uint16_t>() && !IsEnum<float>(), | |
| "!IsEnum"); | |
| static_assert(IsSame<UnderlyingType<Unscoped>, uint16_t>(), "Unscoped"); | |
| static_assert(IsSame<UnderlyingType<Scoped>, int8_t>(), "Scoped"); | |
| static_assert(IsSame<UnderlyingType<const Scoped&>, int8_t>(), | |
| "UnderlyingType ignores cv/ref"); | |
| static_assert(IsSame<UnderlyingType<int>, void>(), "non-enum is void"); | |
| } | |
| struct TestIsSame { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| static_assert(IsSame<T, T>(), "T == T"); | |
| static_assert(!IsSame<MakeSigned<T>, MakeUnsigned<T>>(), "S != U"); | |
| static_assert(!IsSame<MakeUnsigned<T>, MakeSigned<T>>(), "U != S"); | |
| } | |
| }; | |
| HWY_NOINLINE void TestAllIsSame() { ForAllTypes(TestIsSame()); } | |
| HWY_NOINLINE void TestAllBitScan() { | |
| HWY_ASSERT_EQ(size_t{0}, Num0BitsAboveMS1Bit_Nonzero32(0x80000000u)); | |
| HWY_ASSERT_EQ(size_t{0}, Num0BitsAboveMS1Bit_Nonzero32(0xFFFFFFFFu)); | |
| HWY_ASSERT_EQ(size_t{1}, Num0BitsAboveMS1Bit_Nonzero32(0x40000000u)); | |
| HWY_ASSERT_EQ(size_t{1}, Num0BitsAboveMS1Bit_Nonzero32(0x40108210u)); | |
| HWY_ASSERT_EQ(size_t{30}, Num0BitsAboveMS1Bit_Nonzero32(2u)); | |
| HWY_ASSERT_EQ(size_t{30}, Num0BitsAboveMS1Bit_Nonzero32(3u)); | |
| HWY_ASSERT_EQ(size_t{31}, Num0BitsAboveMS1Bit_Nonzero32(1u)); | |
| HWY_ASSERT_EQ(size_t{0}, | |
| Num0BitsAboveMS1Bit_Nonzero64(0x8000000000000000ull)); | |
| HWY_ASSERT_EQ(size_t{0}, | |
| Num0BitsAboveMS1Bit_Nonzero64(0xFFFFFFFFFFFFFFFFull)); | |
| HWY_ASSERT_EQ(size_t{1}, | |
| Num0BitsAboveMS1Bit_Nonzero64(0x4000000000000000ull)); | |
| HWY_ASSERT_EQ(size_t{1}, | |
| Num0BitsAboveMS1Bit_Nonzero64(0x4010821004200011ull)); | |
| HWY_ASSERT_EQ(size_t{62}, Num0BitsAboveMS1Bit_Nonzero64(2ull)); | |
| HWY_ASSERT_EQ(size_t{62}, Num0BitsAboveMS1Bit_Nonzero64(3ull)); | |
| HWY_ASSERT_EQ(size_t{63}, Num0BitsAboveMS1Bit_Nonzero64(1ull)); | |
| HWY_ASSERT_EQ(size_t{0}, Num0BitsBelowLS1Bit_Nonzero32(1u)); | |
| HWY_ASSERT_EQ(size_t{1}, Num0BitsBelowLS1Bit_Nonzero32(2u)); | |
| HWY_ASSERT_EQ(size_t{30}, Num0BitsBelowLS1Bit_Nonzero32(0xC0000000u)); | |
| HWY_ASSERT_EQ(size_t{31}, Num0BitsBelowLS1Bit_Nonzero32(0x80000000u)); | |
| HWY_ASSERT_EQ(size_t{0}, Num0BitsBelowLS1Bit_Nonzero64(1ull)); | |
| HWY_ASSERT_EQ(size_t{1}, Num0BitsBelowLS1Bit_Nonzero64(2ull)); | |
| HWY_ASSERT_EQ(size_t{62}, | |
| Num0BitsBelowLS1Bit_Nonzero64(0xC000000000000000ull)); | |
| HWY_ASSERT_EQ(size_t{63}, | |
| Num0BitsBelowLS1Bit_Nonzero64(0x8000000000000000ull)); | |
| } | |
| HWY_NOINLINE void TestAllPopCount() { | |
| HWY_ASSERT_EQ(size_t{0}, PopCount(0u)); | |
| HWY_ASSERT_EQ(size_t{1}, PopCount(1u)); | |
| HWY_ASSERT_EQ(size_t{1}, PopCount(2u)); | |
| HWY_ASSERT_EQ(size_t{2}, PopCount(3u)); | |
| HWY_ASSERT_EQ(size_t{1}, PopCount(0x80000000u)); | |
| HWY_ASSERT_EQ(size_t{31}, PopCount(0x7FFFFFFFu)); | |
| HWY_ASSERT_EQ(size_t{32}, PopCount(0xFFFFFFFFu)); | |
| HWY_ASSERT_EQ(size_t{1}, PopCount(0x80000000ull)); | |
| HWY_ASSERT_EQ(size_t{31}, PopCount(0x7FFFFFFFull)); | |
| HWY_ASSERT_EQ(size_t{32}, PopCount(0xFFFFFFFFull)); | |
| HWY_ASSERT_EQ(size_t{33}, PopCount(0x10FFFFFFFFull)); | |
| HWY_ASSERT_EQ(size_t{63}, PopCount(0xFFFEFFFFFFFFFFFFull)); | |
| HWY_ASSERT_EQ(size_t{64}, PopCount(0xFFFFFFFFFFFFFFFFull)); | |
| } | |
| HWY_NOINLINE void TestAllDivCeil() { | |
| static_assert(DivCeil(size_t{0}, size_t{1}) == size_t{0}, | |
| "DivCeil must handle zero dividends"); | |
| static_assert(DivCeil(size_t{7}, size_t{7}) == size_t{1}, | |
| "DivCeil must remain constexpr"); | |
| HWY_ASSERT_EQ(size_t{0}, DivCeil(size_t{0}, size_t{1})); | |
| HWY_ASSERT_EQ(size_t{0}, DivCeil(size_t{0}, size_t{7})); | |
| HWY_ASSERT_EQ(size_t{1}, DivCeil(size_t{1}, size_t{7})); | |
| HWY_ASSERT_EQ(size_t{2}, DivCeil(size_t{8}, size_t{7})); | |
| constexpr size_t kMax = std::numeric_limits<size_t>::max(); | |
| HWY_ASSERT_EQ(kMax / size_t{2} + size_t{1}, DivCeil(kMax, size_t{2})); | |
| } | |
| // Exhaustive test for small/large dividends and divisors | |
| HWY_NOINLINE void TestAllDivisor() { | |
| // Small d, small n | |
| for (uint32_t d = 1; d < 256; ++d) { | |
| const Divisor divisor(d); | |
| for (uint32_t n = 0; n < 256; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Large d, small n | |
| for (uint32_t d = 0xFFFFFF00u; d != 0; ++d) { | |
| const Divisor divisor(d); | |
| for (uint32_t n = 0; n < 256; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Small d, large n | |
| for (uint32_t d = 1; d < 256; ++d) { | |
| const Divisor divisor(d); | |
| for (uint32_t n = 0xFFFFFF00u; n != 0; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Large d, large n | |
| for (uint32_t d = 0xFFFFFF00u; d != 0; ++d) { | |
| const Divisor divisor(d); | |
| for (uint32_t n = 0xFFFFFF00u; n != 0; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| } | |
| HWY_NOINLINE void TestAllDivisor64() { | |
| // Small d, small n | |
| for (uint64_t d = 1; d < 256; ++d) { | |
| const Divisor64 divisor(d); | |
| for (uint64_t n = 0; n < 256; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Large d, small n | |
| for (uint64_t d = 0xFFFFFFFFFFFFFF00ULL; d != 0; ++d) { | |
| const Divisor64 divisor(d); | |
| for (uint64_t n = 0; n < 256; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Small d, large n | |
| for (uint64_t d = 1; d < 256; ++d) { | |
| const Divisor64 divisor(d); | |
| for (uint64_t n = 0xFFFFFFFFFFFFFF00ULL; n != 0; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| // Large d, large n | |
| for (uint64_t d = 0xFFFFFFFFFFFFFF00ULL; d != 0; ++d) { | |
| const Divisor64 divisor(d); | |
| for (uint64_t n = 0xFFFFFFFFFFFFFF00ULL; n != 0; ++n) { | |
| HWY_ASSERT(divisor.Divide(n) == n / d); | |
| HWY_ASSERT(divisor.Remainder(n) == n % d); | |
| } | |
| } | |
| } | |
| struct TestScalarShr { | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| using TU = MakeUnsigned<T>; | |
| constexpr T kMsb = static_cast<T>(1ULL << (sizeof(T) * 8 - 1)); | |
| constexpr int kSizeInBits = static_cast<int>(sizeof(T) * 8); | |
| constexpr T kVal1 = static_cast<T>(0x776B0405296C183BULL & LimitsMax<TU>()); | |
| constexpr T kVal2 = static_cast<T>(kVal1 | kMsb); | |
| for (int i = 0; i < kSizeInBits; i++) { | |
| T expected1; | |
| T expected2; | |
| const TU expected1_bits = static_cast<TU>(static_cast<TU>(kVal1) >> i); | |
| const TU expected2_bits = static_cast<TU>( | |
| (static_cast<TU>(kVal2) >> i) | | |
| ((IsSigned<T>() && i > 0) | |
| ? (~((static_cast<TU>(1) << (kSizeInBits - i)) - 1)) | |
| : 0)); | |
| CopySameSize(&expected1_bits, &expected1); | |
| CopySameSize(&expected2_bits, &expected2); | |
| HWY_ASSERT_EQ(expected1, ScalarShr(kVal1, i)); | |
| HWY_ASSERT_EQ(expected2, ScalarShr(kVal2, i)); | |
| } | |
| } | |
| }; | |
| HWY_NOINLINE void TestAllScalarShr() { ForIntegerTypes(TestScalarShr()); } | |
| template <class T> | |
| static HWY_INLINE void AssertMul128Result(T expected_hi, T expected_lo, T a, | |
| T b, const char* file, | |
| const int line) { | |
| RemoveCvRef<T> actual_hi; | |
| const RemoveCvRef<T> actual_lo = Mul128(a, b, &actual_hi); | |
| hwy::AssertEqual(expected_lo, actual_lo, hwy::TargetName(HWY_TARGET), file, | |
| line); | |
| hwy::AssertEqual(expected_hi, actual_hi, hwy::TargetName(HWY_TARGET), file, | |
| line); | |
| } | |
| HWY_NOINLINE void TestAllMul128() { | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(0), | |
| static_cast<int64_t>(0), static_cast<int64_t>(0), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(0), | |
| static_cast<int64_t>(0), static_cast<int64_t>(1), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(0), | |
| static_cast<int64_t>(0), static_cast<int64_t>(-1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(0), | |
| static_cast<int64_t>(1), static_cast<int64_t>(0), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(0), | |
| static_cast<int64_t>(-1), static_cast<int64_t>(0), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(1), | |
| static_cast<int64_t>(1), static_cast<int64_t>(1), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(-1), static_cast<int64_t>(-1), | |
| static_cast<int64_t>(-1), static_cast<int64_t>(1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(-1), static_cast<int64_t>(-1), | |
| static_cast<int64_t>(1), static_cast<int64_t>(-1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0), static_cast<int64_t>(1), | |
| static_cast<int64_t>(-1), static_cast<int64_t>(-1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0), static_cast<uint64_t>(0), | |
| static_cast<uint64_t>(0), static_cast<uint64_t>(0), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0), static_cast<uint64_t>(0), | |
| static_cast<uint64_t>(0), static_cast<uint64_t>(1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0), static_cast<uint64_t>(0), | |
| static_cast<uint64_t>(1), static_cast<uint64_t>(0), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0), static_cast<uint64_t>(1), | |
| static_cast<uint64_t>(1), static_cast<uint64_t>(1), | |
| __FILE__, __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0x24E331A77C96011DULL), | |
| static_cast<int64_t>(0x3C5385F8E294E438ULL), | |
| static_cast<int64_t>(0x4F87AE233A08DD18ULL), | |
| static_cast<int64_t>(0x76BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0xFD1F5A95DF919291ULL), | |
| static_cast<int64_t>(0x3C5385F8E294E438ULL), | |
| static_cast<int64_t>(0x4F87AE233A08DD18ULL), | |
| static_cast<int64_t>(0xF6BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0xE984CB0E30E8DC36ULL), | |
| static_cast<int64_t>(0xBC5385F8E294E438ULL), | |
| static_cast<int64_t>(0xCF87AE233A08DD18ULL), | |
| static_cast<int64_t>(0x76BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<int64_t>(0x01C0F3FC93E46DAAULL), | |
| static_cast<int64_t>(0xBC5385F8E294E438ULL), | |
| static_cast<int64_t>(0xCF87AE233A08DD18ULL), | |
| static_cast<int64_t>(0xF6BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0x24E331A77C96011DULL), | |
| static_cast<uint64_t>(0x3C5385F8E294E438ULL), | |
| static_cast<uint64_t>(0x4F87AE233A08DD18ULL), | |
| static_cast<uint64_t>(0x76BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0x4CA708B9199A6FA9ULL), | |
| static_cast<uint64_t>(0x3C5385F8E294E438ULL), | |
| static_cast<uint64_t>(0x4F87AE233A08DD18ULL), | |
| static_cast<uint64_t>(0xF6BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0x60419840C8432603ULL), | |
| static_cast<uint64_t>(0xBC5385F8E294E438ULL), | |
| static_cast<uint64_t>(0xCF87AE233A08DD18ULL), | |
| static_cast<uint64_t>(0x76BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| AssertMul128Result(static_cast<uint64_t>(0xC8056F526547948FULL), | |
| static_cast<uint64_t>(0xBC5385F8E294E438ULL), | |
| static_cast<uint64_t>(0xCF87AE233A08DD18ULL), | |
| static_cast<uint64_t>(0xF6BCCD32975A49CDULL), __FILE__, | |
| __LINE__); | |
| } | |
| template <class T> | |
| static HWY_INLINE T TestEndianGetIntegerVal(T val) { | |
| static_assert(!IsFloat<T>() && !IsSpecialFloat<T>(), | |
| "T must not be a floating-point type"); | |
| using TU = MakeUnsigned<T>; | |
| static_assert(sizeof(T) == sizeof(TU), | |
| "sizeof(T) == sizeof(TU) must be true"); | |
| uint8_t result_bytes[sizeof(T)]; | |
| const TU val_u = static_cast<TU>(val); | |
| for (size_t i = 0; i < sizeof(T); i++) { | |
| #if HWY_IS_BIG_ENDIAN | |
| const size_t shift_amt = (sizeof(T) - 1 - i) * 8; | |
| #else | |
| const size_t shift_amt = i * 8; | |
| #endif | |
| result_bytes[i] = static_cast<uint8_t>((val_u >> shift_amt) & 0xFF); | |
| } | |
| T result; | |
| CopyBytes<sizeof(T)>(result_bytes, &result); | |
| return result; | |
| } | |
| template <class T, class... Bytes> | |
| static HWY_INLINE T TestEndianCreateValueFromBytes(Bytes&&... bytes) { | |
| static_assert(sizeof(T) > 0, "sizeof(T) > 0 must be true"); | |
| static_assert(sizeof...(Bytes) == sizeof(T), | |
| "sizeof...(Bytes) == sizeof(T) must be true"); | |
| const uint8_t src_bytes[sizeof(T)]{static_cast<uint8_t>(bytes)...}; | |
| T result; | |
| CopyBytes<sizeof(T)>(src_bytes, &result); | |
| return result; | |
| } | |
| #define HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(val) \ | |
| HWY_ASSERT_EQ(val, TestEndianGetIntegerVal(val)) | |
| HWY_NOINLINE void TestAllEndian() { | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int8_t{0x01}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint8_t{0x01}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int16_t{0x0102}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint16_t{0x0102}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int32_t{0x01020304}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint32_t{0x01020304}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int64_t{0x0102030405060708}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint64_t{0x0102030405060708}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int16_t{0x0201}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint16_t{0x0201}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int32_t{0x04030201}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint32_t{0x04030201}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(int64_t{0x0807060504030201}); | |
| HWY_TEST_ENDIAN_CHECK_INTEGER_VAL(uint64_t{0x0807060504030201}); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? int16_t{0x0102} : int16_t{0x0201}, | |
| TestEndianCreateValueFromBytes<int16_t>(0x01, 0x02)); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? uint16_t{0x0102} : uint16_t{0x0201}, | |
| TestEndianCreateValueFromBytes<uint16_t>(0x01, 0x02)); | |
| HWY_ASSERT_EQ( | |
| HWY_IS_BIG_ENDIAN ? int32_t{0x01020304} : int32_t{0x04030201}, | |
| TestEndianCreateValueFromBytes<int32_t>(0x01, 0x02, 0x03, 0x04)); | |
| HWY_ASSERT_EQ( | |
| HWY_IS_BIG_ENDIAN ? uint32_t{0x01020304} : uint32_t{0x04030201}, | |
| TestEndianCreateValueFromBytes<uint32_t>(0x01, 0x02, 0x03, 0x04)); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? int64_t{0x0102030405060708} | |
| : int64_t{0x0807060504030201}, | |
| TestEndianCreateValueFromBytes<int64_t>( | |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08)); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? uint64_t{0x0102030405060708} | |
| : uint64_t{0x0807060504030201}, | |
| TestEndianCreateValueFromBytes<uint64_t>( | |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08)); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? int16_t{-0x5EFE} : int16_t{0x02A1}, | |
| TestEndianCreateValueFromBytes<int16_t>(0xA1, 0x02)); | |
| HWY_ASSERT_EQ( | |
| HWY_IS_BIG_ENDIAN ? int32_t{-0x5E4D3CFC} : int32_t{0x04C3B2A1}, | |
| TestEndianCreateValueFromBytes<int32_t>(0xA1, 0xB2, 0xC3, 0x04)); | |
| HWY_ASSERT_EQ(HWY_IS_BIG_ENDIAN ? int64_t{-0x6E5D4C3B2A1908F8} | |
| : int64_t{0x08F7E6D5C4B3A291}, | |
| TestEndianCreateValueFromBytes<int64_t>( | |
| 0x91, 0xA2, 0xB3, 0xC4, 0xD5, 0xE6, 0xF7, 0x08)); | |
| HWY_ASSERT_EQ(HWY_IS_LITTLE_ENDIAN ? int16_t{-0x5DFF} : int16_t{0x01A2}, | |
| TestEndianCreateValueFromBytes<int16_t>(0x01, 0xA2)); | |
| HWY_ASSERT_EQ( | |
| HWY_IS_LITTLE_ENDIAN ? int32_t{-0x3B4C5DFF} : int32_t{0x01A2B3C4}, | |
| TestEndianCreateValueFromBytes<int32_t>(0x01, 0xA2, 0xB3, 0xC4)); | |
| HWY_ASSERT_EQ(HWY_IS_LITTLE_ENDIAN ? int64_t{-0x0718293A4B5C6DFF} | |
| : int64_t{0x0192A3B4C5D6E7F8}, | |
| TestEndianCreateValueFromBytes<int64_t>( | |
| 0x01, 0x92, 0xA3, 0xB4, 0xC5, 0xD6, 0xE7, 0xF8)); | |
| #if HWY_IS_BIG_ENDIAN | |
| HWY_ASSERT_EQ(1.0f, | |
| TestEndianCreateValueFromBytes<float>(0x3F, 0x80, 0x00, 0x00)); | |
| HWY_ASSERT_EQ(15922433.0f, | |
| TestEndianCreateValueFromBytes<float>(0x4B, 0x72, 0xF5, 0x01)); | |
| HWY_ASSERT_EQ(-12357485.0f, | |
| TestEndianCreateValueFromBytes<float>(0xCB, 0x3C, 0x8F, 0x6D)); | |
| #else | |
| HWY_ASSERT_EQ(1.0f, | |
| TestEndianCreateValueFromBytes<float>(0x00, 0x00, 0x80, 0x3F)); | |
| HWY_ASSERT_EQ(15922433.0f, | |
| TestEndianCreateValueFromBytes<float>(0x01, 0xF5, 0x72, 0x4B)); | |
| HWY_ASSERT_EQ(-12357485.0f, | |
| TestEndianCreateValueFromBytes<float>(0x6D, 0x8F, 0x3C, 0xCB)); | |
| #endif | |
| #if HWY_HAVE_FLOAT64 | |
| #if HWY_IS_BIG_ENDIAN | |
| HWY_ASSERT_EQ(1.0, TestEndianCreateValueFromBytes<double>( | |
| 0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)); | |
| HWY_ASSERT_EQ(8707235690688195.0, | |
| TestEndianCreateValueFromBytes<double>(0x43, 0x3E, 0xEF, 0x2F, | |
| 0x4A, 0x51, 0xAE, 0xC3)); | |
| HWY_ASSERT_EQ(-6815854340348452.0, | |
| TestEndianCreateValueFromBytes<double>(0xC3, 0x38, 0x36, 0xFB, | |
| 0xC0, 0xCC, 0x1A, 0x24)); | |
| #else | |
| HWY_ASSERT_EQ(1.0, TestEndianCreateValueFromBytes<double>( | |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F)); | |
| HWY_ASSERT_EQ(8707235690688195.0, | |
| TestEndianCreateValueFromBytes<double>(0xC3, 0xAE, 0x51, 0x4A, | |
| 0x2F, 0xEF, 0x3E, 0x43)); | |
| HWY_ASSERT_EQ(-6815854340348452.0, | |
| TestEndianCreateValueFromBytes<double>(0x24, 0x1A, 0xCC, 0xC0, | |
| 0xFB, 0x36, 0x38, 0xC3)); | |
| #endif // HWY_IS_BIG_ENDIAN | |
| #endif // HWY_HAVE_FLOAT64 | |
| #if HWY_IS_BIG_ENDIAN | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(1.0f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0x3F, 0x80))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(0.333984375f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0x3E, 0xAB))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(167121905303526337111381770240.0f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0x70, 0x07))); | |
| #else | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(1.0f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0x80, 0x3F))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(0.333984375f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0xAB, 0x3E))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<bfloat16_t>(167121905303526337111381770240.0f), | |
| BitCastScalar<bfloat16_t>( | |
| TestEndianCreateValueFromBytes<uint16_t>(0x07, 0x70))); | |
| #endif | |
| } | |
| HWY_NOINLINE void TestAllScalarByteSwap() { | |
| static_assert( | |
| ScalarByteSwap(static_cast<int8_t>(0x9Au)) == static_cast<int8_t>(0x9Au), | |
| "ScalarByteSwap(static_cast<int8_t>(0x9Au)) must be equal to 0x9A"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int8_t>(0xE4u)) == static_cast<int8_t>(0xE4u), | |
| "ScalarByteSwap(static_cast<int8_t>(0xE4u)) must be equal to 0xE4"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int8_t>(0x1Au)) == static_cast<int8_t>(0x1Au), | |
| "ScalarByteSwap(static_cast<int8_t>(0x1Au)) must be equal to 0x1A"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int8_t>(0x4Eu)) == static_cast<int8_t>(0x4Eu), | |
| "ScalarByteSwap(static_cast<int8_t>(0x4Eu)) must be equal to 0x4E"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int16_t>(0x8DBBu)) == | |
| static_cast<int16_t>(0xBB8Du), | |
| "ScalarByteSwap(static_cast<int16_t>(0x8DBBu)) must be equal to 0xBB8D"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int16_t>(0x18EAu)) == | |
| static_cast<int16_t>(0xEA18u), | |
| "ScalarByteSwap(static_cast<int16_t>(0x18EAu)) must be equal to 0xEA18"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int16_t>(0x3021u)) == | |
| static_cast<int16_t>(0x2130u), | |
| "ScalarByteSwap(static_cast<int16_t>(0x3021u)) must be equal to 0x2130"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<int16_t>(0x823Eu)) == | |
| static_cast<int16_t>(0x3E82u), | |
| "ScalarByteSwap(static_cast<int16_t>(0x823Eu)) must be equal to 0x3E82"); | |
| static_assert(ScalarByteSwap(static_cast<int32_t>(0xF0FB518Eu)) == | |
| static_cast<int32_t>(0x8E51FBF0u), | |
| "ScalarByteSwap(static_cast<int32_t>(0xF0FB518Eu)) must be " | |
| "equal to 0x8E51FBF0"); | |
| static_assert(ScalarByteSwap(static_cast<int32_t>(0x46A94FEDu)) == | |
| static_cast<int32_t>(0xED4FA946u), | |
| "ScalarByteSwap(static_cast<int32_t>(0x46A94FEDu)) must be " | |
| "equal to 0xED4FA946"); | |
| static_assert(ScalarByteSwap(static_cast<int32_t>(0x1FA6D136u)) == | |
| static_cast<int32_t>(0x36D1A61Fu), | |
| "ScalarByteSwap(static_cast<int32_t>(0x1FA6D136u)) must be " | |
| "equal to 0x36D1A61F"); | |
| static_assert(ScalarByteSwap(static_cast<int32_t>(0xCF23BD57u)) == | |
| static_cast<int32_t>(0x57BD23CFu), | |
| "ScalarByteSwap(static_cast<int32_t>(0xCF23BD57u)) must be " | |
| "equal to 0x57BD23CF"); | |
| static_assert(ScalarByteSwap(static_cast<int64_t>(0xE37B7E4AA7C605BBULL)) == | |
| static_cast<int64_t>(0xBB05C6A74A7E7BE3ULL), | |
| "ScalarByteSwap(static_cast<int64_t>(0xE37B7E4AA7C605BBULL)) " | |
| "must be equal to 0xBB05C6A74A7E7BE3"); | |
| static_assert(ScalarByteSwap(static_cast<int64_t>(0x3BDFBB720F94DDBAULL)) == | |
| static_cast<int64_t>(0xBADD940F72BBDF3BULL), | |
| "ScalarByteSwap(static_cast<int64_t>(0x3BDFBB720F94DDBAULL)) " | |
| "must be equal to 0xBADD940F72BBDF3B"); | |
| static_assert(ScalarByteSwap(static_cast<int64_t>(0x6B3E7B7C67BC8643ULL)) == | |
| static_cast<int64_t>(0x4386BC677C7B3E6BULL), | |
| "ScalarByteSwap(static_cast<int64_t>(0x6B3E7B7C67BC8643ULL)) " | |
| "must be equal to 0x4386BC677C7B3E6B"); | |
| static_assert(ScalarByteSwap(static_cast<int64_t>(0xEC5C0AFEF0AC2820ULL)) == | |
| static_cast<int64_t>(0x2028ACF0FE0A5CECULL), | |
| "ScalarByteSwap(static_cast<int64_t>(0xEC5C0AFEF0AC2820ULL)) " | |
| "must be equal to 0x2028ACF0FE0A5CECULL"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint8_t>(0xD1u)) == | |
| static_cast<uint8_t>(0xD1u), | |
| "ScalarByteSwap(static_cast<uint8_t>(0xD1u)) must be equal to 0xD1"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint8_t>(0x90u)) == | |
| static_cast<uint8_t>(0x90u), | |
| "ScalarByteSwap(static_cast<uint8_t>(0x90u)) must be equal to 0x90"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint8_t>(0x78u)) == | |
| static_cast<uint8_t>(0x78u), | |
| "ScalarByteSwap(static_cast<uint8_t>(0x78u)) must be equal to 0x78"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint8_t>(0x3Eu)) == | |
| static_cast<uint8_t>(0x3Eu), | |
| "ScalarByteSwap(static_cast<uint8_t>(0x3Eu)) must be equal to 0x3E"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint16_t>(0xD593u)) == | |
| static_cast<uint16_t>(0x93D5u), | |
| "ScalarByteSwap(static_cast<uint16_t>(0xD593u)) must be equal to 0x93D5"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint16_t>(0x148Bu)) == | |
| static_cast<uint16_t>(0x8B14u), | |
| "ScalarByteSwap(static_cast<uint16_t>(0x148Bu)) must be equal to 0x8B14"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint16_t>(0x0D51u)) == | |
| static_cast<uint16_t>(0x510Du), | |
| "ScalarByteSwap(static_cast<uint16_t>(0x0D51u)) must be equal to 0x510D"); | |
| static_assert( | |
| ScalarByteSwap(static_cast<uint16_t>(0xFA1Au)) == | |
| static_cast<uint16_t>(0x1AFAu), | |
| "ScalarByteSwap(static_cast<uint16_t>(0xFA1Au)) must be equal to 0x1AFA"); | |
| static_assert(ScalarByteSwap(static_cast<uint32_t>(0xBB4582E5u)) == | |
| static_cast<uint32_t>(0xE58245BBu), | |
| "ScalarByteSwap(static_cast<uint32_t>(0xBB4582E5u)) must be " | |
| "equal to 0xE58245BB"); | |
| static_assert(ScalarByteSwap(static_cast<uint32_t>(0x2B876DCCu)) == | |
| static_cast<uint32_t>(0xCC6D872Bu), | |
| "ScalarByteSwap(static_cast<uint32_t>(0x2B876DCCu)) must be " | |
| "equal to 0xCC6D872B"); | |
| static_assert(ScalarByteSwap(static_cast<uint32_t>(0x71CD104Bu)) == | |
| static_cast<uint32_t>(0x4B10CD71u), | |
| "ScalarByteSwap(static_cast<uint32_t>(0x71CD104Bu)) must be " | |
| "equal to 0x4B10CD71"); | |
| static_assert(ScalarByteSwap(static_cast<uint32_t>(0x85D7EF06u)) == | |
| static_cast<uint32_t>(0x06EFD785u), | |
| "ScalarByteSwap(static_cast<uint32_t>(0x85D7EF06u)) must be " | |
| "equal to 0x06EFD785"); | |
| static_assert(ScalarByteSwap(static_cast<uint64_t>(0xA7B54F853A153699ULL)) == | |
| static_cast<uint64_t>(0x9936153A854FB5A7ULL), | |
| "ScalarByteSwap(static_cast<uint64_t>(0xA7B54F853A153699ULL)) " | |
| "must be equal to 0x9936153A854FB5A7"); | |
| static_assert(ScalarByteSwap(static_cast<uint64_t>(0x11D48571C5EC46F2ULL)) == | |
| static_cast<uint64_t>(0xF246ECC57185D411ULL), | |
| "ScalarByteSwap(static_cast<uint64_t>(0x11D48571C5EC46F2ULL)) " | |
| "must be equal to 0xF246ECC57185D411"); | |
| static_assert(ScalarByteSwap(static_cast<uint64_t>(0x634899428FD79059ULL)) == | |
| static_cast<uint64_t>(0x5990D78F42994863ULL), | |
| "ScalarByteSwap(static_cast<uint64_t>(0x634899428FD79059u)) " | |
| "must be equal to 0x5990D78F42994863"); | |
| static_assert(ScalarByteSwap(static_cast<uint64_t>(0x8BDDFB0D305E5B57ULL)) == | |
| static_cast<uint64_t>(0x575B5E300DFBDD8BULL), | |
| "ScalarByteSwap(static_cast<uint64_t>(0x8BDDFB0D305E5B57ULL)) " | |
| "must be equal to 0x575B5E300DFBDD8B"); | |
| const uint64_t u64_zero = static_cast<uint64_t>(hwy::Unpredictable1() - 1); | |
| HWY_ASSERT_EQ(static_cast<int8_t>(0xA2u), | |
| ScalarByteSwap(static_cast<int8_t>(0xA2ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int8_t>(0xD0u), | |
| ScalarByteSwap(static_cast<int8_t>(0xD0ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int8_t>(0x2Du), | |
| ScalarByteSwap(static_cast<int8_t>(0x2DULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int8_t>(0x18u), | |
| ScalarByteSwap(static_cast<int8_t>(0x18ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int16_t>(0xDAADu), | |
| ScalarByteSwap(static_cast<int16_t>(0xADDAULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int16_t>(0x897Fu), | |
| ScalarByteSwap(static_cast<int16_t>(0x7F89ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int16_t>(0x0052u), | |
| ScalarByteSwap(static_cast<int16_t>(0x5200ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int16_t>(0x47E3u), | |
| ScalarByteSwap(static_cast<int16_t>(0xE347ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int32_t>(0x924B72F3u), | |
| ScalarByteSwap(static_cast<int32_t>(0xF3724B92ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int32_t>(0xA858FB53u), | |
| ScalarByteSwap(static_cast<int32_t>(0x53FB58A8ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int32_t>(0x0374517Du), | |
| ScalarByteSwap(static_cast<int32_t>(0x7D517403ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<int32_t>(0x110A87CDu), | |
| ScalarByteSwap(static_cast<int32_t>(0xCD870A11ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int64_t>(0xB71CB1120DCCFB81ULL), | |
| ScalarByteSwap(static_cast<int64_t>(0x81FBCC0D12B11CB7ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int64_t>(0xB9EEDC00E2E25F56ULL), | |
| ScalarByteSwap(static_cast<int64_t>(0x565FE2E200DCEEB9ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int64_t>(0x4313B3E415BBD472ULL), | |
| ScalarByteSwap(static_cast<int64_t>(0x72D4BB15E4B31343ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int64_t>(0x6C6EE3646E2141A7ULL), | |
| ScalarByteSwap(static_cast<int64_t>(0xA741216E64E36E6CULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint8_t>(0x96u), | |
| ScalarByteSwap(static_cast<uint8_t>(0x96ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint8_t>(0xD2u), | |
| ScalarByteSwap(static_cast<uint8_t>(0xD2ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint8_t>(0x0Eu), | |
| ScalarByteSwap(static_cast<uint8_t>(0x0EULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint8_t>(0x2Fu), | |
| ScalarByteSwap(static_cast<uint8_t>(0x2FULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint16_t>(0x90A8u), | |
| ScalarByteSwap(static_cast<uint16_t>(0xA890ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint16_t>(0x8207u), | |
| ScalarByteSwap(static_cast<uint16_t>(0x0782ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint16_t>(0x0D15u), | |
| ScalarByteSwap(static_cast<uint16_t>(0x150DULL ^ u64_zero))); | |
| HWY_ASSERT_EQ(static_cast<uint16_t>(0x1EE4u), | |
| ScalarByteSwap(static_cast<uint16_t>(0xE41EULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint32_t>(0xB3790AC1u), | |
| ScalarByteSwap(static_cast<uint32_t>(0xC10A79B3ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint32_t>(0xA966BF42u), | |
| ScalarByteSwap(static_cast<uint32_t>(0x42BF66A9ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint32_t>(0x5025F263u), | |
| ScalarByteSwap(static_cast<uint32_t>(0x63F22550ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint32_t>(0x0CC9C6DBu), | |
| ScalarByteSwap(static_cast<uint32_t>(0xDBC6C90CULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint64_t>(0xE6EC3EE7741291A0u), | |
| ScalarByteSwap(static_cast<uint64_t>(0xA0911274E73EECE6ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint64_t>(0xA42680BA115C6425u), | |
| ScalarByteSwap(static_cast<uint64_t>(0x25645C11BA8026A4ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint64_t>(0x364E7B009D165067u), | |
| ScalarByteSwap(static_cast<uint64_t>(0x6750169D007B4E36ULL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint64_t>(0x4F02323A5165FEFEu), | |
| ScalarByteSwap(static_cast<uint64_t>(0xFEFE65513A32024FULL ^ u64_zero))); | |
| } | |
| HWY_NOINLINE void TestAllNativeFromLittleEndian() { | |
| static_assert(NativeFromLittleEndian(static_cast<int8_t>(-53)) == -53, | |
| "NativeFromLittleEndian(static_cast<int8_t>(-53)) must be " | |
| "equal to -53"); | |
| static_assert(NativeFromLittleEndian(static_cast<uint8_t>(34)) == 34u, | |
| "NativeFromLittleEndian(static_cast<uint8_t>(34)) must be " | |
| "equal to 34"); | |
| static_assert(NativeFromLittleEndian(static_cast<int16_t>(26623)) == | |
| (HWY_IS_LITTLE_ENDIAN ? 26623 : -153), | |
| "NativeFromLittleEndian(static_cast<int16_t>(26623)) is not " | |
| "equal to expected value"); | |
| static_assert(NativeFromLittleEndian(static_cast<uint16_t>(11595)) == | |
| (HWY_IS_LITTLE_ENDIAN ? 11595u : 19245u), | |
| "NativeFromLittleEndian(static_cast<uint16_t>(11595)) is " | |
| "not equal to expected value"); | |
| static_assert(NativeFromLittleEndian(static_cast<int32_t>(735768149L)) == | |
| (HWY_IS_LITTLE_ENDIAN ? 735768149L : 1441716779L), | |
| "NativeFromLittleEndian(static_cast<int32_t>(735768149L)) " | |
| "is not equal to expected value"); | |
| static_assert( | |
| NativeFromLittleEndian(static_cast<uint32_t>(2435432080UL)) == | |
| (HWY_IS_LITTLE_ENDIAN ? 2435432080UL : 2428381585UL), | |
| "NativeFromLittleEndian(static_cast<uint32_t>(2435432080UL)) is not " | |
| "equal to expected value"); | |
| static_assert( | |
| NativeFromLittleEndian(static_cast<int64_t>(-5291537098829678526L)) == | |
| (HWY_IS_LITTLE_ENDIAN ? -5291537098829678526LL | |
| : 4807720540899872950LL), | |
| "NativeFromLittleEndian(static_cast<int64_t>(-5291537098829678526L)) " | |
| "is not equal to expected value"); | |
| static_assert( | |
| NativeFromLittleEndian(static_cast<uint64_t>(799030716849950444ULL)) == | |
| (HWY_IS_LITTLE_ENDIAN ? 799030716849950444ULL | |
| : 17045692594081371659ULL), | |
| "NativeFromLittleEndian(static_cast<uint64_t>(799030716849950444ULL)) " | |
| "is not equal to expected value"); | |
| const int64_t i64_zero = static_cast<int64_t>(hwy::Unpredictable1() - 1); | |
| const uint64_t u64_zero = static_cast<uint64_t>(i64_zero); | |
| HWY_ASSERT_EQ(static_cast<int8_t>(86), | |
| NativeFromLittleEndian(static_cast<int8_t>(86 ^ i64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int8_t>(26u), | |
| NativeFromLittleEndian(static_cast<uint8_t>(26u ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int16_t>(HWY_IS_LITTLE_ENDIAN ? 11149 : -29397), | |
| NativeFromLittleEndian(static_cast<int16_t>(11149 ^ i64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint16_t>(HWY_IS_LITTLE_ENDIAN ? 11604u : 21549u), | |
| NativeFromLittleEndian(static_cast<uint16_t>(11604u ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int32_t>(HWY_IS_LITTLE_ENDIAN ? -1741085891L : 1025718680L), | |
| NativeFromLittleEndian(static_cast<int32_t>(-1741085891L ^ i64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint32_t>(HWY_IS_LITTLE_ENDIAN ? 243314907UL : 3685777422UL), | |
| NativeFromLittleEndian(static_cast<uint32_t>(243314907UL ^ u64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<int64_t>(HWY_IS_LITTLE_ENDIAN ? 7535629653599444402LL | |
| : -5558091110541192344LL), | |
| NativeFromLittleEndian( | |
| static_cast<int64_t>(7535629653599444402LL ^ i64_zero))); | |
| HWY_ASSERT_EQ( | |
| static_cast<uint64_t>(HWY_IS_LITTLE_ENDIAN ? 2681831622076265638ULL | |
| : 12030314986439391013ULL), | |
| NativeFromLittleEndian( | |
| static_cast<uint64_t>(2681831622076265638ULL ^ u64_zero))); | |
| } | |
| // ScalarLoadULittleEndian must agree with the byte-wise LoadLE16/32/64, and | |
| // ScalarStoreULittleEndian must be its inverse, at every alignment. This | |
| // pins the byte order so that a future big-endian port cannot silently | |
| // diverge: callers rely on these to read/write little-endian file formats. | |
| HWY_NOINLINE void TestAllScalarLoadStoreULittleEndian() { | |
| // Offsets 0..7 so that every load below is also exercised while unaligned. | |
| HWY_ALIGN_MAX uint8_t bytes[8 + 8]; | |
| for (size_t i = 0; i < sizeof(bytes); ++i) { | |
| bytes[i] = static_cast<uint8_t>(0x80u | (i * 17u)); | |
| } | |
| for (size_t offset = 0; offset < 8; ++offset) { | |
| const uint8_t* p = bytes + offset; | |
| HWY_ASSERT_EQ(static_cast<uint16_t>(LoadLE16(p)), | |
| ScalarLoadULittleEndian<uint16_t>(p)); | |
| HWY_ASSERT_EQ(LoadLE32(p), ScalarLoadULittleEndian<uint32_t>(p)); | |
| HWY_ASSERT_EQ(LoadLE64(p), ScalarLoadULittleEndian<uint64_t>(p)); | |
| // Round-trip: storing what we loaded must reproduce the same bytes. | |
| HWY_ALIGN_MAX uint8_t stored[8 + 8] = {}; | |
| uint8_t* q = stored + offset; | |
| ScalarStoreULittleEndian(ScalarLoadULittleEndian<uint64_t>(p), q); | |
| for (size_t i = 0; i < 8; ++i) { | |
| HWY_ASSERT_EQ(p[i], q[i]); | |
| } | |
| } | |
| // Known values, independent of the host byte order: the least significant | |
| // byte of the loaded value is the first byte in memory. | |
| const uint8_t le[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; | |
| HWY_ASSERT_EQ(uint16_t{0x2301u}, ScalarLoadULittleEndian<uint16_t>(le)); | |
| HWY_ASSERT_EQ(uint32_t{0x67452301u}, ScalarLoadULittleEndian<uint32_t>(le)); | |
| HWY_ASSERT_EQ(uint64_t{0xEFCDAB8967452301ull}, | |
| ScalarLoadULittleEndian<uint64_t>(le)); | |
| uint8_t out[8]; | |
| ScalarStoreULittleEndian(uint64_t{0xEFCDAB8967452301ull}, out); | |
| for (size_t i = 0; i < 8; ++i) { | |
| HWY_ASSERT_EQ(le[i], out[i]); | |
| } | |
| ScalarStoreULittleEndian(uint32_t{0x67452301u}, out); | |
| for (size_t i = 0; i < 4; ++i) { | |
| HWY_ASSERT_EQ(le[i], out[i]); | |
| } | |
| ScalarStoreULittleEndian(uint16_t{0x2301u}, out); | |
| for (size_t i = 0; i < 2; ++i) { | |
| HWY_ASSERT_EQ(le[i], out[i]); | |
| } | |
| } | |
| struct TestSpecialFloat { | |
| template <class T> | |
| static constexpr bool EnableSpecialFloatArithOpTest() { | |
| return (hwy::IsSame<T, float16_t>() && HWY_HAVE_SCALAR_F16_OPERATORS) || | |
| (hwy::IsSame<T, bfloat16_t>() && HWY_HAVE_SCALAR_BF16_OPERATORS); | |
| } | |
| template <class T> | |
| static constexpr HWY_INLINE HWY_MAYBE_UNUSED T | |
| EnsureNotNativeSpecialFloat(T&& val) { | |
| #if HWY_HAVE_SCALAR_F16_TYPE | |
| static_assert(!hwy::IsSame<RemoveCvRef<T>, float16_t::Native>(), | |
| "The operator must not return a float16_t::Native"); | |
| #endif | |
| #if HWY_HAVE_SCALAR_BF16_TYPE | |
| static_assert(!hwy::IsSame<RemoveCvRef<T>, bfloat16_t::Native>(), | |
| "The operator must not return a bfloat16_t::Native"); | |
| #endif | |
| return static_cast<T&&>(val); | |
| } | |
| template <class T> | |
| static HWY_INLINE HWY_MAYBE_UNUSED void AssertSpecialFloatOpResultInRange( | |
| float min_expected, float max_expected, T actual, const char* filename, | |
| const int line) { | |
| if (!(actual >= min_expected && actual <= max_expected)) { | |
| hwy::Abort( | |
| filename, line, | |
| "mismatch: value was expected to be between %g and %g, got %g\n", | |
| static_cast<double>(min_expected), static_cast<double>(max_expected), | |
| ConvertScalarTo<double>(actual)); | |
| } | |
| } | |
| template <class T, | |
| hwy::EnableIf<EnableSpecialFloatArithOpTest<T>()>* = nullptr> | |
| static HWY_NOINLINE HWY_MAYBE_UNUSED void TestSpecialFloatArithOperators( | |
| T /*unused*/) { | |
| #if HWY_HAVE_SCALAR_F16_OPERATORS || HWY_HAVE_SCALAR_BF16_OPERATORS | |
| AssertSpecialFloatOpResultInRange( | |
| -0.008422852f, -0.008361816f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(-0.008911133f) + | |
| static_cast<T>(5.264282E-4f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 0.44335937f, 0.4453125f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(-0.0014266968f) + | |
| 0.4453125f), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 39.25f, 39.5f, | |
| EnsureNotNativeSpecialFloat(34.25f + static_cast<T>(5.0625f)), __FILE__, | |
| __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 7456.0f, 7488.0f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(0.29101562f) - | |
| static_cast<T>(-7456.0f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| -2.21875f, -2.203125f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(1.66893E-4f) - 2.21875f), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 0.32421875f, 0.32617188f, | |
| EnsureNotNativeSpecialFloat(0.35351562f - static_cast<T>(0.028198242f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| -0.01135254f, -0.011291503f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(2.109375f) * | |
| static_cast<T>(-0.0053710938f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 2.359375f, 2.375f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(0.0019454956f) * 1216.0f), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| -1.1014938E-4f, 3.453125f, | |
| EnsureNotNativeSpecialFloat(-0.00038146973f * | |
| static_cast<T>(-0.00037956237f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| -27.875f, -27.75f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(-56.5f) / | |
| static_cast<T>(2.03125f)), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 0.033203125f, 0.033447266f, | |
| EnsureNotNativeSpecialFloat(static_cast<T>(470.0f) / 14080.0f), | |
| __FILE__, __LINE__); | |
| AssertSpecialFloatOpResultInRange( | |
| 0.51953125f, 0.5234375f, | |
| EnsureNotNativeSpecialFloat(0.26367188f / static_cast<T>(0.50390625f)), | |
| __FILE__, __LINE__); | |
| T incr_assign_result_1 = static_cast<T>(1.373291E-4f); | |
| EnsureNotNativeSpecialFloat(incr_assign_result_1 += | |
| static_cast<T>(-20.375f)); | |
| AssertSpecialFloatOpResultInRange(-20.375f, -20.25f, incr_assign_result_1, | |
| __FILE__, __LINE__); | |
| T incr_assign_result_2 = static_cast<T>(2.1457672E-4f); | |
| EnsureNotNativeSpecialFloat(incr_assign_result_2 += static_cast<int8_t>(7)); | |
| AssertSpecialFloatOpResultInRange(7.0f, 7.03125f, incr_assign_result_2, | |
| __FILE__, __LINE__); | |
| float incr_assign_result3 = -6.747985f; | |
| incr_assign_result3 += static_cast<T>(4.15625f); | |
| AssertSpecialFloatOpResultInRange(-2.59375f, -2.578125f, | |
| incr_assign_result3, __FILE__, __LINE__); | |
| float incr_assign_result4 = 6.71875; | |
| incr_assign_result4 += static_cast<T>(2.359375); | |
| AssertSpecialFloatOpResultInRange(9.0625, 9.125, incr_assign_result4, | |
| __FILE__, __LINE__); | |
| T decr_assign_result_1 = static_cast<T>(4.4059753E-4f); | |
| EnsureNotNativeSpecialFloat(decr_assign_result_1 -= | |
| static_cast<T>(6880.0f)); | |
| AssertSpecialFloatOpResultInRange(-6880, -6848, decr_assign_result_1, | |
| __FILE__, __LINE__); | |
| T decr_assign_result_2 = static_cast<T>(85.5f); | |
| EnsureNotNativeSpecialFloat(decr_assign_result_2 -= static_cast<int8_t>(5)); | |
| AssertSpecialFloatOpResultInRange(80.5f, 80.5f, decr_assign_result_2, | |
| __FILE__, __LINE__); | |
| float decr_assign_result3 = 9.875f; | |
| decr_assign_result3 -= static_cast<T>(1.5234375f); | |
| AssertSpecialFloatOpResultInRange(8.3125f, 8.375f, decr_assign_result3, | |
| __FILE__, __LINE__); | |
| double decr_assign_result4 = 0.337890625; | |
| decr_assign_result4 -= static_cast<T>(2.328125); | |
| AssertSpecialFloatOpResultInRange(-1.9921875, -1.984375, | |
| decr_assign_result4, __FILE__, __LINE__); | |
| T mul_assign_result_1 = static_cast<T>(15680.0f); | |
| EnsureNotNativeSpecialFloat(mul_assign_result_1 *= | |
| static_cast<T>(0.001373291f)); | |
| AssertSpecialFloatOpResultInRange(21.5f, 21.625f, mul_assign_result_1, | |
| __FILE__, __LINE__); | |
| T mul_assign_result_2 = static_cast<T>(2.609375f); | |
| EnsureNotNativeSpecialFloat(mul_assign_result_2 *= static_cast<int8_t>(7)); | |
| AssertSpecialFloatOpResultInRange(18.25, 18.375, mul_assign_result_2, | |
| __FILE__, __LINE__); | |
| float mul_assign_result3 = 4.125f; | |
| mul_assign_result3 *= static_cast<T>(3.375f); | |
| AssertSpecialFloatOpResultInRange(13.875f, 13.9375f, mul_assign_result3, | |
| __FILE__, __LINE__); | |
| double mul_assign_result4 = 7.9375; | |
| mul_assign_result4 *= static_cast<T>(0.79296875); | |
| AssertSpecialFloatOpResultInRange(6.28125, 6.3125, mul_assign_result4, | |
| __FILE__, __LINE__); | |
| T div_assign_result_1 = static_cast<T>(11584.0f); | |
| EnsureNotNativeSpecialFloat(div_assign_result_1 /= static_cast<T>(9.5625f)); | |
| AssertSpecialFloatOpResultInRange(1208.0f, 1216.0f, div_assign_result_1, | |
| __FILE__, __LINE__); | |
| T div_assign_result_2 = static_cast<T>(0.12109375f); | |
| EnsureNotNativeSpecialFloat(div_assign_result_2 /= static_cast<int8_t>(3)); | |
| AssertSpecialFloatOpResultInRange(0.040283203f, 0.040527344f, | |
| div_assign_result_2, __FILE__, __LINE__); | |
| float div_assign_result_3 = 0.21679688f; | |
| div_assign_result_3 /= static_cast<T>(3.421875f); | |
| AssertSpecialFloatOpResultInRange(0.06298828125f, 0.0634765625f, | |
| div_assign_result_3, __FILE__, __LINE__); | |
| double div_assign_result_4 = 5.34375; | |
| div_assign_result_4 /= static_cast<T>(0.337890625); | |
| AssertSpecialFloatOpResultInRange(15.8125, 15.875, div_assign_result_4, | |
| __FILE__, __LINE__); | |
| HWY_ASSERT_EQ(static_cast<T>(-1.0f), | |
| EnsureNotNativeSpecialFloat(-static_cast<T>(1.0f))); | |
| HWY_ASSERT_EQ(static_cast<T>(1.0f), | |
| EnsureNotNativeSpecialFloat(+static_cast<T>(1.0f))); | |
| T pre_incr_result_1 = static_cast<T>(1.0f); | |
| T pre_incr_result_2 = EnsureNotNativeSpecialFloat(++pre_incr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(2.0f), pre_incr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(2.0f), pre_incr_result_2); | |
| T post_incr_result_1 = static_cast<T>(5.0f); | |
| T post_incr_result_2 = EnsureNotNativeSpecialFloat(post_incr_result_1++); | |
| HWY_ASSERT_EQ(static_cast<T>(6.0f), post_incr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(5.0f), post_incr_result_2); | |
| T pre_decr_result_1 = static_cast<T>(-2.0f); | |
| T pre_decr_result_2 = EnsureNotNativeSpecialFloat(--pre_decr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(-3.0f), pre_decr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(-3.0f), pre_decr_result_2); | |
| T post_decr_result_1 = static_cast<T>(-7.0f); | |
| T post_decr_result_2 = EnsureNotNativeSpecialFloat(post_decr_result_1--); | |
| HWY_ASSERT_EQ(static_cast<T>(-8.0f), post_decr_result_1); | |
| HWY_ASSERT_EQ(static_cast<T>(-7.0f), post_decr_result_2); | |
| HWY_ASSERT(static_cast<T>(1.0f) == 1.0f); | |
| HWY_ASSERT(static_cast<T>(-2.40625f) != 0.0033416748f); | |
| HWY_ASSERT(static_cast<T>(-3248.0f) < 0.0018997193f); | |
| HWY_ASSERT(static_cast<T>(-27904.0f) <= -3.859375f); | |
| HWY_ASSERT(static_cast<T>(1.078125f) > 0.010009765f); | |
| HWY_ASSERT(static_cast<T>(45312.0f) >= 0.00024318695f); | |
| HWY_ASSERT(2.0f == static_cast<T>(2.0f)); | |
| HWY_ASSERT(-5.78125f != static_cast<T>(-15168.0f)); | |
| HWY_ASSERT(-0.056884766f < static_cast<T>(0.000088214875f)); | |
| HWY_ASSERT(0.00008392333f <= static_cast<T>(1384.0f)); | |
| HWY_ASSERT(21888.0f > static_cast<T>(-2.578125f)); | |
| HWY_ASSERT(0.087402344 >= static_cast<T>(-0.65625f)); | |
| #endif // HWY_HAVE_SCALAR_F16_OPERATORS || HWY_HAVE_SCALAR_BF16_OPERATORS | |
| } | |
| template <class T, | |
| hwy::EnableIf<!EnableSpecialFloatArithOpTest<T>()>* = nullptr> | |
| static HWY_INLINE void TestSpecialFloatArithOperators(T /*unused*/) {} | |
| // The emulated scalar operators (value ctor, unary minus, ++/--) are provided | |
| // when the special float lacks a native type. When a native type exists they | |
| // are only available if the native operators are (HWY_HAVE_SCALAR_*_OPERATORS). | |
| template <class T> | |
| static constexpr bool EnableSpecialFloatScalarOpsTest() { | |
| return (hwy::IsSame<T, float16_t>() && | |
| (HWY_HAVE_SCALAR_F16_OPERATORS || !HWY_HAVE_SCALAR_F16_TYPE)) || | |
| (hwy::IsSame<T, bfloat16_t>() && | |
| (HWY_HAVE_SCALAR_BF16_OPERATORS || !HWY_HAVE_SCALAR_BF16_TYPE)); | |
| } | |
| // Value construction, unary minus, and increment/decrement work for both | |
| // special floats on every target, including those that emulate them with a | |
| // uint16_t (where these previously failed to compile). Both float16_t and | |
| // bfloat16_t now provide them. | |
| template <class T, | |
| hwy::EnableIf<EnableSpecialFloatScalarOpsTest<T>()>* = nullptr> | |
| static HWY_NOINLINE void TestSpecialFloatScalarOps(T /*unused*/) { | |
| HWY_ASSERT_EQ(2.0f, ConvertScalarTo<float>(T(2))); // value ctor from int | |
| HWY_ASSERT_EQ(2.5f, ConvertScalarTo<float>(T(2.5))); // value ctor from double | |
| HWY_ASSERT_EQ(-3.0f, ConvertScalarTo<float>(-T(3))); // unary minus | |
| // Start from a value the compiler cannot predict, then PreventElision on | |
| // the result so the increment/decrement is not optimized away. | |
| T inc = T(Unpredictable1()); // == 1 | |
| ++inc; // 2 | |
| HWY_ASSERT_EQ(2.0f, ConvertScalarTo<float>(inc)); // pre-increment | |
| PreventElision(inc); | |
| T dec = T(Unpredictable1()); // == 1 | |
| --dec; // 0 | |
| HWY_ASSERT_EQ(0.0f, ConvertScalarTo<float>(dec)); // pre-decrement | |
| PreventElision(dec); | |
| } | |
| template <class T, | |
| hwy::EnableIf<!EnableSpecialFloatScalarOpsTest<T>()>* = nullptr> | |
| static HWY_INLINE HWY_MAYBE_UNUSED void TestSpecialFloatScalarOps( | |
| T /*unused*/) {} | |
| template <class T> | |
| HWY_NOINLINE void operator()(T /*unused*/) const { | |
| static_assert(IsSpecialFloat<T>(), "IsSpecialFloat<T>() must be true"); | |
| HWY_ASSERT_EQ(static_cast<uint32_t>(0x436B0000u), | |
| BitCastScalar<uint32_t>(ConvertScalarTo<float>( | |
| BitCastScalar<T>(static_cast<uint16_t>( | |
| IsSame<T, hwy::float16_t>() ? 0x5B58u : 0x436Bu))))); | |
| HWY_ASSERT_EQ(static_cast<uint32_t>(0xBB790000u), | |
| BitCastScalar<uint32_t>(ConvertScalarTo<float>( | |
| BitCastScalar<T>(static_cast<uint16_t>( | |
| IsSame<T, hwy::float16_t>() ? 0x9BC8u : 0xBB79u))))); | |
| HWY_ASSERT_EQ(static_cast<uint32_t>( | |
| IsSame<T, hwy::float16_t>() ? 0xC0B86000u : 0xC5C30000u), | |
| BitCastScalar<uint32_t>(ConvertScalarTo<float>( | |
| BitCastScalar<T>(static_cast<uint16_t>(0xC5C3u))))); | |
| HWY_ASSERT_EQ(static_cast<uint32_t>( | |
| IsSame<T, hwy::float16_t>() ? 0x41D20000u : 0x4E900000u), | |
| BitCastScalar<uint32_t>(ConvertScalarTo<float>( | |
| BitCastScalar<T>(static_cast<uint16_t>(0x4E90u))))); | |
| HWY_ASSERT_EQ(1696.0, ConvertScalarTo<double>(ConvertScalarTo<T>(1696.0f))); | |
| HWY_ASSERT_EQ( | |
| -0.00177001953125f, | |
| ConvertScalarTo<float>(ConvertScalarTo<T>(-0.00177001953125f))); | |
| HWY_ASSERT_EQ(0.49609375f, | |
| ConvertScalarTo<float>(ConvertScalarTo<T>(0.49609375))); | |
| HWY_ASSERT_EQ( | |
| 0.000553131103515625, | |
| ConvertScalarTo<double>(ConvertScalarTo<T>(0.000553131103515625))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<T>(3.0f), ConvertScalarTo<T>(3)); | |
| HWY_ASSERT_EQ(ConvertScalarTo<T>(-5.5f), ConvertScalarTo<T>(-5.5)); | |
| HWY_ASSERT_EQ(ConvertScalarTo<T>(0.82421875f), | |
| ConvertScalarTo<T>(BF16FromF32(0.82421875f))); | |
| HWY_ASSERT_EQ(ConvertScalarTo<T>(-6.375f), | |
| ConvertScalarTo<T>(F16FromF32(-6.375f))); | |
| HWY_ASSERT(ConvertScalarTo<T>(-3.671875f) < | |
| ConvertScalarTo<T>(0.0218505859375f)); | |
| HWY_ASSERT(ConvertScalarTo<T>(-0.033447265625f) <= | |
| ConvertScalarTo<T>(8.249282836914062E-5f)); | |
| HWY_ASSERT(ConvertScalarTo<T>(23296.0f) > ConvertScalarTo<T>(192.0f)); | |
| HWY_ASSERT(ConvertScalarTo<T>(41984.0f) >= ConvertScalarTo<T>(370.0f)); | |
| TestSpecialFloatArithOperators(T()); | |
| TestSpecialFloatScalarOps(T()); | |
| } | |
| }; | |
| HWY_NOINLINE void TestAllSpecialFloat() { | |
| TestSpecialFloat test; | |
| test(float16_t()); | |
| test(bfloat16_t()); | |
| } | |
| } // namespace | |
| // NOLINTNEXTLINE(google-readability-namespace-comments) | |
| } // namespace HWY_NAMESPACE | |
| } // namespace hwy | |
| HWY_AFTER_NAMESPACE(); | |
| #if HWY_ONCE | |
| namespace hwy { | |
| namespace { | |
| #ifdef GTEST_HAS_DEATH_TEST | |
| #if HWY_CXX_LANG >= 201703L | |
| TEST(BaseDeathTest, DivCeilByZero) { | |
| ASSERT_DEATH({ (void)DivCeil(size_t{1}, size_t{0}); }, "Assert b != T2"); | |
| } | |
| #endif // HWY_CXX_LANG >= 201703L | |
| TEST(BaseDeathTest, DivisorZero) { | |
| ASSERT_DEATH( | |
| { | |
| Divisor divisor(0); | |
| (void)divisor; | |
| }, | |
| "Assert divisor != 0"); | |
| } | |
| TEST(BaseDeathTest, Divisor64Zero) { | |
| ASSERT_DEATH( | |
| { | |
| Divisor64 divisor(0); | |
| (void)divisor; | |
| }, | |
| "Assert divisor != 0"); | |
| } | |
| #if HWY_IS_DEBUG_BUILD | |
| TEST(BaseDeathTest, SafeCastNegative) { | |
| const int64_t neg = -static_cast<int64_t>(Unpredictable1()); | |
| ASSERT_DEATH( | |
| { | |
| const size_t unused = SafeCast<size_t>(neg); | |
| (void)unused; | |
| }, | |
| "ScalarFits"); | |
| ASSERT_DEATH( | |
| { | |
| const int8_t unused = SafeCast<int8_t>(129 * neg); | |
| (void)unused; | |
| }, | |
| "ScalarFits"); | |
| } | |
| TEST(BaseDeathTest, SafeCastTooLarge) { | |
| const uint64_t big = uint64_t{256} * static_cast<uint64_t>(Unpredictable1()); | |
| ASSERT_DEATH( | |
| { | |
| const uint8_t unused = SafeCast<uint8_t>(big); | |
| (void)unused; | |
| }, | |
| "ScalarFits"); | |
| } | |
| TEST(BaseDeathTest, SafeAddOverflow) { | |
| const uint64_t one = static_cast<uint64_t>(Unpredictable1()); | |
| ASSERT_DEATH( | |
| { | |
| const uint64_t unused = SafeAdd<uint64_t>(LimitsMax<uint64_t>(), one); | |
| (void)unused; | |
| }, | |
| "SumFits"); | |
| ASSERT_DEATH( | |
| { | |
| const int64_t unused = SafeAdd<int64_t>( | |
| static_cast<uint64_t>(LimitsMax<int64_t>()), one); | |
| (void)unused; | |
| }, | |
| "SumFits"); | |
| } | |
| #endif // HWY_IS_DEBUG_BUILD | |
| #endif // GTEST_HAS_DEATH_TEST | |
| HWY_BEFORE_TEST(BaseTest); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestUnreachable); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllLimits); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllSafeArith); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllLowestHighest); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllType); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllIsSame); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllBitScan); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllPopCount); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllDivCeil); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllDivisor); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllDivisor64); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllScalarShr); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllMul128); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllEndian); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllScalarByteSwap); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllNativeFromLittleEndian); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllScalarLoadStoreULittleEndian); | |
| HWY_EXPORT_AND_TEST_P(BaseTest, TestAllSpecialFloat); | |
| HWY_AFTER_TEST(); | |
| } // namespace | |
| } // namespace hwy | |
| HWY_TEST_MAIN(); | |
| #endif // HWY_ONCE |