Add fallback implementation for Arm32/v7

Yuqi Gu · Yuqi Gu · commit 3a9d2d20e946 · 2021-03-31T02:02:58.000Z
Change-Id: I3940e8b579f320288dbf640f0536da017298b00c
Signed-off-by: Yuqi Gu &lt;guyuqi@apache.com&gt;
diff --git a/include/xsimd/types/xsimd_neon_double.hpp b/include/xsimd/types/xsimd_neon_double.hpp
@@ -580,17 +580,23 @@ namespace xsimd
                 return vbslq_f64(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_f64(lhs, rhs);
+#else
+                return vcombine_f64(vget_low_f64(lhs), vget_low_f64(rhs));
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_f64(lhs, rhs);
-            }
+#else
+                return vcombine_f64(vget_high_f64(lhs), vget_high_f64(rhs));
 #endif
+            }
 
             static batch_bool_type isnan(const batch_type& x)
             {
diff --git a/include/xsimd/types/xsimd_neon_float.hpp b/include/xsimd/types/xsimd_neon_float.hpp
@@ -639,17 +639,25 @@ namespace xsimd
                 return vbslq_f32(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_f32(lhs, rhs);
+#else
+                float32x2x2_t tmp = vzip_f32(vget_low_f32(lhs), vget_low_f32(rhs));
+                return vcombine_f32(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_f32(lhs, rhs);
-            }
+#else
+                float32x2x2_t tmp = vzip_f32(vget_high_f32(lhs), vget_high_f32(rhs));
+                return vcombine_f32(tmp.val[0], tmp.val[1]);
 #endif
+            }
 
             static batch_bool_type isnan(const batch_type& x)
             {
diff --git a/include/xsimd/types/xsimd_neon_int16.hpp b/include/xsimd/types/xsimd_neon_int16.hpp
@@ -345,17 +345,25 @@ namespace xsimd
                 return vbslq_s16(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_s16(lhs, rhs);
+#else
+                int16x4x2_t tmp = vzip_s16(vget_low_s16(lhs), vget_low_s16(rhs));
+                return vcombine_s16(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_s16(lhs, rhs);
-            }
+#else
+                int16x4x2_t tmp = vzip_s16(vget_high_s16(lhs), vget_high_s16(rhs));
+                return vcombine_s16(tmp.val[0], tmp.val[1]);
 #endif
+            }
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_int32.hpp b/include/xsimd/types/xsimd_neon_int32.hpp
@@ -425,17 +425,25 @@ namespace xsimd
                 return vbslq_s32(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_s32(lhs, rhs);
+#else
+                int32x2x2_t tmp = vzip_s32(vget_low_s32(lhs), vget_low_s32(rhs));
+                return vcombine_s32(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_s32(lhs, rhs);
-            }
+#else
+                int32x2x2_t tmp = vzip_s32(vget_high_s32(lhs), vget_high_s32(rhs));
+                return vcombine_s32(tmp.val[0], tmp.val[1]);
 #endif
+            }
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_int64.hpp b/include/xsimd/types/xsimd_neon_int64.hpp
@@ -440,17 +440,23 @@ namespace xsimd
                 return vbslq_s64(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_s64(lhs, rhs);
+#else
+                return vcombine_s64(vget_low_s64(lhs), vget_low_s64(rhs));
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_s64(lhs, rhs);
-            }
+#else
+                return vcombine_s64(vget_high_s64(lhs), vget_high_s64(rhs));
 #endif
+            }
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_int8.hpp b/include/xsimd/types/xsimd_neon_int8.hpp
@@ -346,17 +346,25 @@ namespace xsimd
                 return vbslq_s8(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_s8(lhs, rhs);
+#else
+                int8x8x2_t tmp = vzip_s8(vget_low_s8(lhs), vget_low_s8(rhs));
+                return vcombine_s8(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_s8(lhs, rhs);
-            }
+#else
+                int8x8x2_t tmp = vzip_s8(vget_high_s8(lhs), vget_high_s8(rhs));
+                return vcombine_s8(tmp.val[0], tmp.val[1]);
 #endif
+            }
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_uint16.hpp b/include/xsimd/types/xsimd_neon_uint16.hpp
@@ -319,17 +319,25 @@ namespace xsimd
                 return vbslq_u16(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_u16(lhs, rhs);
+#else
+                uint16x4x2_t tmp = vzip_u16(vget_low_u16(lhs), vget_low_u16(rhs));
+                return vcombine_u16(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_u16(lhs, rhs);
-            }
+#else
+                uint16x4x2_t tmp = vzip_u16(vget_high_u16(lhs), vget_high_u16(rhs));
+                return vcombine_u16(tmp.val[0], tmp.val[1]);
 #endif
+            }
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_uint32.hpp b/include/xsimd/types/xsimd_neon_uint32.hpp
@@ -416,17 +416,26 @@ namespace xsimd
                 return vbslq_u32(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_u32(lhs, rhs);
+#else
+                uint32x2x2_t tmp = vzip_u32(vget_low_u32(lhs), vget_low_u32(rhs));
+                return vcombine_u32(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_u32(lhs, rhs);
-            }
+#else
+                uint32x2x2_t tmp = vzip_u32(vget_high_u32(lhs), vget_high_u32(rhs));
+                return vcombine_u32(tmp.val[0], tmp.val[1]);
 #endif
+            }
+
         };
 
         inline batch<uint32_t, 4> shift_left(const batch<uint32_t, 4>& lhs, int32_t n)
