miri/shims/x86/
ssse3.rs

1use rustc_abi::CanonAbi;
2use rustc_middle::mir;
3use rustc_middle::ty::Ty;
4use rustc_span::Symbol;
5use rustc_target::callconv::FnAbi;
6
7use super::{horizontal_bin_op, pmulhrsw, psign};
8use crate::*;
9
10impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
11pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
12    fn emulate_x86_ssse3_intrinsic(
13        &mut self,
14        link_name: Symbol,
15        abi: &FnAbi<'tcx, Ty<'tcx>>,
16        args: &[OpTy<'tcx>],
17        dest: &MPlaceTy<'tcx>,
18    ) -> InterpResult<'tcx, EmulateItemResult> {
19        let this = self.eval_context_mut();
20        this.expect_target_feature_for_intrinsic(link_name, "ssse3")?;
21        // Prefix should have already been checked.
22        let unprefixed_name = link_name.as_str().strip_prefix("llvm.x86.ssse3.").unwrap();
23
24        match unprefixed_name {
25            // Used to implement the _mm_shuffle_epi8 intrinsic.
26            // Shuffles bytes from `left` using `right` as pattern.
27            // https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_shuffle_epi8
28            "pshuf.b.128" => {
29                let [left, right] =
30                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
31
32                let (left, left_len) = this.project_to_simd(left)?;
33                let (right, right_len) = this.project_to_simd(right)?;
34                let (dest, dest_len) = this.project_to_simd(dest)?;
35
36                assert_eq!(dest_len, left_len);
37                assert_eq!(dest_len, right_len);
38
39                for i in 0..dest_len {
40                    let right = this.read_scalar(&this.project_index(&right, i)?)?.to_u8()?;
41                    let dest = this.project_index(&dest, i)?;
42
43                    let res = if right & 0x80 == 0 {
44                        let j = right % 16; // index wraps around
45                        this.read_scalar(&this.project_index(&left, j.into())?)?
46                    } else {
47                        // If the highest bit in `right` is 1, write zero.
48                        Scalar::from_u8(0)
49                    };
50
51                    this.write_scalar(res, &dest)?;
52                }
53            }
54            // Used to implement the _mm_h{adds,subs}_epi16 functions.
55            // Horizontally add / subtract with saturation adjacent 16-bit
56            // integer values in `left` and `right`.
57            "phadd.sw.128" | "phsub.sw.128" => {
58                let [left, right] =
59                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
60
61                let which = match unprefixed_name {
62                    "phadd.sw.128" => mir::BinOp::Add,
63                    "phsub.sw.128" => mir::BinOp::Sub,
64                    _ => unreachable!(),
65                };
66
67                horizontal_bin_op(this, which, /*saturating*/ true, left, right, dest)?;
68            }
69            // Used to implement the _mm_maddubs_epi16 function.
70            // Multiplies packed 8-bit unsigned integers from `left` and packed
71            // signed 8-bit integers from `right` into 16-bit signed integers. Then,
72            // the saturating sum of the products with indices `2*i` and `2*i+1`
73            // produces the output at index `i`.
74            // https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_maddubs_epi16
75            "pmadd.ub.sw.128" => {
76                let [left, right] =
77                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
78
79                let (left, left_len) = this.project_to_simd(left)?;
80                let (right, right_len) = this.project_to_simd(right)?;
81                let (dest, dest_len) = this.project_to_simd(dest)?;
82
83                assert_eq!(left_len, right_len);
84                assert_eq!(dest_len.strict_mul(2), left_len);
85
86                for i in 0..dest_len {
87                    let j1 = i.strict_mul(2);
88                    let left1 = this.read_scalar(&this.project_index(&left, j1)?)?.to_u8()?;
89                    let right1 = this.read_scalar(&this.project_index(&right, j1)?)?.to_i8()?;
90
91                    let j2 = j1.strict_add(1);
92                    let left2 = this.read_scalar(&this.project_index(&left, j2)?)?.to_u8()?;
93                    let right2 = this.read_scalar(&this.project_index(&right, j2)?)?.to_i8()?;
94
95                    let dest = this.project_index(&dest, i)?;
96
97                    // Multiplication of a u8 and an i8 into an i16 cannot overflow.
98                    let mul1 = i16::from(left1).strict_mul(right1.into());
99                    let mul2 = i16::from(left2).strict_mul(right2.into());
100                    let res = mul1.saturating_add(mul2);
101
102                    this.write_scalar(Scalar::from_i16(res), &dest)?;
103                }
104            }
105            // Used to implement the _mm_mulhrs_epi16 function.
106            // Multiplies packed 16-bit signed integer values, truncates the 32-bit
107            // product to the 18 most significant bits by right-shifting, and then
108            // divides the 18-bit value by 2 (rounding to nearest) by first adding
109            // 1 and then taking the bits `1..=16`.
110            // https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_mulhrs_epi16
111            "pmul.hr.sw.128" => {
112                let [left, right] =
113                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
114
115                pmulhrsw(this, left, right, dest)?;
116            }
117            // Used to implement the _mm_sign_epi{8,16,32} functions.
118            // Negates elements from `left` when the corresponding element in
119            // `right` is negative. If an element from `right` is zero, zero
120            // is writen to the corresponding output element.
121            // Basically, we multiply `left` with `right.signum()`.
122            "psign.b.128" | "psign.w.128" | "psign.d.128" => {
123                let [left, right] =
124                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
125
126                psign(this, left, right, dest)?;
127            }
128            _ => return interp_ok(EmulateItemResult::NotSupported),
129        }
130        interp_ok(EmulateItemResult::NeedsReturn)
131    }
132}
miri/shims/x86/ssse3.rs

miri/shims/x86/
ssse3.rs
