diff options
Diffstat (limited to 'libcxx/test/std')
15 files changed, 397 insertions, 1137 deletions
diff --git a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp deleted file mode 100644 index dd843661811..00000000000 --- a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp +++ /dev/null @@ -1,67 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp deleted file mode 100644 index 697035b66f2..00000000000 --- a/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp +++ /dev/null @@ -1,217 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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] >>= 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])); - } - } - { - 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/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp index d15f138d5b9..af6b13fe878 100644 --- a/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp @@ -7,40 +7,34 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.casts] -// template <class T, class U, class Abi> see below ex::simd_cast<(const -// ex::simd<U, Abi>&); - +// template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&); #include <experimental/simd> #include <cstdint> -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; -static_assert( - 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(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<int32_t>(native_simd<int32_t>())), + native_simd<int32_t>>::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, + std::is_same<decltype(simd_cast<int64_t>(fixed_size_simd<int32_t, 4>())), + fixed_size_simd<int64_t, 4>>::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, - ""); +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(simd_cast<simd<int64_t, simd_abi::scalar>>( + fixed_size_simd<int32_t, 1>())), + simd<int64_t, simd_abi::scalar>>::value, + ""); int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp b/libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp index b734664770e..eb1fa55e0a4 100644 --- a/libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.casts/static_simd_cast.pass.cpp @@ -7,35 +7,32 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.casts] -// template <class T, class U, class Abi> see below ex::static_simd_cast<(const -// ex::simd<U, Abi>&); +// template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&); #include <experimental/simd> #include <cstdint> -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; static_assert( - std::is_same<decltype(ex::static_simd_cast<float>(ex::native_simd<int>())), - ex::native_simd<float>>::value, + std::is_same<decltype(static_simd_cast<float>(native_simd<int>())), + native_simd<float>>::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<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::simd<float, ex::simd_abi::scalar>>( - ex::fixed_size_simd<int, 1>())), - ex::simd<float, ex::simd_abi::scalar>>::value, + std::is_same<decltype(static_simd_cast<simd<float, simd_abi::scalar>>( + fixed_size_simd<int, 1>())), + simd<float, simd_abi::scalar>>::value, ""); int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp index 49b2b557284..60230cc6373 100644 --- a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // See GCC PR63723. // UNSUPPORTED: gcc-4.9 @@ -20,19 +20,18 @@ #include <cstdint> #include <experimental/simd> -namespace ex = std::experimental::parallelism_v2; +using namespace 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; + -> decltype(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()) {} + -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) {} template <class T> void supported_native_simd_ctor(...) = delete; @@ -56,31 +55,4 @@ void compile_narrowing_conversion() { not_supported_native_simd_ctor<int>(3.); } -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>>(); -} +int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp deleted file mode 100644 index 0f12eced0aa..00000000000 --- a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp index 43273e896b4..baf7d936c6a 100644 --- a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // See GCC PR63723. // UNSUPPORTED: gcc-4.9 @@ -17,75 +17,30 @@ // [simd.class] // template <class G> explicit simd(G&& gen); -#include <experimental/simd> #include <cstdint> +#include <experimental/simd> -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; template <class T, class... Args> -auto not_supported_simd128_ctor(Args&&... args) -> decltype( - ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...), - void()) = delete; +auto not_supported_native_simd_ctor(Args&&... args) + -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) = delete; template <class T> -void not_supported_simd128_ctor(...) {} +void not_supported_native_simd_ctor(...) {} template <class T, class... Args> -auto supported_simd128_ctor(Args&&... args) -> decltype( - ex::fixed_size_simd<T, 16 / sizeof(T)>(std::forward<Args>(args)...), - void()) {} +auto supported_native_simd_ctor(Args&&... args) + -> decltype(native_simd<T>(std::forward<Args>(args)...), void()) {} template <class T> -void supported_simd128_ctor(...) = delete; - -struct identity { - template <size_t value> - int operator()(std::integral_constant<size_t, value>) const { - return value; - } -}; +void supported_native_simd_ctor(...) = delete; void compile_generator() { - 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; }); + 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; }); } -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>>(); -} +int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp deleted file mode 100644 index 8c87fe7a555..00000000000 --- a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp +++ /dev/null @@ -1,118 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp deleted file mode 100644 index b1a3a2b1d3b..00000000000 --- a/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp +++ /dev/null @@ -1,122 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp deleted file mode 100644 index 2025a79f21a..00000000000 --- a/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp +++ /dev/null @@ -1,95 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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/libcxx/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp index b3cd92add53..6e244220d7e 100644 --- a/libcxx/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.traits/abi_for_size.pass.cpp @@ -7,26 +7,24 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <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 ex::abi_for_size_t = typename -// ex::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 abi_for_size_t = typename abi_for_size<T, N>::type; #include <cstdint> #include <experimental/simd> -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; -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<typename abi_for_size<int, 4>::type, + 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, - ""); +static_assert( + std::is_same<abi_for_size_t<int, 4>, simd_abi::fixed_size<4>>::value, ""); int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp index e87eafbdb1d..4f4f738a835 100644 --- a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp @@ -7,107 +7,109 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.traits] // template <class T> struct is_abi_tag; -// template <class T> inline constexpr bool ex::is_abi_tag_v = -// ex::is_abi_tag<T>::value; +// template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; struct UserType {}; -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>>, ""); +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 int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp index 8d7c0946c73..77f5d10ed3a 100644 --- a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp @@ -7,123 +7,127 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.traits] -// template <class T> struct ex::is_simd; -// template <class T> inline constexpr bool ex::is_simd_v = -// ex::is_simd<T>::value; +// template <class T> struct is_simd; +// template <class T> inline constexpr bool is_simd_v = is_simd<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; struct UserType {}; -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>, ""); +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 int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp index ecb68fb6284..a6fe409057c 100644 --- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp @@ -7,45 +7,49 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.traits] // template <class T> struct is_simd_flag_type; -// template <class T> inline constexpr bool ex::is_simd_flag_type_v = -// ex::is_simd_flag_type<T>::value; +// template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; struct UserType {}; -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>>, ""); +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 int main() {} diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp index 73680244301..8c2e0ed5bf4 100644 --- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp +++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp @@ -7,146 +7,127 @@ // //===----------------------------------------------------------------------===// -// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: c++98, c++03 // <experimental/simd> // // [simd.traits] -// 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; +// template <class T> struct is_simd_mask; +// template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value; #include <cstdint> #include <experimental/simd> #include "test_macros.h" -namespace ex = std::experimental::parallelism_v2; +using namespace std::experimental::parallelism_v2; struct UserType {}; -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>, ""); +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 int main() {} |