diff --git a/include/xsimd/types/xsimd_neon_uint64.hpp b/include/xsimd/types/xsimd_neon_uint64.hpp
@@ -468,17 +468,24 @@ namespace xsimd
                 return vbslq_u64(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_u64(lhs, rhs);
+#else
+                return vcombine_u64(vget_low_u64(lhs), vget_low_u64(rhs));
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_u64(lhs, rhs);
-            }
+#else
+                return vcombine_u64(vget_high_u64(lhs), vget_high_u64(rhs));
 #endif
+            }
+
         };
 
         inline batch<uint64_t, 2> shift_left(const batch<uint64_t, 2>& lhs, int32_t n)
diff --git a/include/xsimd/types/xsimd_neon_uint8.hpp b/include/xsimd/types/xsimd_neon_uint8.hpp
@@ -320,17 +320,25 @@ namespace xsimd
                 return vbslq_u8(cond, a, b);
             }
 
-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
             static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip1q_u8(lhs, rhs);
+#else
+                uint8x8x2_t tmp = vzip_u8(vget_low_u8(lhs), vget_low_u8(rhs));
+                return vcombine_u8(tmp.val[0], tmp.val[1]);
+#endif
             }
 
             static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)
             {
+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION
                 return vzip2q_u8(lhs, rhs);
-            }
+#else
+                uint8x8x2_t tmp = vzip_u8(vget_high_u8(lhs), vget_high_u8(rhs));
+                return vcombine_u8(tmp.val[0], tmp.val[1]);
 #endif
+            }
         };
     }
 

Original file line number	Diff line number	Diff line change
`@@ -580,17 +580,23 @@ namespace xsimd`
`580`	`580`	`return vbslq_f64(cond, a, b);`
`581`	`581`	`}`
`582`	`582`
`583`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`584`	`583`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`585`	`584`	`{`
	`585`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`586`	`586`	`return vzip1q_f64(lhs, rhs);`
	`587`	`+#else`
	`588`	`+ return vcombine_f64(vget_low_f64(lhs), vget_low_f64(rhs));`
	`589`	`+#endif`
`587`	`590`	`}`
`588`	`591`
`589`	`592`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`590`	`593`	`{`
	`594`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`591`	`595`	`return vzip2q_f64(lhs, rhs);`
`592`		`- }`
	`596`	`+#else`
	`597`	`+ return vcombine_f64(vget_high_f64(lhs), vget_high_f64(rhs));`
`593`	`598`	`#endif`
	`599`	`+ }`
`594`	`600`
`595`	`601`	`static batch_bool_type isnan(const batch_type& x)`
`596`	`602`	`{`
Original file line number	Diff line number	Diff line change
`@@ -639,17 +639,25 @@ namespace xsimd`
`639`	`639`	`return vbslq_f32(cond, a, b);`
`640`	`640`	`}`
`641`	`641`
`642`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`643`	`642`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`644`	`643`	`{`
	`644`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`645`	`645`	`return vzip1q_f32(lhs, rhs);`
	`646`	`+#else`
	`647`	`+ float32x2x2_t tmp = vzip_f32(vget_low_f32(lhs), vget_low_f32(rhs));`
	`648`	`+ return vcombine_f32(tmp.val[0], tmp.val[1]);`
	`649`	`+#endif`
`646`	`650`	`}`
`647`	`651`
`648`	`652`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`649`	`653`	`{`
	`654`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`650`	`655`	`return vzip2q_f32(lhs, rhs);`
`651`		`- }`
	`656`	`+#else`
	`657`	`+ float32x2x2_t tmp = vzip_f32(vget_high_f32(lhs), vget_high_f32(rhs));`
	`658`	`+ return vcombine_f32(tmp.val[0], tmp.val[1]);`
