1 // compile-flags: -C no-prepopulate-passes
6 #![feature(repr_simd, platform_intrinsics)]
7 #![allow(non_camel_case_types)]
10 // signed integer types
12 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x2(i8, i8);
13 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x4(i8, i8, i8, i8);
14 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x8(
15 i8, i8, i8, i8, i8, i8, i8, i8,
17 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x16(
18 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
20 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x32(
21 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
22 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
24 #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x64(
25 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
26 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
27 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
28 i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8,
31 #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x2(i16, i16);
32 #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x4(i16, i16, i16, i16);
33 #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x8(
34 i16, i16, i16, i16, i16, i16, i16, i16,
36 #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x16(
37 i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16,
39 #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x32(
40 i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16,
41 i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16, i16,
44 #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x2(i32, i32);
45 #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x4(i32, i32, i32, i32);
46 #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x8(
47 i32, i32, i32, i32, i32, i32, i32, i32,
49 #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x16(
50 i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,
53 #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x2(i64, i64);
54 #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x4(i64, i64, i64, i64);
55 #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x8(
56 i64, i64, i64, i64, i64, i64, i64, i64,
59 #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x2(i128, i128);
60 #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x4(i128, i128, i128, i128);
62 // unsigned integer types
64 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x2(u8, u8);
65 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x4(u8, u8, u8, u8);
66 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x8(
67 u8, u8, u8, u8, u8, u8, u8, u8,
69 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x16(
70 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
72 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x32(
73 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
74 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
76 #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x64(
77 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
78 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
79 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
80 u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8,
83 #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x2(u16, u16);
84 #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x4(u16, u16, u16, u16);
85 #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x8(
86 u16, u16, u16, u16, u16, u16, u16, u16,
88 #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x16(
89 u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16,
91 #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x32(
92 u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16,
93 u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16, u16,
96 #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x2(u32, u32);
97 #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x4(u32, u32, u32, u32);
98 #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x8(
99 u32, u32, u32, u32, u32, u32, u32, u32,
101 #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x16(
102 u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32,
105 #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x2(u64, u64);
106 #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x4(u64, u64, u64, u64);
107 #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x8(
108 u64, u64, u64, u64, u64, u64, u64, u64,
111 #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x2(u128, u128);
112 #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x4(u128, u128, u128, u128);
114 extern "platform-intrinsic" {
115 fn simd_saturating_add<T>(x: T, y: T) -> T;
116 fn simd_saturating_sub<T>(x: T, y: T) -> T;
119 // NOTE(eddyb) `%{{x|_3}}` is used because on some targets (e.g. WASM)
120 // SIMD vectors are passed directly, resulting in `%x` being a vector,
121 // while on others they're passed indirectly, resulting in `%x` being
122 // a pointer to a vector, and `%_3` a vector loaded from that pointer.
123 // This is controlled by the target spec option `simd_types_indirect`.
124 // The same applies to `%{{y|_4}}` as well.
126 // CHECK-LABEL: @sadd_i8x2
128 pub unsafe fn sadd_i8x2(x: i8x2, y: i8x2) -> i8x2 {
129 // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
130 simd_saturating_add(x, y)
133 // CHECK-LABEL: @sadd_i8x4
135 pub unsafe fn sadd_i8x4(x: i8x4, y: i8x4) -> i8x4 {
136 // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.sadd.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
137 simd_saturating_add(x, y)
140 // CHECK-LABEL: @sadd_i8x8
142 pub unsafe fn sadd_i8x8(x: i8x8, y: i8x8) -> i8x8 {
143 // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.sadd.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
144 simd_saturating_add(x, y)
147 // CHECK-LABEL: @sadd_i8x16
149 pub unsafe fn sadd_i8x16(x: i8x16, y: i8x16) -> i8x16 {
150 // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
151 simd_saturating_add(x, y)
154 // CHECK-LABEL: @sadd_i8x32
156 pub unsafe fn sadd_i8x32(x: i8x32, y: i8x32) -> i8x32 {
157 // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
158 simd_saturating_add(x, y)
161 // CHECK-LABEL: @sadd_i8x64
163 pub unsafe fn sadd_i8x64(x: i8x64, y: i8x64) -> i8x64 {
164 // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.sadd.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
165 simd_saturating_add(x, y)
168 // CHECK-LABEL: @sadd_i16x2
170 pub unsafe fn sadd_i16x2(x: i16x2, y: i16x2) -> i16x2 {
171 // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.sadd.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
172 simd_saturating_add(x, y)
175 // CHECK-LABEL: @sadd_i16x4
177 pub unsafe fn sadd_i16x4(x: i16x4, y: i16x4) -> i16x4 {
178 // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.sadd.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
179 simd_saturating_add(x, y)
182 // CHECK-LABEL: @sadd_i16x8
184 pub unsafe fn sadd_i16x8(x: i16x8, y: i16x8) -> i16x8 {
185 // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
186 simd_saturating_add(x, y)
189 // CHECK-LABEL: @sadd_i16x16
191 pub unsafe fn sadd_i16x16(x: i16x16, y: i16x16) -> i16x16 {
192 // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
193 simd_saturating_add(x, y)
196 // CHECK-LABEL: @sadd_i16x32
198 pub unsafe fn sadd_i16x32(x: i16x32, y: i16x32) -> i16x32 {
199 // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.sadd.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
200 simd_saturating_add(x, y)
203 // CHECK-LABEL: @sadd_i32x2
205 pub unsafe fn sadd_i32x2(x: i32x2, y: i32x2) -> i32x2 {
206 // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.sadd.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
207 simd_saturating_add(x, y)
210 // CHECK-LABEL: @sadd_i32x4
212 pub unsafe fn sadd_i32x4(x: i32x4, y: i32x4) -> i32x4 {
213 // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.sadd.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
214 simd_saturating_add(x, y)
217 // CHECK-LABEL: @sadd_i32x8
219 pub unsafe fn sadd_i32x8(x: i32x8, y: i32x8) -> i32x8 {
220 // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
221 simd_saturating_add(x, y)
224 // CHECK-LABEL: @sadd_i32x16
226 pub unsafe fn sadd_i32x16(x: i32x16, y: i32x16) -> i32x16 {
227 // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.sadd.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
228 simd_saturating_add(x, y)
231 // CHECK-LABEL: @sadd_i64x2
233 pub unsafe fn sadd_i64x2(x: i64x2, y: i64x2) -> i64x2 {
234 // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.sadd.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
235 simd_saturating_add(x, y)
238 // CHECK-LABEL: @sadd_i64x4
240 pub unsafe fn sadd_i64x4(x: i64x4, y: i64x4) -> i64x4 {
241 // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.sadd.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
242 simd_saturating_add(x, y)
245 // CHECK-LABEL: @sadd_i64x8
247 pub unsafe fn sadd_i64x8(x: i64x8, y: i64x8) -> i64x8 {
248 // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.sadd.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
249 simd_saturating_add(x, y)
252 // CHECK-LABEL: @sadd_i128x2
254 pub unsafe fn sadd_i128x2(x: i128x2, y: i128x2) -> i128x2 {
255 // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.sadd.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
256 simd_saturating_add(x, y)
259 // CHECK-LABEL: @sadd_i128x4
261 pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
262 // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.sadd.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
263 simd_saturating_add(x, y)
268 // CHECK-LABEL: @uadd_u8x2
270 pub unsafe fn uadd_u8x2(x: u8x2, y: u8x2) -> u8x2 {
271 // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
272 simd_saturating_add(x, y)
275 // CHECK-LABEL: @uadd_u8x4
277 pub unsafe fn uadd_u8x4(x: u8x4, y: u8x4) -> u8x4 {
278 // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.uadd.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
279 simd_saturating_add(x, y)
282 // CHECK-LABEL: @uadd_u8x8
284 pub unsafe fn uadd_u8x8(x: u8x8, y: u8x8) -> u8x8 {
285 // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.uadd.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
286 simd_saturating_add(x, y)
289 // CHECK-LABEL: @uadd_u8x16
291 pub unsafe fn uadd_u8x16(x: u8x16, y: u8x16) -> u8x16 {
292 // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
293 simd_saturating_add(x, y)
296 // CHECK-LABEL: @uadd_u8x32
298 pub unsafe fn uadd_u8x32(x: u8x32, y: u8x32) -> u8x32 {
299 // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
300 simd_saturating_add(x, y)
303 // CHECK-LABEL: @uadd_u8x64
305 pub unsafe fn uadd_u8x64(x: u8x64, y: u8x64) -> u8x64 {
306 // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
307 simd_saturating_add(x, y)
310 // CHECK-LABEL: @uadd_u16x2
312 pub unsafe fn uadd_u16x2(x: u16x2, y: u16x2) -> u16x2 {
313 // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.uadd.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
314 simd_saturating_add(x, y)
317 // CHECK-LABEL: @uadd_u16x4
319 pub unsafe fn uadd_u16x4(x: u16x4, y: u16x4) -> u16x4 {
320 // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.uadd.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
321 simd_saturating_add(x, y)
324 // CHECK-LABEL: @uadd_u16x8
326 pub unsafe fn uadd_u16x8(x: u16x8, y: u16x8) -> u16x8 {
327 // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
328 simd_saturating_add(x, y)
331 // CHECK-LABEL: @uadd_u16x16
333 pub unsafe fn uadd_u16x16(x: u16x16, y: u16x16) -> u16x16 {
334 // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
335 simd_saturating_add(x, y)
338 // CHECK-LABEL: @uadd_u16x32
340 pub unsafe fn uadd_u16x32(x: u16x32, y: u16x32) -> u16x32 {
341 // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
342 simd_saturating_add(x, y)
345 // CHECK-LABEL: @uadd_u32x2
347 pub unsafe fn uadd_u32x2(x: u32x2, y: u32x2) -> u32x2 {
348 // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
349 simd_saturating_add(x, y)
352 // CHECK-LABEL: @uadd_u32x4
354 pub unsafe fn uadd_u32x4(x: u32x4, y: u32x4) -> u32x4 {
355 // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
356 simd_saturating_add(x, y)
359 // CHECK-LABEL: @uadd_u32x8
361 pub unsafe fn uadd_u32x8(x: u32x8, y: u32x8) -> u32x8 {
362 // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
363 simd_saturating_add(x, y)
366 // CHECK-LABEL: @uadd_u32x16
368 pub unsafe fn uadd_u32x16(x: u32x16, y: u32x16) -> u32x16 {
369 // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.uadd.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
370 simd_saturating_add(x, y)
373 // CHECK-LABEL: @uadd_u64x2
375 pub unsafe fn uadd_u64x2(x: u64x2, y: u64x2) -> u64x2 {
376 // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
377 simd_saturating_add(x, y)
380 // CHECK-LABEL: @uadd_u64x4
382 pub unsafe fn uadd_u64x4(x: u64x4, y: u64x4) -> u64x4 {
383 // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.uadd.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
384 simd_saturating_add(x, y)
387 // CHECK-LABEL: @uadd_u64x8
389 pub unsafe fn uadd_u64x8(x: u64x8, y: u64x8) -> u64x8 {
390 // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.uadd.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
391 simd_saturating_add(x, y)
394 // CHECK-LABEL: @uadd_u128x2
396 pub unsafe fn uadd_u128x2(x: u128x2, y: u128x2) -> u128x2 {
397 // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.uadd.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
398 simd_saturating_add(x, y)
401 // CHECK-LABEL: @uadd_u128x4
403 pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
404 // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.uadd.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
405 simd_saturating_add(x, y)
412 // CHECK-LABEL: @ssub_i8x2
414 pub unsafe fn ssub_i8x2(x: i8x2, y: i8x2) -> i8x2 {
415 // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
416 simd_saturating_sub(x, y)
419 // CHECK-LABEL: @ssub_i8x4
421 pub unsafe fn ssub_i8x4(x: i8x4, y: i8x4) -> i8x4 {
422 // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.ssub.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
423 simd_saturating_sub(x, y)
426 // CHECK-LABEL: @ssub_i8x8
428 pub unsafe fn ssub_i8x8(x: i8x8, y: i8x8) -> i8x8 {
429 // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.ssub.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
430 simd_saturating_sub(x, y)
433 // CHECK-LABEL: @ssub_i8x16
435 pub unsafe fn ssub_i8x16(x: i8x16, y: i8x16) -> i8x16 {
436 // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
437 simd_saturating_sub(x, y)
440 // CHECK-LABEL: @ssub_i8x32
442 pub unsafe fn ssub_i8x32(x: i8x32, y: i8x32) -> i8x32 {
443 // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
444 simd_saturating_sub(x, y)
447 // CHECK-LABEL: @ssub_i8x64
449 pub unsafe fn ssub_i8x64(x: i8x64, y: i8x64) -> i8x64 {
450 // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.ssub.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
451 simd_saturating_sub(x, y)
454 // CHECK-LABEL: @ssub_i16x2
456 pub unsafe fn ssub_i16x2(x: i16x2, y: i16x2) -> i16x2 {
457 // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.ssub.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
458 simd_saturating_sub(x, y)
461 // CHECK-LABEL: @ssub_i16x4
463 pub unsafe fn ssub_i16x4(x: i16x4, y: i16x4) -> i16x4 {
464 // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.ssub.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
465 simd_saturating_sub(x, y)
468 // CHECK-LABEL: @ssub_i16x8
470 pub unsafe fn ssub_i16x8(x: i16x8, y: i16x8) -> i16x8 {
471 // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
472 simd_saturating_sub(x, y)
475 // CHECK-LABEL: @ssub_i16x16
477 pub unsafe fn ssub_i16x16(x: i16x16, y: i16x16) -> i16x16 {
478 // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
479 simd_saturating_sub(x, y)
482 // CHECK-LABEL: @ssub_i16x32
484 pub unsafe fn ssub_i16x32(x: i16x32, y: i16x32) -> i16x32 {
485 // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.ssub.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
486 simd_saturating_sub(x, y)
489 // CHECK-LABEL: @ssub_i32x2
491 pub unsafe fn ssub_i32x2(x: i32x2, y: i32x2) -> i32x2 {
492 // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.ssub.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
493 simd_saturating_sub(x, y)
496 // CHECK-LABEL: @ssub_i32x4
498 pub unsafe fn ssub_i32x4(x: i32x4, y: i32x4) -> i32x4 {
499 // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
500 simd_saturating_sub(x, y)
503 // CHECK-LABEL: @ssub_i32x8
505 pub unsafe fn ssub_i32x8(x: i32x8, y: i32x8) -> i32x8 {
506 // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
507 simd_saturating_sub(x, y)
510 // CHECK-LABEL: @ssub_i32x16
512 pub unsafe fn ssub_i32x16(x: i32x16, y: i32x16) -> i32x16 {
513 // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.ssub.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
514 simd_saturating_sub(x, y)
517 // CHECK-LABEL: @ssub_i64x2
519 pub unsafe fn ssub_i64x2(x: i64x2, y: i64x2) -> i64x2 {
520 // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ssub.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
521 simd_saturating_sub(x, y)
524 // CHECK-LABEL: @ssub_i64x4
526 pub unsafe fn ssub_i64x4(x: i64x4, y: i64x4) -> i64x4 {
527 // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.ssub.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
528 simd_saturating_sub(x, y)
531 // CHECK-LABEL: @ssub_i64x8
533 pub unsafe fn ssub_i64x8(x: i64x8, y: i64x8) -> i64x8 {
534 // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.ssub.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
535 simd_saturating_sub(x, y)
538 // CHECK-LABEL: @ssub_i128x2
540 pub unsafe fn ssub_i128x2(x: i128x2, y: i128x2) -> i128x2 {
541 // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.ssub.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
542 simd_saturating_sub(x, y)
545 // CHECK-LABEL: @ssub_i128x4
547 pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
548 // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.ssub.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
549 simd_saturating_sub(x, y)
554 // CHECK-LABEL: @usub_u8x2
556 pub unsafe fn usub_u8x2(x: u8x2, y: u8x2) -> u8x2 {
557 // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
558 simd_saturating_sub(x, y)
561 // CHECK-LABEL: @usub_u8x4
563 pub unsafe fn usub_u8x4(x: u8x4, y: u8x4) -> u8x4 {
564 // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.usub.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
565 simd_saturating_sub(x, y)
568 // CHECK-LABEL: @usub_u8x8
570 pub unsafe fn usub_u8x8(x: u8x8, y: u8x8) -> u8x8 {
571 // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.usub.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
572 simd_saturating_sub(x, y)
575 // CHECK-LABEL: @usub_u8x16
577 pub unsafe fn usub_u8x16(x: u8x16, y: u8x16) -> u8x16 {
578 // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
579 simd_saturating_sub(x, y)
582 // CHECK-LABEL: @usub_u8x32
584 pub unsafe fn usub_u8x32(x: u8x32, y: u8x32) -> u8x32 {
585 // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
586 simd_saturating_sub(x, y)
589 // CHECK-LABEL: @usub_u8x64
591 pub unsafe fn usub_u8x64(x: u8x64, y: u8x64) -> u8x64 {
592 // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
593 simd_saturating_sub(x, y)
596 // CHECK-LABEL: @usub_u16x2
598 pub unsafe fn usub_u16x2(x: u16x2, y: u16x2) -> u16x2 {
599 // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
600 simd_saturating_sub(x, y)
603 // CHECK-LABEL: @usub_u16x4
605 pub unsafe fn usub_u16x4(x: u16x4, y: u16x4) -> u16x4 {
606 // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.usub.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
607 simd_saturating_sub(x, y)
610 // CHECK-LABEL: @usub_u16x8
612 pub unsafe fn usub_u16x8(x: u16x8, y: u16x8) -> u16x8 {
613 // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
614 simd_saturating_sub(x, y)
617 // CHECK-LABEL: @usub_u16x16
619 pub unsafe fn usub_u16x16(x: u16x16, y: u16x16) -> u16x16 {
620 // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
621 simd_saturating_sub(x, y)
624 // CHECK-LABEL: @usub_u16x32
626 pub unsafe fn usub_u16x32(x: u16x32, y: u16x32) -> u16x32 {
627 // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
628 simd_saturating_sub(x, y)
631 // CHECK-LABEL: @usub_u32x2
633 pub unsafe fn usub_u32x2(x: u32x2, y: u32x2) -> u32x2 {
634 // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
635 simd_saturating_sub(x, y)
638 // CHECK-LABEL: @usub_u32x4
640 pub unsafe fn usub_u32x4(x: u32x4, y: u32x4) -> u32x4 {
641 // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
642 simd_saturating_sub(x, y)
645 // CHECK-LABEL: @usub_u32x8
647 pub unsafe fn usub_u32x8(x: u32x8, y: u32x8) -> u32x8 {
648 // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
649 simd_saturating_sub(x, y)
652 // CHECK-LABEL: @usub_u32x16
654 pub unsafe fn usub_u32x16(x: u32x16, y: u32x16) -> u32x16 {
655 // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.usub.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
656 simd_saturating_sub(x, y)
659 // CHECK-LABEL: @usub_u64x2
661 pub unsafe fn usub_u64x2(x: u64x2, y: u64x2) -> u64x2 {
662 // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
663 simd_saturating_sub(x, y)
666 // CHECK-LABEL: @usub_u64x4
668 pub unsafe fn usub_u64x4(x: u64x4, y: u64x4) -> u64x4 {
669 // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.usub.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
670 simd_saturating_sub(x, y)
673 // CHECK-LABEL: @usub_u64x8
675 pub unsafe fn usub_u64x8(x: u64x8, y: u64x8) -> u64x8 {
676 // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.usub.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
677 simd_saturating_sub(x, y)
680 // CHECK-LABEL: @usub_u128x2
682 pub unsafe fn usub_u128x2(x: u128x2, y: u128x2) -> u128x2 {
683 // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.usub.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
684 simd_saturating_sub(x, y)
687 // CHECK-LABEL: @usub_u128x4
689 pub unsafe fn usub_u128x4(x: u128x4, y: u128x4) -> u128x4 {
690 // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.usub.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
691 simd_saturating_sub(x, y)