1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use super::*;

impl ShlAssign<i32> for I16x1 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        *self = I16x1(self.0 << rhs);
    }
}

impl ShlAssign<i32> for I32x1 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        *self = I32x1(self.0 << rhs);
    }
}

impl ShlAssign<i32> for I64x1 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        *self = I64x1(self.0 << rhs);
    }
}

impl ShlAssign<i32> for F32x1 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        let bits = self.0.to_bits() << rhs;
        *self = F32x1(f32::from_bits(bits));
    }
}

impl ShlAssign<i32> for F64x1 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        let bits = self.0.to_bits() << rhs;
        *self = F64x1(f64::from_bits(bits));
    }
}

impl ShlAssign<i32> for I16x8 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        macro_rules! call {
            ($rhs:expr) => {
                *self = unsafe { I16x8(_mm_slli_epi16(self.0, $rhs)) }
            };
        }
        constify_imm8!(rhs, call)
    }
}

impl ShlAssign<i32> for I16x16 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        macro_rules! call {
            ($rhs:expr) => {
                *self = unsafe { I16x16(_mm256_slli_epi16(self.0, $rhs)) }
            };
        }
        constify_imm8!(rhs, call)
    }
}
impl ShlAssign<i32> for I32x4 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        macro_rules! call {
            ($rhs:expr) => {
                *self = unsafe { I32x4(_mm_slli_epi32(self.0, $rhs)) }
            };
        }
        constify_imm8!(rhs, call)
    }
}
impl ShlAssign<i32> for I32x4_41 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        macro_rules! call {
            ($rhs:expr) => {
                *self = unsafe { I32x4_41(_mm_slli_epi32(self.0, $rhs)) }
            };
        }
        constify_imm8!(rhs, call)
    }
}
impl ShlAssign<i32> for I32x8 {
    #[inline(always)]
    fn shl_assign(&mut self, rhs: i32) {
        macro_rules! call {
            ($rhs:expr) => {
                *self = unsafe { I32x8(_mm256_slli_epi32(self.0, $rhs)) }
            };
        }
        constify_imm8!(rhs, call)
    }
}