`652`	`659`	`#endif`
	`660`	`+ }`
`653`	`661`
`654`	`662`	`static batch_bool_type isnan(const batch_type& x)`
`655`	`663`	`{`
Original file line number	Diff line number	Diff line change
`@@ -345,17 +345,25 @@ namespace xsimd`
`345`	`345`	`return vbslq_s16(cond, a, b);`
`346`	`346`	`}`
`347`	`347`
`348`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`349`	`348`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`350`	`349`	`{`
	`350`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`351`	`351`	`return vzip1q_s16(lhs, rhs);`
	`352`	`+#else`
	`353`	`+ int16x4x2_t tmp = vzip_s16(vget_low_s16(lhs), vget_low_s16(rhs));`
	`354`	`+ return vcombine_s16(tmp.val[0], tmp.val[1]);`
	`355`	`+#endif`
`352`	`356`	`}`
`353`	`357`
`354`	`358`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`355`	`359`	`{`
	`360`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`356`	`361`	`return vzip2q_s16(lhs, rhs);`
`357`		`- }`
	`362`	`+#else`
	`363`	`+ int16x4x2_t tmp = vzip_s16(vget_high_s16(lhs), vget_high_s16(rhs));`
	`364`	`+ return vcombine_s16(tmp.val[0], tmp.val[1]);`
`358`	`365`	`#endif`
	`366`	`+ }`
`359`	`367`	`};`
`360`	`368`	`}`
`361`	`369`
Original file line number	Diff line number	Diff line change
`@@ -425,17 +425,25 @@ namespace xsimd`
`425`	`425`	`return vbslq_s32(cond, a, b);`
`426`	`426`	`}`
`427`	`427`
`428`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`429`	`428`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`430`	`429`	`{`
	`430`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`431`	`431`	`return vzip1q_s32(lhs, rhs);`
	`432`	`+#else`
	`433`	`+ int32x2x2_t tmp = vzip_s32(vget_low_s32(lhs), vget_low_s32(rhs));`
	`434`	`+ return vcombine_s32(tmp.val[0], tmp.val[1]);`
	`435`	`+#endif`
`432`	`436`	`}`
`433`	`437`
`434`	`438`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`435`	`439`	`{`
	`440`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`436`	`441`	`return vzip2q_s32(lhs, rhs);`
`437`		`- }`
	`442`	`+#else`
	`443`	`+ int32x2x2_t tmp = vzip_s32(vget_high_s32(lhs), vget_high_s32(rhs));`
	`444`	`+ return vcombine_s32(tmp.val[0], tmp.val[1]);`
`438`	`445`	`#endif`
	`446`	`+ }`
`439`	`447`	`};`
`440`	`448`	`}`
`441`	`449`
Original file line number	Diff line number	Diff line change
`@@ -440,17 +440,23 @@ namespace xsimd`
`440`	`440`	`return vbslq_s64(cond, a, b);`
`441`	`441`	`}`
`442`	`442`
`443`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`444`	`443`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`445`	`444`	`{`
	`445`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`446`	`446`	`return vzip1q_s64(lhs, rhs);`
	`447`	`+#else`
	`448`	`+ return vcombine_s64(vget_low_s64(lhs), vget_low_s64(rhs));`
	`449`	`+#endif`
`447`	`450`	`}`
`448`	`451`
`449`	`452`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`450`	`453`	`{`
	`454`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`451`	`455`	`return vzip2q_s64(lhs, rhs);`
`452`		`- }`
	`456`	`+#else`
	`457`	`+ return vcombine_s64(vget_high_s64(lhs), vget_high_s64(rhs));`
`453`	`458`	`#endif`
	`459`	`+ }`
`454`	`460`	`};`
`455`	`461`	`}`
`456`	`462`
Original file line number	Diff line number	Diff line change
`@@ -346,17 +346,25 @@ namespace xsimd`
`346`	`346`	`return vbslq_s8(cond, a, b);`
`347`	`347`	`}`
`348`	`348`
`349`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`350`	`349`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`351`	`350`	`{`
	`351`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`352`	`352`	`return vzip1q_s8(lhs, rhs);`
	`353`	`+#else`
	`354`	`+ int8x8x2_t tmp = vzip_s8(vget_low_s8(lhs), vget_low_s8(rhs));`
	`355`	`+ return vcombine_s8(tmp.val[0], tmp.val[1]);`
	`356`	`+#endif`
