WIP

Author: serge-sans-paille

include/xsimd/arch/xsimd_altivec.hpp

@@ -790,121 +790,112 @@ namespace xsimd
         {
             return select(batch_bool<T, A> { Values... }, true_br, false_br, altivec {});
         }
-#if 0
 
         // shuffle
         template <class A, class ITy, ITy I0, ITy I1, ITy I2, ITy I3>
         XSIMD_INLINE batch<float, A> shuffle(batch<float, A> const& x, batch<float, A> const& y, batch_constant<ITy, A, I0, I1, I2, I3> mask, requires_arch<altivec>) noexcept
         {
-            constexpr uint32_t smask = detail::mod_shuffle(I0, I1, I2, I3);
-            // shuffle within lane
-            if (I0 < 4 && I1 < 4 && I2 >= 4 && I3 >= 4)
-                return _mm_shuffle_ps(x, y, smask);
-
-            // shuffle within opposite lane
-            if (I0 >= 4 && I1 >= 4 && I2 < 4 && I3 < 4)
-                return _mm_shuffle_ps(y, x, smask);
-            return shuffle(x, y, mask, common {});
+            return vec_perm(x, y,
+                            (__vector unsigned char) {
+                                4 * I0 + 0, 4 * I0 + 1, 4 * I0 + 2, 4 * I0 + 3,
+                                4 * I1 + 0, 4 * I1 + 1, 4 * I1 + 2, 4 * I1 + 3,
+                                4 * I2 + 0, 4 * I2 + 1, 4 * I2 + 2, 4 * I2 + 3,
+                                4 * I3 + 0, 4 * I3 + 1, 4 * I3 + 2, 4 * I3 + 3 });
         }
 
         template <class A, class ITy, ITy I0, ITy I1>
         XSIMD_INLINE batch<double, A> shuffle(batch<double, A> const& x, batch<double, A> const& y, batch_constant<ITy, A, I0, I1> mask, requires_arch<altivec>) noexcept
         {
-            constexpr uint32_t smask = detail::mod_shuffle(I0, I1);
-            // shuffle within lane
-            if (I0 < 2 && I1 >= 2)
-                return _mm_shuffle_pd(x, y, smask);
-
-            // shuffle within opposite lane
-            if (I0 >= 2 && I1 < 2)
-                return _mm_shuffle_pd(y, x, smask);
-            return shuffle(x, y, mask, common {});
+            return vec_perm(x, y,
+                (__vector unsigned char) {
+                8 * I0 + 0, 8 * I0 + 1, 8 * I0 + 2, 8 * I0 + 3, 8 * I0 + 4, 8 * I0 + 5, 8 * I0 + 6, 8 * I0 + 7,
+                8 * I1 + 0, 8 * I1 + 1, 8 * I1 + 2, 8 * I1 + 3, 8 * I1 + 4, 8 * I1 + 5, 8 * I1 + 6, 8 * I1 + 7,
+                );
         }
-#endif
 
         // sqrt
         template <class A>
         XSIMD_INLINE batch<float, A> sqrt(batch<float, A> const& val, requires_arch<altivec>) noexcept
         {
-            return vec_sqrt(val.data);
+                return vec_sqrt(val.data);
         }
 
         template <class A>
         XSIMD_INLINE batch<double, A> sqrt(batch<double, A> const& val, requires_arch<altivec>) noexcept
         {
-            return vec_sqrt(val.data);
+                return vec_sqrt(val.data);
         }
 
         // slide_left
         template <size_t N, class A, class T>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& x, requires_arch<altivec>) noexcept
         {
-            return (typename batch<T, A>::register_type)vec_sll((__vector unsigned char)x.data, vec_splats((uint32_t)N));
+                return (typename batch<T, A>::register_type)vec_sll((__vector unsigned char)x.data, vec_splats((uint32_t)N));
         }
 
         // slide_right
         template <size_t N, class A, class T>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& x, requires_arch<altivec>) noexcept
         {
-            return (typename batch<T, A>::register_type)vec_srl((__vector unsigned char)x.data, vec_splats((uint32_t)N));
+                return (typename batch<T, A>::register_type)vec_srl((__vector unsigned char)x.data, vec_splats((uint32_t)N));
         }
 
         // sadd
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value && sizeof(T) != 8, void>::type>
         XSIMD_INLINE batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<altivec>) noexcept
         {
-            return vec_adds(self.data, other.data);
+                return vec_adds(self.data, other.data);
         }
 
         // set
         template <class A, class T, class... Values>
         XSIMD_INLINE batch<T, A> set(batch<T, A> const&, requires_arch<altivec>, Values... values) noexcept
         {
-            static_assert(sizeof...(Values) == batch<T, A>::size, "consistent init");
-            return typename batch<T, A>::register_type { values... };
+                static_assert(sizeof...(Values) == batch<T, A>::size, "consistent init");
+                return typename batch<T, A>::register_type { values... };
         }
 
         template <class A, class T, class... Values, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE batch_bool<T, A> set(batch_bool<T, A> const&, requires_arch<altivec>, Values... values) noexcept
         {
-            static_assert(sizeof...(Values) == batch_bool<T, A>::size, "consistent init");
-            return typename batch_bool<T, A>::register_type { static_cast<decltype(std::declval<typename batch_bool<T, A>::register_type>()[0])>(values ? -1LL : 0LL)... };
+                static_assert(sizeof...(Values) == batch_bool<T, A>::size, "consistent init");
+                return typename batch_bool<T, A>::register_type { static_cast<decltype(std::declval<typename batch_bool<T, A>::register_type>()[0])>(values ? -1LL : 0LL)... };
         }
 
         // ssub
 
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value && sizeof(T) == 1, void>::type>
         XSIMD_INLINE batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<altivec>) noexcept
         {
-            return vec_subs(self.data, other.data);
+                return vec_subs(self.data, other.data);
         }
 
         // store_aligned
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE void store_aligned(T* mem, batch<T, A> const& self, requires_arch<altivec>) noexcept
         {
-            return vec_st(self.data, 0, reinterpret_cast<typename batch<T, A>::register_type*>(mem));
+                return vec_st(self.data, 0, reinterpret_cast<typename batch<T, A>::register_type*>(mem));
         }
 
         // store_unaligned
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE void store_unaligned(T* mem, batch<T, A> const& self, requires_arch<altivec>) noexcept
         {
-            auto tmp = vec_perm(*reinterpret_cast<const __vector unsigned char*>(&self.data), *reinterpret_cast<const __vector unsigned char*>(&self.data), vec_lvsr(0, (unsigned char*)mem));
-            vec_ste((__vector unsigned char)tmp, 0, (unsigned char*)mem);
-            vec_ste((__vector unsigned short)tmp, 1, (unsigned short*)mem);
-            vec_ste((__vector unsigned int)tmp, 3, (unsigned int*)mem);
-            vec_ste((__vector unsigned int)tmp, 4, (unsigned int*)mem);
-            vec_ste((__vector unsigned int)tmp, 8, (unsigned int*)mem);
-            vec_ste((__vector unsigned int)tmp, 12, (unsigned int*)mem);
-            vec_ste((__vector unsigned short)tmp, 14, (unsigned short*)mem);
+                auto tmp = vec_perm(*reinterpret_cast<const __vector unsigned char*>(&self.data), *reinterpret_cast<const __vector unsigned char*>(&self.data), vec_lvsr(0, (unsigned char*)mem));
+                vec_ste((__vector unsigned char)tmp, 0, (unsigned char*)mem);
+                vec_ste((__vector unsigned short)tmp, 1, (unsigned short*)mem);
+                vec_ste((__vector unsigned int)tmp, 3, (unsigned int*)mem);
+                vec_ste((__vector unsigned int)tmp, 4, (unsigned int*)mem);
+                vec_ste((__vector unsigned int)tmp, 8, (unsigned int*)mem);
+                vec_ste((__vector unsigned int)tmp, 12, (unsigned int*)mem);
+                vec_ste((__vector unsigned short)tmp, 14, (unsigned short*)mem);
         }
 
         // sub
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<altivec>) noexcept
         {
-            return vec_sub(self.data, other.data);
+                return vec_sub(self.data, other.data);
         }
 
 #if 0
@@ -1024,16 +1015,16 @@ namespace xsimd
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& self, batch<T, A> const& other, requires_arch<altivec>) noexcept
         {
-            return vec_mergeh(self.data, other.data);
+                return vec_mergeh(self.data, other.data);
         }
 
         // zip_lo
         template <class A, class T, class = typename std::enable_if<std::is_scalar<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& self, batch<T, A> const& other, requires_arch<altivec>) noexcept
         {
-            return vec_mergel(self.data, other.data);
+                return vec_mergel(self.data, other.data);
+        }
         }
     }
-}
 
 #endif