Re-commit r330627 "[libcxx] implement <experimental/simd> declarations based on P0214R7."
There are 3 changes: * Renamed genertor.pass.cpp to generator.pass.cpp * Removed nothing_to_do.pass.cpp * Mark GCC 4.9 as UNSUPPORTED for the test files that have negative narrowing conversion SFINAE test (see GCC PR63723). llvm-svn: 330655
This commit is contained in:
Tim Shen
parent
42da9cb091
commit
403c667b4b
|
|
@ -54,4 +54,16 @@
|
|||
|
||||
#define _VSTD_FS ::std::experimental::filesystem::v1
|
||||
|
||||
#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
|
||||
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
|
||||
|
||||
#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
|
||||
} _LIBCPP_END_NAMESPACE_EXPERIMENTAL
|
||||
|
||||
#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
|
||||
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {
|
||||
|
||||
#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
|
||||
} _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
|
||||
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -550,6 +550,10 @@ module std [system] {
|
|||
header "experimental/regex"
|
||||
export *
|
||||
}
|
||||
module simd {
|
||||
header "experimental/simd"
|
||||
export *
|
||||
}
|
||||
module set {
|
||||
header "experimental/set"
|
||||
export *
|
||||
|
|
|
|||
|
|
@ -151,6 +151,7 @@
|
|||
#include <experimental/memory_resource>
|
||||
#include <experimental/propagate_const>
|
||||
#include <experimental/regex>
|
||||
#include <experimental/simd>
|
||||
#include <experimental/set>
|
||||
#include <experimental/string>
|
||||
#include <experimental/type_traits>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <experimental/simd>
|
||||
//
|
||||
// [simd.casts]
|
||||
// template <class T, class U, class Abi> see below simd_cast(const 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,
|
||||
"");
|
||||
|
||||
static_assert(
|
||||
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(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() {}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <experimental/simd>
|
||||
//
|
||||
// [simd.casts]
|
||||
// template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);
|
||||
|
||||
#include <experimental/simd>
|
||||
#include <cstdint>
|
||||
|
||||
using namespace std::experimental::parallelism_v2;
|
||||
|
||||
static_assert(
|
||||
std::is_same<decltype(static_simd_cast<float>(native_simd<int>())),
|
||||
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(static_simd_cast<simd<float, simd_abi::scalar>>(
|
||||
fixed_size_simd<int, 1>())),
|
||||
simd<float, simd_abi::scalar>>::value,
|
||||
"");
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// See GCC PR63723.
|
||||
// UNSUPPORTED: gcc-4.9
|
||||
|
||||
// <experimental/simd>
|
||||
//
|
||||
// [simd.class]
|
||||
// template <class U> simd(U&& value);
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
|
||||
using namespace 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;
|
||||
|
||||
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()) {}
|
||||
|
||||
template <class T>
|
||||
void supported_native_simd_ctor(...) = delete;
|
||||
|
||||
void compile_narrowing_conversion() {
|
||||
supported_native_simd_ctor<int8_t>(3);
|
||||
supported_native_simd_ctor<int16_t>(3);
|
||||
supported_native_simd_ctor<int32_t>(3);
|
||||
supported_native_simd_ctor<int64_t>(3);
|
||||
supported_native_simd_ctor<uint8_t>(3);
|
||||
supported_native_simd_ctor<uint16_t>(3);
|
||||
supported_native_simd_ctor<uint32_t>(3);
|
||||
supported_native_simd_ctor<uint64_t>(3);
|
||||
supported_native_simd_ctor<float>(3.f);
|
||||
supported_native_simd_ctor<double>(3.);
|
||||
supported_native_simd_ctor<long double>(3.);
|
||||
|
||||
not_supported_native_simd_ctor<float>(3.);
|
||||
not_supported_native_simd_ctor<int8_t>(long(3));
|
||||
not_supported_native_simd_ctor<float>(long(3));
|
||||
not_supported_native_simd_ctor<int>(3.);
|
||||
}
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// See GCC PR63723.
|
||||
// UNSUPPORTED: gcc-4.9
|
||||
|
||||
// <experimental/simd>
|
||||
//
|
||||
// [simd.class]
|
||||
// template <class G> explicit simd(G&& gen);
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
|
||||
using namespace 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;
|
||||
|
||||
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()) {}
|
||||
|
||||
template <class T>
|
||||
void supported_native_simd_ctor(...) = delete;
|
||||
|
||||
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; });
|
||||
}
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <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;
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
|
||||
using namespace 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<abi_for_size_t<int, 4>, simd_abi::fixed_size<4>>::value, "");
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,115 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <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;
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
#include "test_macros.h"
|
||||
|
||||
using namespace 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
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <experimental/simd>
|
||||
//
|
||||
// [simd.traits]
|
||||
// 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"
|
||||
|
||||
using namespace 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
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <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;
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
#include "test_macros.h"
|
||||
|
||||
using namespace 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
|
||||
|
||||
int main() {}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// <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;
|
||||
|
||||
#include <cstdint>
|
||||
#include <experimental/simd>
|
||||
#include "test_macros.h"
|
||||
|
||||
using namespace 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
|
||||
|
||||
int main() {}
|
||||
Loading…
Reference in New Issue