From ef24de24a82fe681581cc130f342363c47c0969a Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 7 Jun 2024 07:48:48 +0200
Subject: Merging upstream version 1.75.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/packed_simd/src/api/cast/macros.rs |  82 ++++++++
 vendor/packed_simd/src/api/cast/v128.rs   | 302 ++++++++++++++++++++++++++++++
 vendor/packed_simd/src/api/cast/v16.rs    |  68 +++++++
 vendor/packed_simd/src/api/cast/v256.rs   | 298 +++++++++++++++++++++++++++++
 vendor/packed_simd/src/api/cast/v32.rs    | 132 +++++++++++++
 vendor/packed_simd/src/api/cast/v512.rs   | 209 +++++++++++++++++++++
 vendor/packed_simd/src/api/cast/v64.rs    | 208 ++++++++++++++++++++
 7 files changed, 1299 insertions(+)
 create mode 100644 vendor/packed_simd/src/api/cast/macros.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v128.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v16.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v256.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v32.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v512.rs
 create mode 100644 vendor/packed_simd/src/api/cast/v64.rs

(limited to 'vendor/packed_simd/src/api/cast')

diff --git a/vendor/packed_simd/src/api/cast/macros.rs b/vendor/packed_simd/src/api/cast/macros.rs
new file mode 100644
index 000000000..3bb29f0b8
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/macros.rs
@@ -0,0 +1,82 @@
+//! Macros implementing `FromCast`
+
+macro_rules! impl_from_cast_ {
+    ($id:ident[$test_tt:tt]: $from_ty:ident) => {
+        impl crate::api::cast::FromCast<$from_ty> for $id {
+            #[inline]
+            fn from_cast(x: $from_ty) -> Self {
+                use crate::llvm::simd_cast;
+                debug_assert_eq!($from_ty::lanes(), $id::lanes());
+                Simd(unsafe { simd_cast(x.0) })
+            }
+        }
+
+        test_if!{
+            $test_tt:
+            paste::item! {
+                pub mod [<$id _from_cast_ $from_ty>] {
+                    use super::*;
+                    #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+                    fn test() {
+                        assert_eq!($id::lanes(), $from_ty::lanes());
+                    }
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_from_cast {
+    ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => {
+        $(
+            impl_from_cast_!($id[$test_tt]: $from_ty);
+        )*
+    }
+}
+
+macro_rules! impl_from_cast_mask_ {
+    ($id:ident[$test_tt:tt]: $from_ty:ident) => {
+        impl crate::api::cast::FromCast<$from_ty> for $id {
+            #[inline]
+            fn from_cast(x: $from_ty) -> Self {
+                debug_assert_eq!($from_ty::lanes(), $id::lanes());
+                x.ne($from_ty::default())
+                    .select($id::splat(true), $id::splat(false))
+            }
+        }
+
+        test_if!{
+            $test_tt:
+            paste::item! {
+                pub mod [<$id _from_cast_ $from_ty>] {
+                    use super::*;
+                    #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+                    fn test() {
+                        assert_eq!($id::lanes(), $from_ty::lanes());
+
+                        let x = $from_ty::default();
+                        let m: $id = x.cast();
+                        assert!(m.none());
+                    }
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_from_cast_mask {
+    ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => {
+        $(
+            impl_from_cast_mask_!($id[$test_tt]: $from_ty);
+        )*
+    }
+}
+
+#[allow(unused)]
+macro_rules! impl_into_cast {
+    ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => {
+        $(
+            impl_from_cast_!($from_ty[$test_tt]: $id);
+        )*
+    }
+}
diff --git a/vendor/packed_simd/src/api/cast/v128.rs b/vendor/packed_simd/src/api/cast/v128.rs
new file mode 100644
index 000000000..2e10b97b7
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v128.rs
@@ -0,0 +1,302 @@
+//! `FromCast` and `IntoCast` implementations for portable 128-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(i8x16[test_v128]: u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16);
+impl_from_cast!(u8x16[test_v128]: i8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16);
+impl_from_cast_mask!(m8x16[test_v128]: i8x16, u8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16);
+
+impl_from_cast!(
+    i16x8[test_v128]: i8x8,
+    u8x8,
+    m8x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    u16x8[test_v128]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast_mask!(
+    m16x8[test_v128]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+
+impl_from_cast!(
+    i32x4[test_v128]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    u32x4[test_v128]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    f32x4[test_v128]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    m32x4[test_v128]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+
+impl_from_cast!(
+    i64x2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    u64x2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    f64x2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    m64x2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+
+impl_from_cast!(
+    isizex2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    usizex2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    msizex2[test_v128]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2
+);
+
+// FIXME[test_v128]: 64-bit single element vectors into_cast impls
+impl_from_cast!(i128x1[test_v128]: u128x1, m128x1);
+impl_from_cast!(u128x1[test_v128]: i128x1, m128x1);
+impl_from_cast!(m128x1[test_v128]: i128x1, u128x1);
diff --git a/vendor/packed_simd/src/api/cast/v16.rs b/vendor/packed_simd/src/api/cast/v16.rs
new file mode 100644
index 000000000..896febacb
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v16.rs
@@ -0,0 +1,68 @@
+//! `FromCast` and `IntoCast` implementations for portable 16-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(
+    i8x2[test_v16]: u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    u8x2[test_v16]: i8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    m8x2[test_v16]: i8x2,
+    u8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
diff --git a/vendor/packed_simd/src/api/cast/v256.rs b/vendor/packed_simd/src/api/cast/v256.rs
new file mode 100644
index 000000000..fe0c835e3
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v256.rs
@@ -0,0 +1,298 @@
+//! `FromCast` and `IntoCast` implementations for portable 256-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(i8x32[test_v256]: u8x32, m8x32, i16x32, u16x32, m16x32);
+impl_from_cast!(u8x32[test_v256]: i8x32, m8x32, i16x32, u16x32, m16x32);
+impl_from_cast_mask!(m8x32[test_v256]: i8x32, u8x32, i16x32, u16x32, m16x32);
+
+impl_from_cast!(i16x16[test_v256]: i8x16, u8x16, m8x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16);
+impl_from_cast!(u16x16[test_v256]: i8x16, u8x16, m8x16, i16x16, m16x16, i32x16, u32x16, f32x16, m32x16);
+impl_from_cast_mask!(m16x16[test_v256]: i8x16, u8x16, m8x16, i16x16, u16x16, i32x16, u32x16, f32x16, m32x16);
+
+impl_from_cast!(
+    i32x8[test_v256]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    u32x8[test_v256]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    f32x8[test_v256]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast_mask!(
+    m32x8[test_v256]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+
+impl_from_cast!(
+    i64x4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    u64x4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    f64x4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    m64x4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+
+impl_from_cast!(
+    i128x2[test_v256]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    u128x2[test_v256]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    m128x2[test_v256]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    m64x2,
+    f64x2,
+    i128x2,
+    u128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+
+impl_from_cast!(
+    isizex4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    usizex4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    msizex4[test_v256]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4
+);
diff --git a/vendor/packed_simd/src/api/cast/v32.rs b/vendor/packed_simd/src/api/cast/v32.rs
new file mode 100644
index 000000000..4ad1cbf74
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v32.rs
@@ -0,0 +1,132 @@
+//! `FromCast` and `IntoCast` implementations for portable 32-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(
+    i8x4[test_v32]: u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    u8x4[test_v32]: i8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    m8x4[test_v32]: i8x4,
+    u8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+
+impl_from_cast!(
+    i16x2[test_v32]: i8x2,
+    u8x2,
+    m8x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    u16x2[test_v32]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    m16x2[test_v32]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
diff --git a/vendor/packed_simd/src/api/cast/v512.rs b/vendor/packed_simd/src/api/cast/v512.rs
new file mode 100644
index 000000000..b64605045
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v512.rs
@@ -0,0 +1,209 @@
+//! `FromCast` and `IntoCast` implementations for portable 512-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(i8x64[test_v512]: u8x64, m8x64);
+impl_from_cast!(u8x64[test_v512]: i8x64, m8x64);
+impl_from_cast_mask!(m8x64[test_v512]: i8x64, u8x64);
+
+impl_from_cast!(i16x32[test_v512]: i8x32, u8x32, m8x32, u16x32, m16x32);
+impl_from_cast!(u16x32[test_v512]: i8x32, u8x32, m8x32, i16x32, m16x32);
+impl_from_cast_mask!(m16x32[test_v512]: i8x32, u8x32, m8x32, i16x32, u16x32);
+
+impl_from_cast!(i32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, u32x16, f32x16, m32x16);
+impl_from_cast!(u32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, f32x16, m32x16);
+impl_from_cast!(f32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, m32x16);
+impl_from_cast_mask!(m32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16);
+
+impl_from_cast!(
+    i64x8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    u64x8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    f64x8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast_mask!(
+    m64x8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+
+impl_from_cast!(
+    i128x4[test_v512]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    u128x4[test_v512]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    m128x4[test_v512]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    m64x4,
+    f64x4,
+    i128x4,
+    u128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+
+impl_from_cast!(
+    isizex8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    usizex8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    msizex8
+);
+impl_from_cast_mask!(
+    msizex8[test_v512]: i8x8,
+    u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8
+);
diff --git a/vendor/packed_simd/src/api/cast/v64.rs b/vendor/packed_simd/src/api/cast/v64.rs
new file mode 100644
index 000000000..b23d1a491
--- /dev/null
+++ b/vendor/packed_simd/src/api/cast/v64.rs
@@ -0,0 +1,208 @@
+//! `FromCast` and `IntoCast` implementations for portable 64-bit wide vectors
+#[rustfmt::skip]
+
+use crate::*;
+
+impl_from_cast!(
+    i8x8[test_v64]: u8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast!(
+    u8x8[test_v64]: i8x8,
+    m8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+impl_from_cast_mask!(
+    m8x8[test_v64]: i8x8,
+    u8x8,
+    i16x8,
+    u16x8,
+    m16x8,
+    i32x8,
+    u32x8,
+    f32x8,
+    m32x8,
+    i64x8,
+    u64x8,
+    f64x8,
+    m64x8,
+    isizex8,
+    usizex8,
+    msizex8
+);
+
+impl_from_cast!(
+    i16x4[test_v64]: i8x4,
+    u8x4,
+    m8x4,
+    u16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast!(
+    u16x4[test_v64]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    m16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+impl_from_cast_mask!(
+    m16x4[test_v64]: i8x4,
+    u8x4,
+    m8x4,
+    i16x4,
+    u16x4,
+    i32x4,
+    u32x4,
+    f32x4,
+    m32x4,
+    i64x4,
+    u64x4,
+    f64x4,
+    m64x4,
+    i128x4,
+    u128x4,
+    m128x4,
+    isizex4,
+    usizex4,
+    msizex4
+);
+
+impl_from_cast!(
+    i32x2[test_v64]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    u32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    u32x2[test_v64]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    f32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast!(
+    f32x2[test_v64]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    m32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
+impl_from_cast_mask!(
+    m32x2[test_v64]: i8x2,
+    u8x2,
+    m8x2,
+    i16x2,
+    u16x2,
+    m16x2,
+    i32x2,
+    u32x2,
+    f32x2,
+    i64x2,
+    u64x2,
+    f64x2,
+    m64x2,
+    i128x2,
+    u128x2,
+    m128x2,
+    isizex2,
+    usizex2,
+    msizex2
+);
-- 
cgit v1.2.3