`353`	`357`	`}`
`354`	`358`
`355`	`359`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`356`	`360`	`{`
	`361`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`357`	`362`	`return vzip2q_s8(lhs, rhs);`
`358`		`- }`
	`363`	`+#else`
	`364`	`+ int8x8x2_t tmp = vzip_s8(vget_high_s8(lhs), vget_high_s8(rhs));`
	`365`	`+ return vcombine_s8(tmp.val[0], tmp.val[1]);`
`359`	`366`	`#endif`
	`367`	`+ }`
`360`	`368`	`};`
`361`	`369`	`}`
`362`	`370`
Original file line number	Diff line number	Diff line change
`@@ -319,17 +319,25 @@ namespace xsimd`
`319`	`319`	`return vbslq_u16(cond, a, b);`
`320`	`320`	`}`
`321`	`321`
`322`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`323`	`322`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`324`	`323`	`{`
	`324`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`325`	`325`	`return vzip1q_u16(lhs, rhs);`
	`326`	`+#else`
	`327`	`+ uint16x4x2_t tmp = vzip_u16(vget_low_u16(lhs), vget_low_u16(rhs));`
	`328`	`+ return vcombine_u16(tmp.val[0], tmp.val[1]);`
	`329`	`+#endif`
`326`	`330`	`}`
`327`	`331`
`328`	`332`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`329`	`333`	`{`
	`334`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`330`	`335`	`return vzip2q_u16(lhs, rhs);`
`331`		`- }`
	`336`	`+#else`
	`337`	`+ uint16x4x2_t tmp = vzip_u16(vget_high_u16(lhs), vget_high_u16(rhs));`
	`338`	`+ return vcombine_u16(tmp.val[0], tmp.val[1]);`
`332`	`339`	`#endif`
	`340`	`+ }`
`333`	`341`	`};`
`334`	`342`	`}`
`335`	`343`
Original file line number	Diff line number	Diff line change
`@@ -468,17 +468,24 @@ namespace xsimd`
`468`	`468`	`return vbslq_u64(cond, a, b);`
`469`	`469`	`}`
`470`	`470`
`471`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`472`	`471`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`473`	`472`	`{`
	`473`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`474`	`474`	`return vzip1q_u64(lhs, rhs);`
	`475`	`+#else`
	`476`	`+ return vcombine_u64(vget_low_u64(lhs), vget_low_u64(rhs));`
	`477`	`+#endif`
`475`	`478`	`}`
`476`	`479`
`477`	`480`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`478`	`481`	`{`
	`482`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`479`	`483`	`return vzip2q_u64(lhs, rhs);`
`480`		`- }`
	`484`	`+#else`
	`485`	`+ return vcombine_u64(vget_high_u64(lhs), vget_high_u64(rhs));`
`481`	`486`	`#endif`
	`487`	`+ }`
	`488`	`+`
`482`	`489`	`};`
`483`	`490`
`484`	`491`	`inline batch<uint64_t, 2> shift_left(const batch<uint64_t, 2>& lhs, int32_t n)`
Original file line number	Diff line number	Diff line change
`@@ -320,17 +320,25 @@ namespace xsimd`
`320`	`320`	`return vbslq_u8(cond, a, b);`
`321`	`321`	`}`
`322`	`322`
`323`		`-#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`324`	`323`	`static batch_type zip_lo(const batch_type& lhs, const batch_type& rhs)`
`325`	`324`	`{`
	`325`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`326`	`326`	`return vzip1q_u8(lhs, rhs);`
	`327`	`+#else`
	`328`	`+ uint8x8x2_t tmp = vzip_u8(vget_low_u8(lhs), vget_low_u8(rhs));`
	`329`	`+ return vcombine_u8(tmp.val[0], tmp.val[1]);`
	`330`	`+#endif`
`327`	`331`	`}`
`328`	`332`
`329`	`333`	`static batch_type zip_hi(const batch_type& lhs, const batch_type& rhs)`
`330`	`334`	`{`
	`335`	`+#if XSIMD_ARM_INSTR_SET >= XSIMD_ARM8_64_NEON_VERSION`
`331`	`336`	`return vzip2q_u8(lhs, rhs);`
`332`		`- }`
	`337`	`+#else`
	`338`	`+ uint8x8x2_t tmp = vzip_u8(vget_high_u8(lhs), vget_high_u8(rhs));`
	`339`	`+ return vcombine_u8(tmp.val[0], tmp.val[1]);`
`333`	`340`	`#endif`
	`341`	`+ }`
`334`	`342`	`};`
`335`	`343`	`}`
`336`	`344`