diff --git a/crates/core_arch/src/s390x/macros.rs b/crates/core_arch/src/s390x/macros.rs
index 87936715ea..6f94d6828e 100644
--- a/crates/core_arch/src/s390x/macros.rs
+++ b/crates/core_arch/src/s390x/macros.rs
@@ -85,13 +85,15 @@ macro_rules! impl_vec_trait {
         impl_vec_trait!{ [$Trait $m] $fun ($a, $b) -> $r }
         impl_vec_trait!{ [$Trait $m] $fun ($b, $a) -> $r }
     };
-    ([$Trait:ident $m:ident] ~($ub:ident, $sb:ident, $uh:ident, $sh:ident, $uw:ident, $sw:ident)) => {
+    ([$Trait:ident $m:ident] ~($ub:ident, $sb:ident, $uh:ident, $sh:ident, $uw:ident, $sw:ident, $ug:ident, $sg:ident)) => {
         impl_vec_trait!{ [$Trait $m] $ub (vector_unsigned_char, ~vector_bool_char) -> vector_unsigned_char }
         impl_vec_trait!{ [$Trait $m] $sb (vector_signed_char, ~vector_bool_char) -> vector_signed_char }
         impl_vec_trait!{ [$Trait $m] $uh (vector_unsigned_short, ~vector_bool_short) -> vector_unsigned_short }
         impl_vec_trait!{ [$Trait $m] $sh (vector_signed_short, ~vector_bool_short) -> vector_signed_short }
         impl_vec_trait!{ [$Trait $m] $uw (vector_unsigned_int, ~vector_bool_int) -> vector_unsigned_int }
         impl_vec_trait!{ [$Trait $m] $sw (vector_signed_int, ~vector_bool_int) -> vector_signed_int }
+        impl_vec_trait!{ [$Trait $m] $ug (vector_unsigned_long_long, ~vector_bool_long_long) -> vector_unsigned_long_long }
+        impl_vec_trait!{ [$Trait $m] $sg (vector_signed_long_long, ~vector_bool_long_long) -> vector_signed_long_long }
     };
     ([$Trait:ident $m:ident] ~($fn:ident)) => {
         impl_vec_trait!{ [$Trait $m] ~($fn, $fn, $fn, $fn, $fn, $fn) }
diff --git a/crates/core_arch/src/s390x/vector.rs b/crates/core_arch/src/s390x/vector.rs
index 5d50311b15..56996cef5c 100644
--- a/crates/core_arch/src/s390x/vector.rs
+++ b/crates/core_arch/src/s390x/vector.rs
@@ -52,7 +52,28 @@ types! {
 }
 
 #[allow(improper_ctypes)]
-extern "C" {}
+#[rustfmt::skip]
+extern "unadjusted" {
+    #[link_name = "llvm.smax.v16i8"] fn vmxb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
+    #[link_name = "llvm.smax.v8i16"] fn vmxh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_short;
+    #[link_name = "llvm.smax.v4i32"] fn vmxf(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int;
+    #[link_name = "llvm.smax.v2i64"] fn vmxg(a: vector_signed_long_long, b: vector_signed_long_long) -> vector_signed_long_long;
+
+    #[link_name = "llvm.umax.v16i8"] fn vmxlb(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_char;
+    #[link_name = "llvm.umax.v8i16"] fn vmxlh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_short;
+    #[link_name = "llvm.umax.v4i32"] fn vmxlf(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int;
+    #[link_name = "llvm.umax.v2i64"] fn vmxlg(a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> vector_unsigned_long_long;
+
+    #[link_name = "llvm.smin.v16i8"] fn vmnb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
+    #[link_name = "llvm.smin.v8i16"] fn vmnh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_short;
+    #[link_name = "llvm.smin.v4i32"] fn vmnf(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int;
+    #[link_name = "llvm.smin.v2i64"] fn vmng(a: vector_signed_long_long, b: vector_signed_long_long) -> vector_signed_long_long;
+
+    #[link_name = "llvm.umin.v16i8"] fn vmnlb(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_char;
+    #[link_name = "llvm.umin.v8i16"] fn vmnlh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_short;
+    #[link_name = "llvm.umin.v4i32"] fn vmnlf(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int;
+    #[link_name = "llvm.umin.v2i64"] fn vmnlg(a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> vector_unsigned_long_long;
+}
 
 impl_from! { i8x16, u8x16,  i16x8, u16x8, i32x4, u32x4, i64x2, u64x2, f32x4, f64x2 }
 
@@ -131,21 +152,307 @@ mod sealed {
 
         impl_add!(va_double, vector_double, vfadb);
 
+        #[inline]
+        #[target_feature(enable = "vector")]
         // FIXME: "vfasb" is part of vector enhancements 1, add a test for it when possible
+        // #[cfg_attr(test, assert_instr(vfasb))]
+        pub unsafe fn va_float(a: vector_float, b: vector_float) -> vector_float {
+            transmute(simd_add(a, b))
+        }
+
         #[unstable(feature = "stdarch_s390x", issue = "135681")]
-        impl VectorAdd<Self> for f32 {
+        impl VectorAdd<Self> for vector_float {
             type Result = Self;
 
             #[inline]
             #[target_feature(enable = "vector")]
             unsafe fn vec_add(self, other: Self) -> Self::Result {
-                simd_add(self, other)
+                va_float(self, other)
+            }
+        }
+    }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorSub<Other> {
+        type Result;
+        unsafe fn vec_sub(self, other: Other) -> Self::Result;
+    }
+
+    macro_rules! impl_sub {
+        ($name:ident, $a:ty, $instr:ident) => {
+            impl_sub!($name, $a, $a, $a, $instr);
+        };
+        ($name:ident, $a:ty, $b:ty, $c:ty, $instr:ident) => {
+            #[inline]
+            #[target_feature(enable = "vector")]
+            #[cfg_attr(test, assert_instr($instr))]
+            pub unsafe fn $name(a: $a, b: $b) -> $c {
+                transmute(simd_sub(transmute(a), b))
+            }
+
+            #[unstable(feature = "stdarch_s390x", issue = "135681")]
+            impl VectorSub<$b> for $a {
+                type Result = $c;
+
+                #[inline]
+                #[target_feature(enable = "vector")]
+                unsafe fn vec_sub(self, other: $b) -> Self::Result {
+                    $name(self, other)
+                }
+            }
+        };
+    }
+
+    #[rustfmt::skip]
+    mod impl_sub {
+        use super::*;
+
+        impl_sub!(vs_sc, vector_signed_char, vsb);
+        impl_sub!(vs_uc, vector_unsigned_char, vsb);
+        impl_sub!(vs_sh, vector_signed_short, vsh);
+        impl_sub!(vs_uh, vector_unsigned_short, vsh);
+        impl_sub!(vs_sf, vector_signed_int, vsf);
+        impl_sub!(vs_uf, vector_unsigned_int, vsf);
+        impl_sub!(vs_sg, vector_signed_long_long, vsg);
+        impl_sub!(vs_ug, vector_unsigned_long_long, vsg);
+
+        impl_sub!(vs_sc_bc, vector_signed_char, vector_bool_char, vector_signed_char, vsb);
+        impl_sub!(vs_uc_bc, vector_unsigned_char, vector_bool_char, vector_unsigned_char, vsb);
+        impl_sub!(vs_sh_bh, vector_signed_short, vector_bool_short, vector_signed_short, vsh);
+        impl_sub!(vs_uh_bh, vector_unsigned_short, vector_bool_short, vector_unsigned_short, vsh);
+        impl_sub!(vs_sf_bf, vector_signed_int, vector_bool_int, vector_signed_int, vsf);
+        impl_sub!(vs_uf_bf, vector_unsigned_int, vector_bool_int, vector_unsigned_int, vsf);
+        impl_sub!(vs_sg_bg, vector_signed_long_long, vector_bool_long_long, vector_signed_long_long, vsg);
+        impl_sub!(vs_ug_bg, vector_unsigned_long_long, vector_bool_long_long, vector_unsigned_long_long, vsg);
+
+        impl_sub!(vs_bc_sc, vector_bool_char, vector_signed_char, vector_signed_char, vsb);
+        impl_sub!(vs_bc_uc, vector_bool_char, vector_unsigned_char, vector_unsigned_char, vsb);
+        impl_sub!(vs_bh_sh, vector_bool_short, vector_signed_short, vector_signed_short, vsh);
+        impl_sub!(vs_bh_uh, vector_bool_short, vector_unsigned_short, vector_unsigned_short, vsh);
+        impl_sub!(vs_bf_sf, vector_bool_int, vector_signed_int, vector_signed_int, vsf);
+        impl_sub!(vs_bf_uf, vector_bool_int, vector_unsigned_int, vector_unsigned_int, vsf);
+        impl_sub!(vs_bg_sg, vector_bool_long_long, vector_signed_long_long, vector_signed_long_long, vsg);
+        impl_sub!(vs_bg_ug, vector_bool_long_long, vector_unsigned_long_long, vector_unsigned_long_long, vsg);
+
+        impl_sub!(vs_double, vector_double, vfsdb);
+
+        #[inline]
+        #[target_feature(enable = "vector")]
+        // FIXME: "vfssb" is part of vector enhancements 1, add a test for it when possible
+        // #[cfg_attr(test, assert_instr(vfasb))]
+        pub unsafe fn vs_float(a: vector_float, b: vector_float) -> vector_float {
+            transmute(simd_sub(a, b))
+        }
+
+        #[unstable(feature = "stdarch_s390x", issue = "135681")]
+        impl VectorSub<Self> for vector_float {
+            type Result = Self;
+
+            #[inline]
+            #[target_feature(enable = "vector")]
+            unsafe fn vec_sub(self, other: Self) -> Self::Result {
+                vs_float(self, other)
+            }
+        }
+    }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorMul {
+        unsafe fn vec_mul(self, b: Self) -> Self;
+    }
+
+    macro_rules! impl_mul {
+        ($name:ident, $a:ty, std_simd) => {
+            #[unstable(feature = "stdarch_s390x", issue = "135681")]
+            impl VectorMul for $a {
+                #[inline]
+                #[target_feature(enable = "vector")]
+                unsafe fn vec_mul(self, other: Self) -> Self {
+                    transmute(simd_mul(transmute(self), other))
+                }
+            }
+        };
+        ($name:ident, $a:ty, $instr:ident) => {
+            #[inline]
+            #[target_feature(enable = "vector")]
+            #[cfg_attr(test, assert_instr($instr))]
+            pub unsafe fn $name(a: $a, b: $a) -> $a {
+                transmute(simd_mul(transmute(a), b))
+            }
+
+            #[unstable(feature = "stdarch_s390x", issue = "135681")]
+            impl VectorMul for $a {
+                #[inline]
+                #[target_feature(enable = "vector")]
+                unsafe fn vec_mul(self, other: Self) -> Self {
+                    $name(self, other)
+                }
+            }
+        };
+    }
+
+    #[rustfmt::skip]
+    mod impl_mul {
+        use super::*;
+
+        impl_mul!(vml_sc, vector_signed_char, vmlb);
+        impl_mul!(vml_uc, vector_unsigned_char, vmlb);
+        impl_mul!(vml_sh, vector_signed_short, vmlhw);
+        impl_mul!(vml_uh, vector_unsigned_short, vmlhw);
+        impl_mul!(vml_sf, vector_signed_int, vmlf);
+        impl_mul!(vml_uf, vector_unsigned_int, vmlf);
+        impl_mul!(vml_sg, vector_signed_long_long, std_simd);
+        impl_mul!(vml_ug, vector_unsigned_long_long, std_simd);
+
+        impl_mul!(vml_float, vector_float, std_simd);
+        impl_mul!(vml_double, vector_double, vfmdb);
+    }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorMax<Other> {
+        type Result;
+        unsafe fn vec_max(self, b: Other) -> Self::Result;
+    }
+
+    test_impl! { vec_vmxsb (a: vector_signed_char, b: vector_signed_char) -> vector_signed_char [vmxb, vmxb] }
+    test_impl! { vec_vmxsh (a: vector_signed_short, b: vector_signed_short) -> vector_signed_short [vmxh, vmxh] }
+    test_impl! { vec_vmxsf (a: vector_signed_int, b: vector_signed_int) -> vector_signed_int [vmxf, vmxf] }
+    test_impl! { vec_vmxsg (a: vector_signed_long_long, b: vector_signed_long_long) -> vector_signed_long_long [vmxg, vmxg] }
+
+    test_impl! { vec_vmxslb (a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_char [vmxlb, vmxlb] }
+    test_impl! { vec_vmxslh (a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_short [vmxlh, vmxlh] }
+    test_impl! { vec_vmxslf (a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int [vmxlf, vmxlf] }
+    test_impl! { vec_vmxslg (a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> vector_unsigned_long_long [vmxlg, vmxlg] }
+
+    impl_vec_trait! { [VectorMax vec_max] ~(vmxlb, vmxb, vmxlh, vmxh, vmxlf, vmxf, vmxlg, vmxg) }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorMin<Other> {
+        type Result;
+        unsafe fn vec_min(self, b: Other) -> Self::Result;
+    }
+
+    test_impl! { vec_vmnsb (a: vector_signed_char, b: vector_signed_char) -> vector_signed_char [vmnb, vmnb] }
+    test_impl! { vec_vmnsh (a: vector_signed_short, b: vector_signed_short) -> vector_signed_short [vmnh, vmnh] }
+    test_impl! { vec_vmnsf (a: vector_signed_int, b: vector_signed_int) -> vector_signed_int [vmnf, vmnf] }
+    test_impl! { vec_vmnsg (a: vector_signed_long_long, b: vector_signed_long_long) -> vector_signed_long_long [vmng, vmng] }
+
+    test_impl! { vec_vmnslb (a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_char [vmnlb, vmnlb] }
+    test_impl! { vec_vmnslh (a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_short [vmnlh, vmnlh] }
+    test_impl! { vec_vmnslf (a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int [vmnlf, vmnlf] }
+    test_impl! { vec_vmnslg (a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> vector_unsigned_long_long [vmnlg, vmnlg] }
+
+    impl_vec_trait! { [VectorMin vec_min] ~(vmxlb, vmxb, vmxlh, vmxh, vmxlf, vmxf, vmxlg, vmxg) }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorAbs {
+        unsafe fn vec_abs(self) -> Self;
+    }
+
+    macro_rules! impl_abs {
+        ($name:ident, $ty:ident) => {
+            #[inline]
+            #[target_feature(enable = "vector")]
+            unsafe fn $name(v: s_t_l!($ty)) -> s_t_l!($ty) {
+                v.vec_max(-v)
             }
+
+            impl_vec_trait! { [VectorAbs vec_abs] $name (s_t_l!($ty)) }
+        };
+    }
+
+    impl_abs! { vec_abs_i8, i8x16 }
+    impl_abs! { vec_abs_i16, i16x8 }
+    impl_abs! { vec_abs_i32, i32x4 }
+    impl_abs! { vec_abs_i64, i64x2 }
+
+    #[inline]
+    #[target_feature(enable = "vector")]
+    unsafe fn vec_abs_f32(v: vector_float) -> vector_float {
+        let v: u32x4 = transmute(v);
+
+        transmute(simd_and(v, u32x4::splat(0x7FFFFFFF)))
+    }
+
+    #[inline]
+    #[target_feature(enable = "vector")]
+    unsafe fn vec_abs_f64(v: vector_double) -> vector_double {
+        let v: u64x2 = transmute(v);
+
+        transmute(simd_and(v, u64x2::splat(0x7FFFFFFF_FFFFFFFF)))
+    }
+
+    impl_vec_trait! { [VectorAbs vec_abs] vec_abs_f32 (vector_float) }
+    impl_vec_trait! { [VectorAbs vec_abs] vec_abs_f64 (vector_double) }
+
+    #[unstable(feature = "stdarch_s390x", issue = "135681")]
+    pub trait VectorSplats<Output> {
+        unsafe fn vec_splats(self) -> Output;
+    }
+
+    macro_rules! impl_vec_splats {
+        ($(($fn:ident ($ty:ty, $shortty:tt) $instr:ident)),*) => {
+            $(
+                #[inline]
+                #[target_feature(enable = "vector")]
+                #[cfg_attr(test, assert_instr($instr))]
+                pub unsafe fn $fn(v: $ty) -> s_t_l!($shortty) {
+                    transmute($shortty::splat(v))
+                }
+
+                #[unstable(feature = "stdarch_s390x", issue = "135681")]
+                impl VectorSplats<s_t_l!($shortty)> for $ty {
+                    #[inline]
+                    #[target_feature(enable = "vector")]
+                    unsafe fn vec_splats(self) -> s_t_l!($shortty) {
+                        $fn (self)
+                    }
+                }
+            )*
         }
     }
+
+    impl_vec_splats! {
+        (vec_splats_u8 (u8, u8x16) vrepb),
+        (vec_splats_i8 (i8, i8x16) vrepb),
+        (vec_splats_u16 (u16, u16x8) vreph),
+        (vec_splats_i16 (i16, i16x8) vreph),
+        (vec_splats_u32 (u32, u32x4) vrepf),
+        (vec_splats_i32 (i32, i32x4) vrepf),
+        (vec_splats_u64 (u64, u64x2) vlvgp),
+        (vec_splats_i64 (i64, i64x2) vlvgp),
+        (vec_splats_f32 (f32, f32x4) vrepf),
+        (vec_splats_f64 (f64, f64x2) vrepg)
+    }
+
+    macro_rules! impl_bool_vec_splats {
+        ($(($ty:ty, $shortty:tt, $boolty:ty)),*) => {
+            $(
+                #[unstable(feature = "stdarch_s390x", issue = "135681")]
+                impl VectorSplats<$boolty> for $ty {
+                    #[inline]
+                    #[target_feature(enable = "vector")]
+                    unsafe fn vec_splats(self) -> $boolty {
+                        transmute($shortty::splat(self))
+                    }
+                }
+            )*
+        }
+    }
+
+    impl_bool_vec_splats! {
+        (u8, u8x16, vector_bool_char),
+        (i8, i8x16, vector_bool_char),
+        (u16, u16x8, vector_bool_short),
+        (i16, i16x8, vector_bool_short),
+        (u32, u32x4, vector_bool_int),
+        (i32, i32x4, vector_bool_int),
+        (u64, u64x2, vector_bool_long_long),
+        (i64, i64x2, vector_bool_long_long)
+    }
 }
 
-/// Vector add.
+/// Vector element-wise addition.
 #[inline]
 #[target_feature(enable = "vector")]
 #[unstable(feature = "stdarch_s390x", issue = "135681")]
@@ -156,6 +463,78 @@ where
     a.vec_add(b)
 }
 
+/// Vector element-wise subtraction.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_sub<T, U>(a: T, b: U) -> <T as sealed::VectorSub<U>>::Result
+where
+    T: sealed::VectorSub<U>,
+{
+    a.vec_sub(b)
+}
+
+/// Vector element-wise multiplication.
+///
+/// ## Purpose
+/// Compute the products of corresponding elements of two vectors.
+///
+/// ## Result value
+/// Each element of r receives the product of the corresponding elements of a and b.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_mul<T>(a: T, b: T) -> T
+where
+    T: sealed::VectorMul,
+{
+    a.vec_mul(b)
+}
+
+/// Vector element-wise maximum.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_max<T, U>(a: T, b: U) -> <T as sealed::VectorMax<U>>::Result
+where
+    T: sealed::VectorMax<U>,
+{
+    a.vec_max(b)
+}
+
+/// Vector element-wise minimum.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_min<T, U>(a: T, b: U) -> <T as sealed::VectorMin<U>>::Result
+where
+    T: sealed::VectorMin<U>,
+{
+    a.vec_min(b)
+}
+
+/// Vector abs.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_abs<T>(a: T) -> T
+where
+    T: sealed::VectorAbs,
+{
+    a.vec_abs()
+}
+
+/// Vector splats.
+#[inline]
+#[target_feature(enable = "vector")]
+#[unstable(feature = "stdarch_s390x", issue = "135681")]
+pub unsafe fn vec_splats<T, U>(a: T) -> U
+where
+    T: sealed::VectorSplats<U>,
+{
+    a.vec_splats()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -165,6 +544,33 @@ mod tests {
     use crate::core_arch::simd::*;
     use stdarch_test::simd_test;
 
+    macro_rules! test_vec_2 {
+        { $name: ident, $fn:ident, $ty: ident, [$($a:expr),+], [$($b:expr),+], [$($d:expr),+] } => {
+            test_vec_2! { $name, $fn, $ty -> $ty, [$($a),+], [$($b),+], [$($d),+] }
+        };
+        { $name: ident, $fn:ident, $ty: ident -> $ty_out: ident, [$($a:expr),+], [$($b:expr),+], [$($d:expr),+] } => {
+            #[simd_test(enable = "vector")]
+            unsafe fn $name() {
+                let a: s_t_l!($ty) = transmute($ty::new($($a),+));
+                let b: s_t_l!($ty) = transmute($ty::new($($b),+));
+
+                let d = $ty_out::new($($d),+);
+                let r : $ty_out = transmute($fn(a, b));
+                assert_eq!(d, r);
+            }
+         };
+         { $name: ident, $fn:ident, $ty: ident -> $ty_out: ident, [$($a:expr),+], [$($b:expr),+], $d:expr } => {
+            #[simd_test(enable = "vector")]
+            unsafe fn $name() {
+                let a: s_t_l!($ty) = transmute($ty::new($($a),+));
+                let b: s_t_l!($ty) = transmute($ty::new($($b),+));
+
+                let r : $ty_out = transmute($fn(a, b));
+                assert_eq!($d, r);
+            }
+         }
+   }
+
     #[simd_test(enable = "vector")]
     unsafe fn vec_add_i32x4_i32x4() {
         let x = i32x4::new(1, 2, 3, 4);
@@ -174,4 +580,135 @@ mod tests {
         let z = vec_add(x, y);
         assert_eq!(i32x4::splat(5), transmute(z));
     }
+
+    macro_rules! test_vec_sub {
+        { $name: ident, $ty: ident, [$($a:expr),+], [$($b:expr),+], [$($d:expr),+] } => {
+            test_vec_2! {$name, vec_sub, $ty, [$($a),+], [$($b),+], [$($d),+] }
+        }
+    }
+
+    test_vec_sub! { test_vec_sub_f32x4, f32x4,
+    [-1.0, 0.0, 1.0, 2.0],
+    [2.0, 1.0, -1.0, -2.0],
+    [-3.0, -1.0, 2.0, 4.0] }
+
+    test_vec_sub! { test_vec_sub_f64x2, f64x2,
+    [-1.0, 0.0],
+    [2.0, 1.0],
+    [-3.0, -1.0] }
+
+    test_vec_sub! { test_vec_sub_i64x2, i64x2,
+    [-1, 0],
+    [2, 1],
+    [-3, -1] }
+
+    test_vec_sub! { test_vec_sub_u64x2, u64x2,
+    [0, 1],
+    [1, 0],
+    [u64::MAX, 1] }
+
+    test_vec_sub! { test_vec_sub_i32x4, i32x4,
+    [-1, 0, 1, 2],
+    [2, 1, -1, -2],
+    [-3, -1, 2, 4] }
+
+    test_vec_sub! { test_vec_sub_u32x4, u32x4,
+    [0, 0, 1, 2],
+    [2, 1, 0, 0],
+    [4294967294, 4294967295, 1, 2] }
+
+    test_vec_sub! { test_vec_sub_i16x8, i16x8,
+    [-1, 0, 1, 2, -1, 0, 1, 2],
+    [2, 1, -1, -2, 2, 1, -1, -2],
+    [-3, -1, 2, 4, -3, -1, 2, 4] }
+
+    test_vec_sub! { test_vec_sub_u16x8, u16x8,
+    [0, 0, 1, 2, 0, 0, 1, 2],
+    [2, 1, 0, 0, 2, 1, 0, 0],
+    [65534, 65535, 1, 2, 65534, 65535, 1, 2] }
+
+    test_vec_sub! { test_vec_sub_i8x16, i8x16,
+    [-1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2],
+    [2, 1, -1, -2, 2, 1, -1, -2, 2, 1, -1, -2, 2, 1, -1, -2],
+    [-3, -1, 2, 4, -3, -1, 2, 4, -3, -1, 2, 4, -3, -1, 2, 4] }
+
+    test_vec_sub! { test_vec_sub_u8x16, u8x16,
+    [0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2],
+    [2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0],
+    [254, 255, 1, 2, 254, 255, 1, 2, 254, 255, 1, 2, 254, 255, 1, 2] }
+
+    macro_rules! test_vec_mul {
+        { $name: ident, $ty: ident, [$($a:expr),+], [$($b:expr),+], [$($d:expr),+] } => {
+            test_vec_2! {$name, vec_mul, $ty, [$($a),+], [$($b),+], [$($d),+] }
+        }
+    }
+
+    test_vec_mul! { test_vec_mul_f32x4, f32x4,
+    [-1.0, 0.0, 1.0, 2.0],
+    [2.0, 1.0, -1.0, -2.0],
+    [-2.0, 0.0, -1.0, -4.0] }
+
+    test_vec_mul! { test_vec_mul_f64x2, f64x2,
+    [-1.0, 0.0],
+    [2.0, 1.0],
+    [-2.0, 0.0] }
+
+    test_vec_mul! { test_vec_mul_i64x2, i64x2,
+    [i64::MAX, -4],
+    [2, 3],
+    [i64::MAX.wrapping_mul(2), -12] }
+
+    test_vec_mul! { test_vec_mul_u64x2, u64x2,
+    [u64::MAX, 4],
+    [2, 3],
+    [u64::MAX.wrapping_mul(2), 12] }
+
+    test_vec_mul! { test_vec_mul_i32x4, i32x4,
+    [-1, 0, 1, 2],
+    [2, 1, -1, -2],
+    [-2, 0, -1, -4] }
+
+    test_vec_mul! { test_vec_mul_u32x4, u32x4,
+    [0, u32::MAX - 1, 1, 2],
+    [5, 6, 7, 8],
+    [0, 4294967284, 7, 16] }
+
+    test_vec_mul! { test_vec_mul_i16x8, i16x8,
+    [-1, 0, 1, 2, -1, 0, 1, 2],
+    [2, 1, -1, -2, 2, 1, -1, -2],
+    [-2, 0, -1, -4, -2, 0, -1, -4] }
+
+    test_vec_mul! { test_vec_mul_u16x8, u16x8,
+    [0, u16::MAX - 1, 1, 2, 3, 4, 5, 6],
+    [5, 6, 7, 8, 9, 8, 7, 6],
+    [0, 65524, 7, 16, 27, 32, 35, 36] }
+
+    test_vec_mul! { test_vec_mul_i8x16, i8x16,
+    [-1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2],
+    [2, 1, -1, -2, 2, 1, -1, -2, 2, 1, -1, -2, 2, 1, -1, -2],
+    [-2, 0, -1, -4, -2, 0, -1, -4, -2, 0, -1, -4, -2, 0, -1, -4] }
+
+    test_vec_mul! { test_vec_mul_u8x16, u8x16,
+    [0, u8::MAX - 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4],
+    [5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 0, u8::MAX, 1, 2, 3, 4],
+    [0, 244, 7, 16, 27, 32, 35, 36, 35, 32, 0, 248, 7, 12, 15, 16] }
+
+    macro_rules! test_vec_abs {
+        { $name: ident, $ty: ident, $a: expr, $d: expr } => {
+            #[simd_test(enable = "vector")]
+            unsafe fn $name() {
+                let a: s_t_l!($ty) = vec_splats($a);
+                let a: s_t_l!($ty) = vec_abs(a);
+                let d = $ty::splat($d);
+                assert_eq!(d, transmute(a));
+            }
+        }
+    }
+
+    test_vec_abs! { test_vec_abs_i8, i8x16, -42i8, 42i8 }
+    test_vec_abs! { test_vec_abs_i16, i16x8, -42i16, 42i16 }
+    test_vec_abs! { test_vec_abs_i32, i32x4, -42i32, 42i32 }
+    test_vec_abs! { test_vec_abs_i64, i64x2, -42i64, 42i64 }
+    test_vec_abs! { test_vec_abs_f32, f32x4, -42f32, 42f32 }
+    test_vec_abs! { test_vec_abs_f64, f64x2, -42f64, 42f64 }
 }