[libc++] <experimental/simd> Add binary operators for class simd #118744
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
the
libc++
Member
|
@llvm/pr-subscribers-libcxx Author: ZhangYin (joy2myself) ChangesFull diff: https://github.com/llvm/llvm-project/pull/118744.diff 4 Files Affected:
diff --git a/libcxx/include/experimental/__simd/scalar.h b/libcxx/include/experimental/__simd/scalar.h
index da318d2f4650fd..a65f55b59dddeb 100644
--- a/libcxx/include/experimental/__simd/scalar.h
+++ b/libcxx/include/experimental/__simd/scalar.h
@@ -82,6 +82,54 @@ struct __simd_operations<_Tp, simd_abi::__scalar> {
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __unary_minus(_SimdStorage __s) noexcept {
return {static_cast<_Tp>(-__s.__data)};
}
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __plus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data + __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __minus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data - __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __multiplies(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data * __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __divides(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data / __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __modulus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data % __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_and(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data & __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_or(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data | __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_xor(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data ^ __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_left(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data << __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_right(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data >> __rhs.__data)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_left(_SimdStorage __lhs, int __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data << __rhs)};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_right(_SimdStorage __lhs, int __rhs) noexcept {
+ return {static_cast<_Tp>(__lhs.__data >> __rhs)};
+ }
};
template <class _Tp>
diff --git a/libcxx/include/experimental/__simd/simd.h b/libcxx/include/experimental/__simd/simd.h
index fd919e75e32f51..80dd91bd299a47 100644
--- a/libcxx/include/experimental/__simd/simd.h
+++ b/libcxx/include/experimental/__simd/simd.h
@@ -37,6 +37,39 @@ class __simd_int_operators<_Simd, _Impl, true> {
_LIBCPP_HIDE_FROM_ABI _Simd operator~() const noexcept {
return _Simd(_Impl::__bitwise_not((*static_cast<const _Simd*>(this)).__s_), _Simd::__storage_tag);
}
+
+ // binary operators for integral _Tp
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator%(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__modulus(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator&(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__bitwise_and(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator|(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__bitwise_or(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator^(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__bitwise_xor(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator<<(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__shift_left(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator>>(const _Simd& __lhs, const _Simd& __rhs) noexcept {
+ return _Simd(_Impl::__shift_right(__lhs.__s_, __rhs.__s_), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator<<(const _Simd& __lhs, int __rhs) noexcept {
+ return _Simd(_Impl::__shift_left(__lhs.__s_, __rhs), _Simd::__storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI _Simd operator>>(const _Simd& __lhs, int __rhs) noexcept {
+ return _Simd(_Impl::__shift_right(__lhs.__s_, __rhs), _Simd::__storage_tag);
+ }
};
// class template simd [simd.class]
@@ -137,6 +170,23 @@ class simd : public __simd_int_operators<simd<_Tp, _Abi>, __simd_operations<_Tp,
_LIBCPP_HIDE_FROM_ABI simd operator+() const noexcept { return *this; }
_LIBCPP_HIDE_FROM_ABI simd operator-() const noexcept { return simd(_Impl::__unary_minus(__s_), __storage_tag); }
+
+ // binary operators
+ friend _LIBCPP_HIDE_FROM_ABI simd operator+(const simd& __lhs, const simd& __rhs) noexcept {
+ return simd(_Impl::__plus(__lhs.__s_, __rhs.__s_), __storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI simd operator-(const simd& __lhs, const simd& __rhs) noexcept {
+ return simd(_Impl::__minus(__lhs.__s_, __rhs.__s_), __storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI simd operator*(const simd& __lhs, const simd& __rhs) noexcept {
+ return simd(_Impl::__multiplies(__lhs.__s_, __rhs.__s_), __storage_tag);
+ }
+
+ friend _LIBCPP_HIDE_FROM_ABI simd operator/(const simd& __lhs, const simd& __rhs) noexcept {
+ return simd(_Impl::__divides(__lhs.__s_, __rhs.__s_), __storage_tag);
+ }
};
template <class _Tp, class _Abi>
diff --git a/libcxx/include/experimental/__simd/vec_ext.h b/libcxx/include/experimental/__simd/vec_ext.h
index abc7e9595be9c8..df46113b678212 100644
--- a/libcxx/include/experimental/__simd/vec_ext.h
+++ b/libcxx/include/experimental/__simd/vec_ext.h
@@ -39,6 +39,8 @@ template <class _Tp, int _Np>
struct __simd_storage<_Tp, simd_abi::__vec_ext<_Np>> {
_Tp __data __attribute__((__vector_size__(std::__bit_ceil((sizeof(_Tp) * _Np)))));
+ static constexpr bool __is_partial_v = (_Np < (sizeof(__data) / sizeof(_Tp)));
+
_LIBCPP_HIDE_FROM_ABI _Tp __get(size_t __idx) const noexcept {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < _Np, "Index is out of bounds");
return __data[__idx];
@@ -47,6 +49,17 @@ struct __simd_storage<_Tp, simd_abi::__vec_ext<_Np>> {
_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < _Np, "Index is out of bounds");
__data[__idx] = __v;
}
+
+ _LIBCPP_HIDE_FROM_ABI __simd_storage __make_padding_nonzero() const noexcept {
+ __simd_storage __result = *this;
+ if constexpr (__is_partial_v) {
+ constexpr size_t __full_size = sizeof(__data) / sizeof(_Tp);
+ for (size_t __i = _Np; __i < __full_size; ++__i) {
+ __result.__data[__i] = _Tp(1);
+ }
+ }
+ return __result;
+ }
};
template <class _Tp, int _Np>
@@ -97,6 +110,60 @@ struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_not(_SimdStorage __s) noexcept { return {~__s.__data}; }
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __unary_minus(_SimdStorage __s) noexcept { return {-__s.__data}; }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __plus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data + __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __minus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data - __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __multiplies(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data * __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __divides(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ if constexpr (!_SimdStorage::__is_partial_v)
+ return {__lhs.__data / __rhs.__data};
+ else
+ return {__lhs.__data / __rhs.__make_padding_nonzero().__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __modulus(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ if constexpr (!_SimdStorage::__is_partial_v)
+ return {__lhs.__data % __rhs.__data};
+ else
+ return {__lhs.__data % __rhs.__make_padding_nonzero().__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_and(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data & __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_or(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data | __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_xor(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data ^ __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_left(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data << __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_right(_SimdStorage __lhs, _SimdStorage __rhs) noexcept {
+ return {__lhs.__data >> __rhs.__data};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_left(_SimdStorage __lhs, int __rhs) noexcept {
+ return {__lhs.__data << __rhs};
+ }
+
+ static _LIBCPP_HIDE_FROM_ABI _SimdStorage __shift_right(_SimdStorage __lhs, int __rhs) noexcept {
+ return {__lhs.__data >> __rhs};
+ }
};
template <class _Tp, int _Np>
diff --git a/libcxx/test/std/experimental/simd/simd.nonmembers/simd_binary.pass.cpp b/libcxx/test/std/experimental/simd/simd.nonmembers/simd_binary.pass.cpp
new file mode 100644
index 00000000000000..faad7faf0930e4
--- /dev/null
+++ b/libcxx/test/std/experimental/simd/simd.nonmembers/simd_binary.pass.cpp
@@ -0,0 +1,226 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// <experimental/simd>
+//
+// [simd.nonmembers]
+// friend simd operator+(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator-(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator*(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator/(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator%(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator&(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator|(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator^(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator<<(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator>>(const simd& lhs, const simd& rhs) noexcept;
+// friend simd operator<<(const simd& v, int n) noexcept;
+// friend simd operator>>(const simd& v, int n) noexcept;
+
+#include "../test_utils.h"
+#include <experimental/simd>
+
+namespace ex = std::experimental::parallelism_v2;
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorPlus {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd + right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) + static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd + right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorMinus {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd - right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) - static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd - right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorMultiplies {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd * right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) * static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd * right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorDivides {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd / right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) / static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd / right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorModulus {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd % right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) % static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd % right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorBitAnd {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd & right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) & static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd & right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorBitOr {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd | right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) | static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd | right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorBitXor {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd ^ right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) ^ static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd ^ right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorShiftLeft {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd << right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) << static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd << right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorShiftRight {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> left_simd([](T i) { return i; });
+ ex::simd<T, SimdAbi> right_simd(static_cast<T>(2));
+ static_assert(noexcept(left_simd >> right_simd));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) >> static_cast<T>(2);
+ assert_simd_values_equal<array_size>(left_simd >> right_simd, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorShiftLeftByInt {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> simd_value([](T i) { return i; });
+ constexpr int shift_amount = 2;
+ static_assert(noexcept(simd_value << shift_amount));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) << shift_amount;
+ assert_simd_values_equal<array_size>(simd_value << shift_amount, expected_value);
+ }
+};
+
+template <class T, std::size_t>
+struct CheckSimdBinaryOperatorShiftRightByInt {
+ template <class SimdAbi>
+ void operator()() {
+ constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
+ ex::simd<T, SimdAbi> simd_value([](T i) { return i; });
+ constexpr int shift_amount = 2;
+ static_assert(noexcept(simd_value >> shift_amount));
+ std::array<T, array_size> expected_value;
+ for (size_t i = 0; i < array_size; ++i)
+ expected_value[i] = static_cast<T>(i) >> shift_amount;
+ assert_simd_values_equal<array_size>(simd_value >> shift_amount, expected_value);
+ }
+};
+
+int main(int, char**) {
+ test_all_simd_abi<CheckSimdBinaryOperatorPlus>();
+ test_all_simd_abi<CheckSimdBinaryOperatorMinus>();
+ test_all_simd_abi<CheckSimdBinaryOperatorMultiplies>();
+ test_all_simd_abi<CheckSimdBinaryOperatorDivides>();
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorModulus>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorBitAnd>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorBitOr>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorBitXor>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorShiftLeft>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorShiftRight>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorShiftLeftByInt>());
+ types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBinaryOperatorShiftRightByInt>());
+ return 0;
+}
|
joy2myself
force-pushed
the
simd_binary
branch
from
8765420 to
2099ce8
Compare
Member
Author
|
@philnik777 ping. |
Contributor
|
We've decided to implement |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.