diff options
Diffstat (limited to 'test/std/experimental/simd')
15 files changed, 1137 insertions, 397 deletions
diff --git a/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp new file mode 100644 index 000000000000..dd8436618111 --- /dev/null +++ b/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// [simd.abi] + +#include <experimental/simd> +#include <cstdint> + +namespace ex = std::experimental::parallelism_v2; + +constexpr inline int reg_width() { +#if defined(__AVX__) + return 32; +#else + return 16; +#endif +} + +#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION + +static_assert( + sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 1>>) == 1, + ""); +static_assert( + sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 2>>) == 2, + ""); +static_assert( + sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) == 4, + ""); +static_assert( + sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 12>>) == 16, + ""); +static_assert( + sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) == + 16, + ""); +static_assert( + sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) == + 32, + ""); +static_assert( + std::is_same<ex::simd_abi::native<int8_t>, + ex::__simd_abi<ex::_StorageKind::_VecExt, reg_width()>>::value, + ""); +#else +static_assert( + std::is_same<ex::simd_abi::native<int8_t>, + ex::__simd_abi<ex::_StorageKind::_Array, reg_width()>>::value, + ""); + +#endif + +static_assert(std::is_same<ex::simd_abi::compatible<int8_t>, + ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value, + ""); + +int main() {} diff --git a/test/std/experimental/simd/simd.access/default.pass.cpp b/test/std/experimental/simd/simd.access/default.pass.cpp new file mode 100644 index 000000000000..6ce32cab8673 --- /dev/null +++ b/test/std/experimental/simd/simd.access/default.pass.cpp @@ -0,0 +1,217 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// scalar access [simd.subscr] +// reference operator[](size_t); +// value_type operator[](size_t) const; + +#include <experimental/simd> +#include <cassert> +#include <cstdint> + +namespace ex = std::experimental::parallelism_v2; + +template <typename SimdType> +void test_access() { + { + SimdType a(42), b(4); + static_assert(std::is_convertible<decltype(a[0]), int8_t>::value, ""); + + assert(a[0] == 42); + assert(!a[0] == !42); + assert(~a[0] == ~42); + assert(+a[0] == +42); + assert(-a[0] == -42); + assert(a[0] + b[0] == 42 + 4); + assert(a[0] - b[0] == 42 - 4); + assert(a[0] * b[0] == 42 * 4); + assert(a[0] / b[0] == 42 / 4); + assert(a[0] % b[0] == 42 % 4); + assert(a[0] << b[0] == (42 << 4)); + assert(a[0] >> b[0] == (42 >> 4)); + assert(a[0] < b[0] == false); + assert(a[0] <= b[0] == false); + assert(a[0] > b[0] == true); + assert(a[0] >= b[0] == true); + assert(a[0] == b[0] == false); + assert(a[0] != b[0] == true); + assert((a[0] & b[0]) == (42 & 4)); + assert((a[0] | b[0]) == (42 | 4)); + assert((a[0] ^ b[0]) == (42 ^ 4)); + assert((a[0] && b[0]) == true); + assert((a[0] || b[0]) == true); + + { + auto c = a; + ++c[0]; + assert(c[0] == 42 + 1); + assert(c[1] == 42); + } + { + auto c = a; + auto ret = c[0]++; + assert(ret == 42); + assert(c[0] == 42 + 1); + assert(c[1] == 42); + } + { + auto c = a; + --c[0]; + assert(c[0] == 42 - 1); + assert(c[1] == 42); + } + { + auto c = a; + auto ret = c[0]--; + assert(ret == 42); + assert(c[0] == 42 - 1); + assert(c[1] == 42); + } + + { + auto c = a; + c[0] += b[0]; + assert(c[0] == 42 + 4); + assert(c[1] == 42); + } + { + auto c = a; + c[0] -= b[0]; + assert(c[0] == 42 - 4); + assert(c[1] == 42); + } + { + auto c = a; + c[0] *= b[0]; + assert(c[0] == 42 * 4); + assert(c[1] == 42); + } + { + auto c = a; + c[0] /= b[0]; + assert(c[0] == 42 / 4); + assert(c[1] == 42); + } + { + auto c = a; + c[0] %= b[0]; + assert(c[0] == 42 % 4); + assert(c[1] == 42); + } + { + auto c = a; + c[0] >>= b[0]; + assert(c[0] == (42 >> 4)); + assert(c[1] == 42); + } + { + auto c = a; + c[0] <<= b[0]; + assert(c[0] == (42 << 4)); + assert(c[1] == 42); + } + { + auto c = a; + c[0] &= b[0]; + assert(c[0] == (42 & 4)); + assert(c[1] == 42); + } + { + auto c = a; + c[0] |= b[0]; + assert(c[0] == (42 | 4)); + assert(c[1] == 42); + } + { + auto c = a; + c[0] ^= b[0]; + assert(c[0] == (42 ^ 4)); + assert(c[1] == 42); + } + + { + auto c = a; + (void)(a[0] + (c[0] += a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] -= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] *= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] /= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] %= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] >>= b[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] <<= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] &= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] |= a[0])); + } + { + auto c = a; + (void)(a[0] + (c[0] ^= a[0])); + } + } + { + const SimdType a(42); + const SimdType b(4); + static_assert(std::is_same<decltype(a[0]), int>::value, ""); + + assert(a[0] == 42); + assert(!a[0] == !42); + assert(~a[0] == ~42); + assert(+a[0] == +42); + assert(-a[0] == -42); + assert(a[0] + b[0] == 42 + 4); + assert(a[0] - b[0] == 42 - 4); + assert(a[0] * b[0] == 42 * 4); + assert(a[0] / b[0] == 42 / 4); + assert(a[0] % b[0] == 42 % 4); + assert(a[0] << b[0] == (42 << 4)); + assert(a[0] >> b[0] == (42 >> 4)); + assert(a[0] < b[0] == false); + assert(a[0] <= b[0] == false); + assert(a[0] > b[0] == true); + assert(a[0] >= b[0] == true); + assert(a[0] == b[0] == false); + assert(a[0] != b[0] == true); + assert((a[0] & b[0]) == (42 & 4)); + assert((a[0] | b[0]) == (42 | 4)); + assert((a[0] ^ b[0]) == (42 ^ 4)); + assert((a[0] && b[0]) == true); + assert((a[0] || b[0]) == true); + } +} + +int main() { + test_access<ex::native_simd<int>>(); + test_access<ex::fixed_size_simd<int, 4>>(); +} diff --git a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp index af6b13fe878d..d15f138d5b90 100644 --- a/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp +++ b/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp @@ -7,34 +7,40 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.casts] -// template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&); +// template <class T, class U, class Abi> see below ex::simd_cast<(const +// ex::simd<U, Abi>&); + #include <experimental/simd> #include <cstdint> -using namespace std::experimental::parallelism_v2; - -static_assert(std::is_same<decltype(simd_cast<int32_t>(native_simd<int32_t>())), - native_simd<int32_t>>::value, - ""); +namespace ex = std::experimental::parallelism_v2; static_assert( - std::is_same<decltype(simd_cast<int64_t>(fixed_size_simd<int32_t, 4>())), - fixed_size_simd<int64_t, 4>>::value, + std::is_same<decltype(ex::simd_cast<int32_t>(ex::native_simd<int32_t>())), + ex::native_simd<int32_t>>::value, ""); -static_assert(std::is_same<decltype(simd_cast<fixed_size_simd<int64_t, 1>>( - simd<int32_t, simd_abi::scalar>())), - fixed_size_simd<int64_t, 1>>::value, +static_assert(std::is_same<decltype(ex::simd_cast<int64_t>( + ex::fixed_size_simd<int32_t, 4>())), + ex::fixed_size_simd<int64_t, 4>>::value, ""); -static_assert(std::is_same<decltype(simd_cast<simd<int64_t, simd_abi::scalar>>( - fixed_size_simd<int32_t, 1>())), - simd<int64_t, simd_abi::scalar>>::value, - ""); +static_assert( + std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<int64_t, 1>>( + ex::simd<int32_t, ex::simd_abi::scalar>())), + ex::fixed_size_simd<int64_t, 1>>::value, + ""); + +static_assert( + std::is_same< + decltype(ex::simd_cast<ex::simd<int64_t, ex::simd_abi::scalar>>( + ex::fixed_size_simd<int32_t, 1>())), + ex::simd<int64_t, ex::simd_abi::scalar>>::value, + ""); int main() {} diff --git a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp index eb1fa55e0a44..b734664770ef 100644 --- a/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp +++ b/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp @@ -7,32 +7,35 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.casts] -// template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&); +// template <class T, class U, class Abi> see below ex::static_simd_cast<(const +// ex::simd<U, Abi>&); #include <experimental/simd> #include <cstdint> -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; static_assert( - std::is_same<decltype(static_simd_cast<float>(native_simd<int>())), - native_simd<float>>::value, + std::is_same<decltype(ex::static_simd_cast<float>(ex::native_simd<int>())), + ex::native_simd<float>>::value, ""); -static_assert(std::is_same<decltype(static_simd_cast<fixed_size_simd<float, 1>>( - simd<int, simd_abi::scalar>())), - fixed_size_simd<float, 1>>::value, - ""); +static_assert( + std::is_same<decltype(ex::static_simd_cast<ex::fixed_size_simd<float, 1>>( + ex::simd<int, ex::simd_abi::scalar>())), + ex::fixed_size_simd<float, 1>>::value, + ""); static_assert( - std::is_same<decltype(static_simd_cast<simd<float, simd_abi::scalar>>( - fixed_size_simd<int, 1>())), - simd<float, simd_abi::scalar>>::value, + std::is_same< + decltype(ex::static_simd_cast<ex::simd<float, ex::simd_abi::scalar>>( + ex::fixed_size_simd<int, 1>())), + ex::simd<float, ex::simd_abi::scalar>>::value, ""); int main() {} diff --git a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp index 60230cc63735..49b2b5572842 100644 --- a/test/std/experimental/simd/simd.cons/broadcast.pass.cpp +++ b/test/std/experimental/simd/simd.cons/broadcast.pass.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // See GCC PR63723. // UNSUPPORTED: gcc-4.9 @@ -20,18 +20,19 @@ #include <cstdint> #include <experimental/simd> -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; template <class T, class... Args> auto not_supported_native_simd_ctor(Args&&... args) - -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) = delete; + -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), + void()) = delete; template <class T> void not_supported_native_simd_ctor(...) {} template <class T, class... Args> auto supported_native_simd_ctor(Args&&... args) - -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) {} + -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), void()) {} template <class T> void supported_native_simd_ctor(...) = delete; @@ -55,4 +56,31 @@ void compile_narrowing_conversion() { not_supported_native_simd_ctor<int>(3.); } -int main() {} +void compile_convertible() { + struct ConvertibleToInt { + operator int64_t() const; + }; + supported_native_simd_ctor<int64_t>(ConvertibleToInt()); + + struct NotConvertibleToInt {}; + not_supported_native_simd_ctor<int64_t>(NotConvertibleToInt()); +} + +void compile_unsigned() { + not_supported_native_simd_ctor<int>(3u); + supported_native_simd_ctor<uint16_t>(3u); +} + +template <typename SimdType> +void test_broadcast() { + SimdType a(3); + for (size_t i = 0; i < a.size(); i++) { + assert(a[i] == 3); + } +} + +int main() { + test_broadcast<ex::native_simd<int>>(); + test_broadcast<ex::fixed_size_simd<int, 4>>(); + test_broadcast<ex::fixed_size_simd<int, 15>>(); +} diff --git a/test/std/experimental/simd/simd.cons/default.pass.cpp b/test/std/experimental/simd/simd.cons/default.pass.cpp new file mode 100644 index 000000000000..0f12eced0aaf --- /dev/null +++ b/test/std/experimental/simd/simd.cons/default.pass.cpp @@ -0,0 +1,28 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// [simd.class] +// simd() = default; + +#include <cstdint> +#include <experimental/simd> + +namespace ex = std::experimental::parallelism_v2; + +int main() { + static_assert(ex::native_simd<int32_t>().size() > 0, ""); + static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, ""); + static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, ""); + static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, ""); + static_assert(ex::fixed_size_simd<char, 32>().size() == 32, ""); +} diff --git a/test/std/experimental/simd/simd.cons/generator.pass.cpp b/test/std/experimental/simd/simd.cons/generator.pass.cpp index baf7d936c6a3..43273e896b41 100644 --- a/test/std/experimental/simd/simd.cons/generator.pass.cpp +++ b/test/std/experimental/simd/simd.cons/generator.pass.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // See GCC PR63723. // UNSUPPORTED: gcc-4.9 @@ -17,30 +17,75 @@ // [simd.class] // template <class G> explicit simd(G&& gen); -#include <cstdint> #include <experimental/simd> +#include <cstdint> -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; template <class T, class... Args> -auto not_supported_native_simd_ctor(Args&&... args) - -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) = delete; +auto not_supported_simd128_ctor(Args&&... args) -> decltype( + ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...), + void()) = delete; template <class T> -void not_supported_native_simd_ctor(...) {} +void not_supported_simd128_ctor(...) {} template <class T, class... Args> -auto supported_native_simd_ctor(Args&&... args) - -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) {} +auto supported_simd128_ctor(Args&&... args) -> decltype( + ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...), + void()) {} template <class T> -void supported_native_simd_ctor(...) = delete; +void supported_simd128_ctor(...) = delete; + +struct identity { + template <size_t value> + int operator()(std::integral_constant<size_t, value>) const { + return value; + } +}; void compile_generator() { - supported_native_simd_ctor<int>([](int i) { return i; }); - not_supported_native_simd_ctor<int>([](int i) { return float(i); }); - not_supported_native_simd_ctor<int>([](intptr_t i) { return (int*)(i); }); - not_supported_native_simd_ctor<int>([](int* i) { return i; }); + supported_simd128_ctor<int>(identity()); + not_supported_simd128_ctor<int>([](int i) { return float(i); }); + not_supported_simd128_ctor<int>([](intptr_t i) { return (int*)(i); }); + not_supported_simd128_ctor<int>([](int* i) { return i; }); } -int main() {} +struct limited_identity { + template <size_t value> + typename std::conditional<value <= 2, int32_t, int64_t>::type + operator()(std::integral_constant<size_t, value>) const { + return value; + } +}; + +void compile_limited_identity() { + supported_simd128_ctor<int64_t>(limited_identity()); + not_supported_simd128_ctor<int32_t>(limited_identity()); +} + +template <typename SimdType> +void test_generator() { + { + SimdType a([](int i) { return i; }); + assert(a[0] == 0); + assert(a[1] == 1); + assert(a[2] == 2); + assert(a[3] == 3); + } + { + SimdType a([](int i) { return 2 * i - 1; }); + assert(a[0] == -1); + assert(a[1] == 1); + assert(a[2] == 3); + assert(a[3] == 5); + } +} + +int main() { + // TODO: adjust the tests when this assertion fails. + assert(ex::native_simd<int32_t>::size() >= 4); + test_generator<ex::native_simd<int32_t>>(); + test_generator<ex::fixed_size_simd<int32_t, 4>>(); +} diff --git a/test/std/experimental/simd/simd.cons/load.pass.cpp b/test/std/experimental/simd/simd.cons/load.pass.cpp new file mode 100644 index 000000000000..8c87fe7a5554 --- /dev/null +++ b/test/std/experimental/simd/simd.cons/load.pass.cpp @@ -0,0 +1,118 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// [simd.class] +// template <class U, class Flags> simd(const U* mem, Flags f); + +#include <cstdint> +#include <experimental/simd> + +#include "test_macros.h" + +namespace ex = std::experimental::parallelism_v2; + +template <class T, class... Args> +auto not_supported_native_simd_ctor(Args&&... args) + -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), + void()) = delete; + +template <class T> +void not_supported_native_simd_ctor(...) {} + +template <class T, class... Args> +auto supported_native_simd_ctor(Args&&... args) + -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), void()) {} + +template <class T> +void supported_native_simd_ctor(...) = delete; + +void compile_load_ctor() { + supported_native_simd_ctor<int>((int*)nullptr, ex::element_aligned_tag()); + supported_native_simd_ctor<uint32_t>((int*)nullptr, + ex::element_aligned_tag()); + supported_native_simd_ctor<double>((float*)nullptr, + ex::element_aligned_tag()); + supported_native_simd_ctor<uint16_t>((unsigned int*)nullptr, + ex::element_aligned_tag()); + supported_native_simd_ctor<uint32_t>((float*)nullptr, + ex::element_aligned_tag()); + + not_supported_native_simd_ctor<int>((int*)nullptr, int()); +} + +template <typename SimdType> +void test_load_ctor() { + alignas(32) int32_t buffer[] = {4, 3, 2, 1}; + { + SimdType a(buffer, ex::element_aligned_tag()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a(buffer, ex::vector_aligned_tag()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a(buffer, ex::overaligned_tag<32>()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + + { + SimdType a(buffer, ex::element_aligned); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a(buffer, ex::vector_aligned); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a(buffer, ex::overaligned<32>); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } +} + +template <typename SimdType> +void test_converting_load_ctor() { + float buffer[] = {1., 2., 4., 8.}; + SimdType a(buffer, ex::element_aligned_tag()); + assert(a[0] == 1); + assert(a[1] == 2); + assert(a[2] == 4); + assert(a[3] == 8); +} + +int main() { + // TODO: adjust the tests when this assertion fails. + assert(ex::native_simd<int32_t>::size() >= 4); + test_load_ctor<ex::native_simd<int32_t>>(); + test_load_ctor<ex::fixed_size_simd<int32_t, 4>>(); + test_converting_load_ctor<ex::native_simd<int32_t>>(); + test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>(); +} diff --git a/test/std/experimental/simd/simd.mem/load.pass.cpp b/test/std/experimental/simd/simd.mem/load.pass.cpp new file mode 100644 index 000000000000..b1a3a2b1d3b5 --- /dev/null +++ b/test/std/experimental/simd/simd.mem/load.pass.cpp @@ -0,0 +1,122 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// loads [simd.load] +// template <class U, class Flags> void copy_from(const U* mem, Flags f); + +#include <experimental/simd> +#include <cstdint> + +#include "test_macros.h" + +namespace ex = std::experimental::parallelism_v2; + +template <class T, class... Args> +auto not_supported_load(Args&&... args) -> decltype( + std::declval<ex::native_simd<T>>().copy_from(std::forward<Args>(args)...), + void()) = delete; + +template <class T> +void not_supported_load(...) {} + +template <class T, class... Args> +auto supported_load(Args&&... args) -> decltype( + std::declval<ex::native_simd<T>>().copy_from(std::forward<Args>(args)...), + void()) {} + +template <class T> +void supported_load(...) = delete; + +void compile_load() { + supported_load<int>((int*)nullptr, ex::element_aligned_tag()); + supported_load<uint32_t>((int*)nullptr, ex::element_aligned_tag()); + supported_load<double>((float*)nullptr, ex::element_aligned_tag()); + supported_load<uint16_t>((unsigned int*)nullptr, ex::element_aligned_tag()); + supported_load<uint32_t>((float*)nullptr, ex::element_aligned_tag()); + + not_supported_load<int>((int*)nullptr, int()); +} + +template <typename SimdType> +void test_load() { + alignas(32) int32_t buffer[] = {4, 3, 2, 1}; + { + SimdType a; + a.copy_from(buffer, ex::element_aligned_tag()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a; + a.copy_from(buffer, ex::vector_aligned_tag()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a; + a.copy_from(buffer, ex::overaligned_tag<32>()); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + + { + SimdType a; + a.copy_from(buffer, ex::element_aligned); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a; + a.copy_from(buffer, ex::vector_aligned); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } + { + SimdType a; + a.copy_from(buffer, ex::overaligned<32>); + assert(a[0] == 4); + assert(a[1] == 3); + assert(a[2] == 2); + assert(a[3] == 1); + } +} + +template <typename SimdType> +void test_converting_load() { + float buffer[] = {1., 2., 4., 8.}; + SimdType a; + a.copy_from(buffer, ex::element_aligned_tag()); + assert(a[0] == 1); + assert(a[1] == 2); + assert(a[2] == 4); + assert(a[3] == 8); +} + +int main() { + // TODO: adjust the tests when this assertion fails. + assert(ex::native_simd<int32_t>::size() >= 4); + test_load<ex::native_simd<int32_t>>(); + test_load<ex::fixed_size_simd<int32_t, 4>>(); + test_converting_load<ex::native_simd<int32_t>>(); + test_converting_load<ex::fixed_size_simd<int32_t, 4>>(); +} diff --git a/test/std/experimental/simd/simd.mem/store.pass.cpp b/test/std/experimental/simd/simd.mem/store.pass.cpp new file mode 100644 index 000000000000..2025a79f21a0 --- /dev/null +++ b/test/std/experimental/simd/simd.mem/store.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +// <experimental/simd> +// +// // stores [simd.store] +// template <class U, class Flags> void copy_to(U* mem, Flags f) const; + +#include <experimental/simd> +#include <cstdint> + +#include "test_macros.h" + +namespace ex = std::experimental::parallelism_v2; + +template <typename SimdType> +void test_store() { + SimdType a([](int i) { return 4 - i; }); + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::element_aligned_tag()); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::vector_aligned_tag()); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::overaligned_tag<32>()); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } + + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::element_aligned); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::vector_aligned); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } + { + alignas(32) int32_t buffer[4] = {0}; + a.copy_to(buffer, ex::overaligned<32>); + assert(buffer[0] == 4); + assert(buffer[1] == 3); + assert(buffer[2] == 2); + assert(buffer[3] == 1); + } +} + +template <typename SimdType> +void test_converting_store() { + float buffer[4] = {0.}; + SimdType a([](int i) { return 1 << i; }); + a.copy_to(buffer, ex::element_aligned_tag()); + assert(buffer[0] == 1.); + assert(buffer[1] == 2.); + assert(buffer[2] == 4.); + assert(buffer[3] == 8.); +} + +int main() { + // TODO: adjust the tests when this assertion fails. + test_store<ex::native_simd<int32_t>>(); + test_store<ex::fixed_size_simd<int32_t, 4>>(); + test_converting_store<ex::native_simd<int32_t>>(); + test_converting_store<ex::fixed_size_simd<int32_t, 4>>(); +} diff --git a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp index 6e244220d7e2..b3cd92add537 100644 --- a/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp +++ b/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp @@ -7,24 +7,26 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.traits] -// template <class T, size_t N> struct abi_for_size { using type = see below ; }; -// template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type; +// template <class T, size_t N> struct abi_for_size { using type = see below ; +// }; template <class T, size_t N> using ex::abi_for_size_t = typename +// ex::abi_for_size<T, N>::type; #include <cstdint> #include <experimental/simd> -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; -static_assert(std::is_same<typename abi_for_size<int, 4>::type, - simd_abi::fixed_size<4>>::value, +static_assert(std::is_same<typename ex::abi_for_size<int, 4>::type, + ex::simd_abi::fixed_size<4>>::value, ""); -static_assert( - std::is_same<abi_for_size_t<int, 4>, simd_abi::fixed_size<4>>::value, ""); +static_assert(std::is_same<ex::abi_for_size_t<int, 4>, + ex::simd_abi::fixed_size<4>>::value, + ""); int main() {} diff --git a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp index 4f4f738a8351..e87eafbdb1d4 100644 --- a/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp +++ b/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp @@ -7,109 +7,107 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.traits] // template <class T> struct is_abi_tag; -// template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value; +// template <class T> inline constexpr bool ex::is_abi_tag_v = +// ex::is_abi_tag<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; struct UserType {}; -static_assert( is_abi_tag<simd_abi::native<int8_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<int16_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<int32_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<int64_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<uint8_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<uint16_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<uint32_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<uint64_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<float>>::value, ""); -static_assert( is_abi_tag<simd_abi::native<double>>::value, ""); - -static_assert( is_abi_tag<simd_abi::compatible<int8_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<int16_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<int32_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<int64_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<uint8_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<uint16_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<uint32_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<uint64_t>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<float>>::value, ""); -static_assert( is_abi_tag<simd_abi::compatible<double>>::value, ""); - -static_assert( is_abi_tag<simd_abi::scalar>::value, ""); -static_assert(!std::is_same<simd_abi::scalar, simd_abi::fixed_size<1>>::value, - ""); - -static_assert( is_abi_tag<simd_abi::fixed_size<1>>::value, ""); -static_assert( is_abi_tag<simd_abi::fixed_size<2>>::value, ""); -static_assert( is_abi_tag<simd_abi::fixed_size<3>>::value, ""); -static_assert( is_abi_tag<simd_abi::fixed_size<4>>::value, ""); -static_assert( is_abi_tag<simd_abi::fixed_size<5>>::value, ""); -static_assert( is_abi_tag<simd_abi::fixed_size<32>>::value, ""); - -static_assert(!is_abi_tag<void>::value, ""); -static_assert(!is_abi_tag<int>::value, ""); -static_assert(!is_abi_tag<float>::value, ""); -static_assert(!is_abi_tag<UserType>::value, ""); -static_assert(!is_abi_tag<simd<int>>::value, ""); -static_assert(!is_abi_tag<simd<float>>::value, ""); -static_assert(!is_abi_tag<simd_mask<int>>::value, ""); -static_assert(!is_abi_tag<simd_mask<float>>::value, ""); - -#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && \ - !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES) - -static_assert( is_abi_tag_v<simd_abi::native<int8_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<int16_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<int32_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<int64_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<uint8_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<uint16_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<uint32_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<uint64_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<float>>, ""); -static_assert( is_abi_tag_v<simd_abi::native<double>>, ""); - -static_assert( is_abi_tag_v<simd_abi::compatible<int8_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<int16_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<int32_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<int64_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<uint8_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<uint16_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<uint32_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<uint64_t>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<float>>, ""); -static_assert( is_abi_tag_v<simd_abi::compatible<double>>, ""); - -static_assert( is_abi_tag_v<simd_abi::scalar>, ""); -static_assert(!std::is_same<simd_abi::scalar, simd_abi::fixed_size<1>>::value, - ""); - -static_assert( is_abi_tag_v<simd_abi::fixed_size<1>>, ""); -static_assert( is_abi_tag_v<simd_abi::fixed_size<2>>, ""); -static_assert( is_abi_tag_v<simd_abi::fixed_size<3>>, ""); -static_assert( is_abi_tag_v<simd_abi::fixed_size<4>>, ""); -static_assert( is_abi_tag_v<simd_abi::fixed_size<5>>, ""); -static_assert( is_abi_tag_v<simd_abi::fixed_size<32>>, ""); - -static_assert(!is_abi_tag_v<void>, ""); -static_assert(!is_abi_tag_v<int>, ""); -static_assert(!is_abi_tag_v<float>, ""); -static_assert(!is_abi_tag_v<UserType>, ""); -static_assert(!is_abi_tag_v<simd<int>>, ""); -static_assert(!is_abi_tag_v<simd<float>>, ""); -static_assert(!is_abi_tag_v<simd_mask<int>>, ""); -static_assert(!is_abi_tag_v<simd_mask<float>>, ""); - -#endif +static_assert(ex::is_abi_tag<ex::simd_abi::native<int8_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<int16_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<int32_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<int64_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<uint8_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<uint16_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<uint32_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<uint64_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<float>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::native<double>>::value, ""); + +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int8_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int16_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int32_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int64_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint8_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint16_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint32_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint64_t>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<float>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::compatible<double>>::value, ""); + +static_assert(ex::is_abi_tag<ex::simd_abi::scalar>::value, ""); +static_assert( + !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value, + ""); + +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<1>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<2>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<3>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<4>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<5>>::value, ""); +static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<32>>::value, ""); + +static_assert(!ex::is_abi_tag<void>::value, ""); +static_assert(!ex::is_abi_tag<int>::value, ""); +static_assert(!ex::is_abi_tag<float>::value, ""); +static_assert(!ex::is_abi_tag<UserType>::value, ""); +static_assert(!ex::is_abi_tag<ex::simd<int>>::value, ""); +static_assert(!ex::is_abi_tag<ex::simd<float>>::value, ""); +static_assert(!ex::is_abi_tag<ex::simd_mask<int>>::value, ""); +static_assert(!ex::is_abi_tag<ex::simd_mask<float>>::value, ""); + +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int8_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int16_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int32_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int64_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint8_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint16_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint32_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint64_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<float>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::native<double>>, ""); + +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int8_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int16_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int32_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int64_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint8_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint16_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint32_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint64_t>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<float>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<double>>, ""); + +static_assert(ex::is_abi_tag_v<ex::simd_abi::scalar>, ""); +static_assert( + !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value, + ""); + +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<1>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<2>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<3>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<4>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<5>>, ""); +static_assert(ex::is_abi_tag_v<ex::simd_abi::fixed_size<32>>, ""); + +static_assert(!ex::is_abi_tag_v<void>, ""); +static_assert(!ex::is_abi_tag_v<int>, ""); +static_assert(!ex::is_abi_tag_v<float>, ""); +static_assert(!ex::is_abi_tag_v<UserType>, ""); +static_assert(!ex::is_abi_tag_v<ex::simd<int>>, ""); +static_assert(!ex::is_abi_tag_v<ex::simd<float>>, ""); +static_assert(!ex::is_abi_tag_v<ex::simd_mask<int>>, ""); +static_assert(!ex::is_abi_tag_v<ex::simd_mask<float>>, ""); int main() {} diff --git a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp index 77f5d10ed3a8..8d7c0946c730 100644 --- a/test/std/experimental/simd/simd.traits/is_simd.pass.cpp +++ b/test/std/experimental/simd/simd.traits/is_simd.pass.cpp @@ -7,127 +7,123 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.traits] -// template <class T> struct is_simd; -// template <class T> inline constexpr bool is_simd_v = is_simd<T>::value; +// template <class T> struct ex::is_simd; +// template <class T> inline constexpr bool ex::is_simd_v = +// ex::is_simd<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; struct UserType {}; -static_assert( is_simd<native_simd<int8_t>>::value, ""); -static_assert( is_simd<native_simd<int16_t>>::value, ""); -static_assert( is_simd<native_simd<int32_t>>::value, ""); -static_assert( is_simd<native_simd<int64_t>>::value, ""); -static_assert( is_simd<native_simd<uint8_t>>::value, ""); -static_assert( is_simd<native_simd<uint16_t>>::value, ""); -static_assert( is_simd<native_simd<uint32_t>>::value, ""); -static_assert( is_simd<native_simd<uint64_t>>::value, ""); -static_assert( is_simd<native_simd<float>>::value, ""); -static_assert( is_simd<native_simd<double>>::value, ""); - -static_assert( is_simd<fixed_size_simd<int8_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<int16_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<int32_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<int64_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint8_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint16_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint32_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint64_t, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<float, 1>>::value, ""); -static_assert( is_simd<fixed_size_simd<double, 1>>::value, ""); - -static_assert( is_simd<fixed_size_simd<int8_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<int16_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<int32_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<int64_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint8_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint16_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint32_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint64_t, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<float, 3>>::value, ""); -static_assert( is_simd<fixed_size_simd<double, 3>>::value, ""); - -static_assert( is_simd<fixed_size_simd<int8_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<int16_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<int32_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<int64_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint8_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint16_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint32_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<uint64_t, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<float, 32>>::value, ""); -static_assert( is_simd<fixed_size_simd<double, 32>>::value, ""); - -static_assert(!is_simd<void>::value, ""); -static_assert(!is_simd<int>::value, ""); -static_assert(!is_simd<float>::value, ""); -static_assert(!is_simd<simd_mask<int>>::value, ""); -static_assert(!is_simd<simd_mask<float>>::value, ""); -static_assert(!is_simd<UserType>::value, ""); - -#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && \ - !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES) - -static_assert( is_simd_v<native_simd<int8_t>>, ""); -static_assert( is_simd_v<native_simd<int16_t>>, ""); -static_assert( is_simd_v<native_simd<int32_t>>, ""); -static_assert( is_simd_v<native_simd<int64_t>>, ""); -static_assert( is_simd_v<native_simd<uint8_t>>, ""); -static_assert( is_simd_v<native_simd<uint16_t>>, ""); -static_assert( is_simd_v<native_simd<uint32_t>>, ""); -static_assert( is_simd_v<native_simd<uint64_t>>, ""); -static_assert( is_simd_v<native_simd<float>>, ""); -static_assert( is_simd_v<native_simd<double>>, ""); - -static_assert( is_simd_v<fixed_size_simd<int8_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<int16_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<int32_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<int64_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint8_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint16_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint32_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint64_t, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<float, 1>>, ""); -static_assert( is_simd_v<fixed_size_simd<double, 1>>, ""); - -static_assert( is_simd_v<fixed_size_simd<int8_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<int16_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<int32_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<int64_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint8_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint16_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint32_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint64_t, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<float, 3>>, ""); -static_assert( is_simd_v<fixed_size_simd<double, 3>>, ""); - -static_assert( is_simd_v<fixed_size_simd<int8_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<int16_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<int32_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<int64_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint8_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint16_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint32_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<uint64_t, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<float, 32>>, ""); -static_assert( is_simd_v<fixed_size_simd<double, 32>>, ""); - -static_assert(!is_simd_v<void>, ""); -static_assert(!is_simd_v<int>, ""); -static_assert(!is_simd_v<float>, ""); -static_assert(!is_simd_v<simd_mask<int>>, ""); -static_assert(!is_simd_v<simd_mask<float>>, ""); -static_assert(!is_simd_v<UserType>, ""); - -#endif +static_assert(ex::is_simd<ex::native_simd<int8_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<int16_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<int32_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<int64_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<uint8_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<uint16_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<uint32_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<uint64_t>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<float>>::value, ""); +static_assert(ex::is_simd<ex::native_simd<double>>::value, ""); + +static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<float, 1>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<double, 1>>::value, ""); + +static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<float, 3>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<double, 3>>::value, ""); + +static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<float, 32>>::value, ""); +static_assert(ex::is_simd<ex::fixed_size_simd<double, 32>>::value, ""); + +static_assert(!ex::is_simd<void>::value, ""); +static_assert(!ex::is_simd<int>::value, ""); +static_assert(!ex::is_simd<float>::value, ""); +static_assert(!ex::is_simd<ex::simd_mask<int>>::value, ""); +static_assert(!ex::is_simd<ex::simd_mask<float>>::value, ""); +static_assert(!ex::is_simd<UserType>::value, ""); + +static_assert(ex::is_simd_v<ex::native_simd<int8_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<int16_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<int32_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<int64_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<uint8_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<uint16_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<uint32_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<uint64_t>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<float>>, ""); +static_assert(ex::is_simd_v<ex::native_simd<double>>, ""); + +static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 1>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 1>>, ""); + +static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 3>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 3>>, ""); + +static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 32>>, ""); +static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 32>>, ""); + +static_assert(!ex::is_simd_v<void>, ""); +static_assert(!ex::is_simd_v<int>, ""); +static_assert(!ex::is_simd_v<float>, ""); +static_assert(!ex::is_simd_v<ex::simd_mask<int>>, ""); +static_assert(!ex::is_simd_v<ex::simd_mask<float>>, ""); +static_assert(!ex::is_simd_v<UserType>, ""); int main() {} diff --git a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp index a6fe409057c2..ecb68fb62844 100644 --- a/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp +++ b/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp @@ -7,49 +7,45 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.traits] // template <class T> struct is_simd_flag_type; -// template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value; +// template <class T> inline constexpr bool ex::is_simd_flag_type_v = +// ex::is_simd_flag_type<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; struct UserType {}; -static_assert( is_simd_flag_type<element_aligned_tag>::value, ""); -static_assert( is_simd_flag_type<vector_aligned_tag>::value, ""); -static_assert( is_simd_flag_type<overaligned_tag<16>>::value, ""); -static_assert( is_simd_flag_type<overaligned_tag<32>>::value, ""); - -static_assert(!is_simd_flag_type<void>::value, ""); -static_assert(!is_simd_flag_type<int>::value, ""); -static_assert(!is_simd_flag_type<float>::value, ""); -static_assert(!is_simd_flag_type<UserType>::value, ""); -static_assert(!is_simd_flag_type<simd<int8_t>>::value, ""); -static_assert(!is_simd_flag_type<simd_mask<int8_t>>::value, ""); - -#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && \ - !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES) - -static_assert( is_simd_flag_type_v<element_aligned_tag>, ""); -static_assert( is_simd_flag_type_v<vector_aligned_tag>, ""); -static_assert( is_simd_flag_type_v<overaligned_tag<16>>, ""); -static_assert( is_simd_flag_type_v<overaligned_tag<32>>, ""); - -static_assert(!is_simd_flag_type_v<void>, ""); -static_assert(!is_simd_flag_type_v<int>, ""); -static_assert(!is_simd_flag_type_v<float>, ""); -static_assert(!is_simd_flag_type_v<UserType>, ""); -static_assert(!is_simd_flag_type_v<simd<int8_t>>, ""); -static_assert(!is_simd_flag_type_v<simd_mask<int8_t>>, ""); - -#endif +static_assert(ex::is_simd_flag_type<ex::element_aligned_tag>::value, ""); +static_assert(ex::is_simd_flag_type<ex::vector_aligned_tag>::value, ""); +static_assert(ex::is_simd_flag_type<ex::overaligned_tag<16>>::value, ""); +static_assert(ex::is_simd_flag_type<ex::overaligned_tag<32>>::value, ""); + +static_assert(!ex::is_simd_flag_type<void>::value, ""); +static_assert(!ex::is_simd_flag_type<int>::value, ""); +static_assert(!ex::is_simd_flag_type<float>::value, ""); +static_assert(!ex::is_simd_flag_type<UserType>::value, ""); +static_assert(!ex::is_simd_flag_type<ex::simd<int8_t>>::value, ""); +static_assert(!ex::is_simd_flag_type<ex::simd_mask<int8_t>>::value, ""); + +static_assert(ex::is_simd_flag_type_v<ex::element_aligned_tag>, ""); +static_assert(ex::is_simd_flag_type_v<ex::vector_aligned_tag>, ""); +static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<16>>, ""); +static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<32>>, ""); + +static_assert(!ex::is_simd_flag_type_v<void>, ""); +static_assert(!ex::is_simd_flag_type_v<int>, ""); +static_assert(!ex::is_simd_flag_type_v<float>, ""); +static_assert(!ex::is_simd_flag_type_v<UserType>, ""); +static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, ""); +static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, ""); int main() {} diff --git a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp index 8c2e0ed5bf43..736802443012 100644 --- a/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp +++ b/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp @@ -7,127 +7,146 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03 +// UNSUPPORTED: c++98, c++03, c++11, c++14 // <experimental/simd> // // [simd.traits] -// template <class T> struct is_simd_mask; -// template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value; +// template <class T> struct ex::is_simd_mask; +// template <class T> inline constexpr bool ex::is_simd_mask_v = +// ex::is_simd_mask<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -using namespace std::experimental::parallelism_v2; +namespace ex = std::experimental::parallelism_v2; struct UserType {}; -static_assert( is_simd_mask<native_simd_mask<int8_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<int16_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<int32_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<int64_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<uint8_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<uint16_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<uint32_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<uint64_t>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<float>>::value, ""); -static_assert( is_simd_mask<native_simd_mask<double>>::value, ""); - -static_assert( is_simd_mask<fixed_size_simd_mask<int8_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int16_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int32_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int64_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint8_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint16_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint32_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint64_t, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<float, 1>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<double, 1>>::value, ""); - -static_assert( is_simd_mask<fixed_size_simd_mask<int8_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int16_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int32_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int64_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint8_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint16_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint32_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint64_t, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<float, 3>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<double, 3>>::value, ""); - -static_assert( is_simd_mask<fixed_size_simd_mask<int8_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int16_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int32_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<int64_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint8_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint16_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint32_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<uint64_t, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<float, 32>>::value, ""); -static_assert( is_simd_mask<fixed_size_simd_mask<double, 32>>::value, ""); - -static_assert(!is_simd_mask<void>::value, ""); -static_assert(!is_simd_mask<int>::value, ""); -static_assert(!is_simd_mask<float>::value, ""); -static_assert(!is_simd_mask<simd<int>>::value, ""); -static_assert(!is_simd_mask<simd<float>>::value, ""); -static_assert(!is_simd_mask<UserType>::value, ""); - -#if TEST_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && \ - !defined(_LIBCPP_HAS_NO_INLINE_VARIABLES) - -static_assert( is_simd_mask_v<native_simd_mask<int8_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<int16_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<int32_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<int64_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<uint8_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<uint16_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<uint32_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<uint64_t>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<float>>, ""); -static_assert( is_simd_mask_v<native_simd_mask<double>>, ""); - -static_assert( is_simd_mask_v<fixed_size_simd_mask<int8_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int16_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int32_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int64_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint8_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint16_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint32_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint64_t, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<float, 1>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<double, 1>>, ""); - -static_assert( is_simd_mask_v<fixed_size_simd_mask<int8_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int16_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int32_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int64_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint8_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint16_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint32_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint64_t, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<float, 3>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<double, 3>>, ""); - -static_assert( is_simd_mask_v<fixed_size_simd_mask<int8_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int16_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int32_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<int64_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint8_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint16_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint32_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<uint64_t, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<float, 32>>, ""); -static_assert( is_simd_mask_v<fixed_size_simd_mask<double, 32>>, ""); - -static_assert(!is_simd_mask_v<void>, ""); -static_assert(!is_simd_mask_v<int>, ""); -static_assert(!is_simd_mask_v<float>, ""); -static_assert(!is_simd_mask_v<simd<int>>, ""); -static_assert(!is_simd_mask_v<simd<float>>, ""); -static_assert(!is_simd_mask_v<UserType>, ""); - -#endif +static_assert(ex::is_simd_mask<ex::native_simd_mask<int8_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<int16_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<int32_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<int64_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<uint8_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<uint16_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<uint32_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<uint64_t>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<float>>::value, ""); +static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, ""); + +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 1>>::value, ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 1>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 1>>::value, ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 1>>::value, ""); + +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 3>>::value, ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 3>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 3>>::value, ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 3>>::value, ""); + +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 32>>::value, + ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 32>>::value, ""); +static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 32>>::value, + ""); + +static_assert(!ex::is_simd_mask<void>::value, ""); +static_assert(!ex::is_simd_mask<int>::value, ""); +static_assert(!ex::is_simd_mask<float>::value, ""); +static_assert(!ex::is_simd_mask<ex::simd<int>>::value, ""); +static_assert(!ex::is_simd_mask<ex::simd<float>>::value, ""); +static_assert(!ex::is_simd_mask<UserType>::value, ""); + +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int8_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int16_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int32_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int64_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint8_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint16_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint32_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint64_t>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<float>>, ""); +static_assert(ex::is_simd_mask_v<ex::native_simd_mask<double>>, ""); + +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 1>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 1>>, ""); + +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 3>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 3>>, ""); + +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 32>>, ""); +static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 32>>, ""); + +static_assert(!ex::is_simd_mask_v<void>, ""); +static_assert(!ex::is_simd_mask_v<int>, ""); +static_assert(!ex::is_simd_mask_v<float>, ""); +static_assert(!ex::is_simd_mask_v<ex::simd<int>>, ""); +static_assert(!ex::is_simd_mask_v<ex::simd<float>>, ""); +static_assert(!ex::is_simd_mask_v<UserType>, ""); int main() {} |