Clang Project

clang_source_code/test/CodeGen/sse2-builtins.c
1// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Wall -Werror | FileCheck %s
2// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
3// RUN: %clang_cc1 -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +sse2 -emit-llvm -o - -Wall -Werror | FileCheck %s
4
5
6#include <immintrin.h>
7
8// NOTE: This should match the tests in llvm/test/CodeGen/X86/sse2-intrinsics-fast-isel.ll
9
10__m128i test_mm_add_epi8(__m128i A, __m128i B) {
11  // CHECK-LABEL: test_mm_add_epi8
12  // CHECK: add <16 x i8>
13  return _mm_add_epi8(A, B);
14}
15
16__m128i test_mm_add_epi16(__m128i A, __m128i B) {
17  // CHECK-LABEL: test_mm_add_epi16
18  // CHECK: add <8 x i16>
19  return _mm_add_epi16(A, B);
20}
21
22__m128i test_mm_add_epi32(__m128i A, __m128i B) {
23  // CHECK-LABEL: test_mm_add_epi32
24  // CHECK: add <4 x i32>
25  return _mm_add_epi32(A, B);
26}
27
28__m128i test_mm_add_epi64(__m128i A, __m128i B) {
29  // CHECK-LABEL: test_mm_add_epi64
30  // CHECK: add <2 x i64>
31  return _mm_add_epi64(A, B);
32}
33
34__m128d test_mm_add_pd(__m128d A, __m128d B) {
35  // CHECK-LABEL: test_mm_add_pd
36  // CHECK: fadd <2 x double>
37  return _mm_add_pd(A, B);
38}
39
40__m128d test_mm_add_sd(__m128d A, __m128d B) {
41  // CHECK-LABEL: test_mm_add_sd
42  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
43  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
44  // CHECK: fadd double
45  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
46  return _mm_add_sd(A, B);
47}
48
49__m128i test_mm_adds_epi8(__m128i A, __m128i B) {
50  // CHECK-LABEL: test_mm_adds_epi8
51  // CHECK: call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
52  return _mm_adds_epi8(A, B);
53}
54
55__m128i test_mm_adds_epi16(__m128i A, __m128i B) {
56  // CHECK-LABEL: test_mm_adds_epi16
57  // CHECK: call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
58  return _mm_adds_epi16(A, B);
59}
60
61__m128i test_mm_adds_epu8(__m128i A, __m128i B) {
62  // CHECK-LABEL: test_mm_adds_epu8
63  // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
64  // CHECK: call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
65  return _mm_adds_epu8(A, B);
66}
67
68__m128i test_mm_adds_epu16(__m128i A, __m128i B) {
69  // CHECK-LABEL: test_mm_adds_epu16
70  // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
71  // CHECK: call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
72  return _mm_adds_epu16(A, B);
73}
74
75__m128d test_mm_and_pd(__m128d A, __m128d B) {
76  // CHECK-LABEL: test_mm_and_pd
77  // CHECK: and <2 x i64>
78  return _mm_and_pd(A, B);
79}
80
81__m128i test_mm_and_si128(__m128i A, __m128i B) {
82  // CHECK-LABEL: test_mm_and_si128
83  // CHECK: and <2 x i64>
84  return _mm_and_si128(A, B);
85}
86
87__m128d test_mm_andnot_pd(__m128d A, __m128d B) {
88  // CHECK-LABEL: test_mm_andnot_pd
89  // CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
90  // CHECK: and <2 x i64>
91  return _mm_andnot_pd(A, B);
92}
93
94__m128i test_mm_andnot_si128(__m128i A, __m128i B) {
95  // CHECK-LABEL: test_mm_andnot_si128
96  // CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
97  // CHECK: and <2 x i64>
98  return _mm_andnot_si128(A, B);
99}
100
101__m128i test_mm_avg_epu8(__m128i A, __m128i B) {
102  // CHECK-LABEL: test_mm_avg_epu8
103  // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.pavg.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
104  // CHECK: zext <16 x i8> %{{.*}} to <16 x i16>
105  // CHECK: zext <16 x i8> %{{.*}} to <16 x i16>
106  // CHECK: add <16 x i16> %{{.*}}, %{{.*}}
107  // CHECK: add <16 x i16> %{{.*}}, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
108  // CHECK: lshr <16 x i16> %{{.*}}, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
109  // CHECK:trunc <16 x i16> %{{.*}} to <16 x i8>
110  return _mm_avg_epu8(A, B);
111}
112
113__m128i test_mm_avg_epu16(__m128i A, __m128i B) {
114  // CHECK-LABEL: test_mm_avg_epu16
115  // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.pavg.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
116  // CHECK: zext <8 x i16> %{{.*}} to <8 x i32>
117  // CHECK: zext <8 x i16> %{{.*}} to <8 x i32>
118  // CHECK: add <8 x i32> %{{.*}}, %{{.*}}
119  // CHECK: add <8 x i32> %{{.*}}, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
120  // CHECK: lshr <8 x i32> %{{.*}}, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
121  // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16>
122  return _mm_avg_epu16(A, B);
123}
124
125__m128i test_mm_bslli_si128(__m128i A) {
126  // CHECK-LABEL: test_mm_bslli_si128
127  // CHECK: shufflevector <16 x i8> zeroinitializer, <16 x i8> %{{.*}}, <16 x i32> <i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26>
128  return _mm_bslli_si128(A, 5);
129}
130
131__m128i test_mm_bsrli_si128(__m128i A) {
132  // CHECK-LABEL: test_mm_bsrli_si128
133  // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> zeroinitializer, <16 x i32> <i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20>
134  return _mm_bsrli_si128(A, 5);
135}
136
137__m128 test_mm_castpd_ps(__m128d A) {
138  // CHECK-LABEL: test_mm_castpd_ps
139  // CHECK: bitcast <2 x double> %{{.*}} to <4 x float>
140  return _mm_castpd_ps(A);
141}
142
143__m128i test_mm_castpd_si128(__m128d A) {
144  // CHECK-LABEL: test_mm_castpd_si128
145  // CHECK: bitcast <2 x double> %{{.*}} to <2 x i64>
146  return _mm_castpd_si128(A);
147}
148
149__m128d test_mm_castps_pd(__m128 A) {
150  // CHECK-LABEL: test_mm_castps_pd
151  // CHECK: bitcast <4 x float> %{{.*}} to <2 x double>
152  return _mm_castps_pd(A);
153}
154
155__m128i test_mm_castps_si128(__m128 A) {
156  // CHECK-LABEL: test_mm_castps_si128
157  // CHECK: bitcast <4 x float> %{{.*}} to <2 x i64>
158  return _mm_castps_si128(A);
159}
160
161__m128d test_mm_castsi128_pd(__m128i A) {
162  // CHECK-LABEL: test_mm_castsi128_pd
163  // CHECK: bitcast <2 x i64> %{{.*}} to <2 x double>
164  return _mm_castsi128_pd(A);
165}
166
167__m128 test_mm_castsi128_ps(__m128i A) {
168  // CHECK-LABEL: test_mm_castsi128_ps
169  // CHECK: bitcast <2 x i64> %{{.*}} to <4 x float>
170  return _mm_castsi128_ps(A);
171}
172
173void test_mm_clflush(void* A) {
174  // CHECK-LABEL: test_mm_clflush
175  // CHECK: call void @llvm.x86.sse2.clflush(i8* %{{.*}})
176  _mm_clflush(A);
177}
178
179__m128i test_mm_cmpeq_epi8(__m128i A, __m128i B) {
180  // CHECK-LABEL: test_mm_cmpeq_epi8
181  // CHECK: icmp eq <16 x i8>
182  return _mm_cmpeq_epi8(A, B);
183}
184
185__m128i test_mm_cmpeq_epi16(__m128i A, __m128i B) {
186  // CHECK-LABEL: test_mm_cmpeq_epi16
187  // CHECK: icmp eq <8 x i16>
188  return _mm_cmpeq_epi16(A, B);
189}
190
191__m128i test_mm_cmpeq_epi32(__m128i A, __m128i B) {
192  // CHECK-LABEL: test_mm_cmpeq_epi32
193  // CHECK: icmp eq <4 x i32>
194  return _mm_cmpeq_epi32(A, B);
195}
196
197__m128d test_mm_cmpeq_pd(__m128d A, __m128d B) {
198  // CHECK-LABEL: test_mm_cmpeq_pd
199  // CHECK:         [[CMP:%.*]] = fcmp oeq <2 x double>
200  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
201  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
202  // CHECK-NEXT:    ret <2 x double> [[BC]]
203  return _mm_cmpeq_pd(A, B);
204}
205
206__m128d test_mm_cmpeq_sd(__m128d A, __m128d B) {
207  // CHECK-LABEL: test_mm_cmpeq_sd
208  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0)
209  return _mm_cmpeq_sd(A, B);
210}
211
212__m128d test_mm_cmpge_pd(__m128d A, __m128d B) {
213  // CHECK-LABEL: test_mm_cmpge_pd
214  // CHECK:         [[CMP:%.*]] = fcmp ole <2 x double>
215  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
216  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
217  // CHECK-NEXT:    ret <2 x double> [[BC]]
218  return _mm_cmpge_pd(A, B);
219}
220
221__m128d test_mm_cmpge_sd(__m128d A, __m128d B) {
222  // CHECK-LABEL: test_mm_cmpge_sd
223  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2)
224  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
225  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
226  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
227  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
228  return _mm_cmpge_sd(A, B);
229}
230
231__m128i test_mm_cmpgt_epi8(__m128i A, __m128i B) {
232  // CHECK-LABEL: test_mm_cmpgt_epi8
233  // CHECK: icmp sgt <16 x i8>
234  return _mm_cmpgt_epi8(A, B);
235}
236
237__m128i test_mm_cmpgt_epi16(__m128i A, __m128i B) {
238  // CHECK-LABEL: test_mm_cmpgt_epi16
239  // CHECK: icmp sgt <8 x i16>
240  return _mm_cmpgt_epi16(A, B);
241}
242
243__m128i test_mm_cmpgt_epi32(__m128i A, __m128i B) {
244  // CHECK-LABEL: test_mm_cmpgt_epi32
245  // CHECK: icmp sgt <4 x i32>
246  return _mm_cmpgt_epi32(A, B);
247}
248
249__m128d test_mm_cmpgt_pd(__m128d A, __m128d B) {
250  // CHECK-LABEL: test_mm_cmpgt_pd
251  // CHECK:         [[CMP:%.*]] = fcmp olt <2 x double>
252  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
253  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
254  // CHECK-NEXT:    ret <2 x double> [[BC]]
255  return _mm_cmpgt_pd(A, B);
256}
257
258__m128d test_mm_cmpgt_sd(__m128d A, __m128d B) {
259  // CHECK-LABEL: test_mm_cmpgt_sd
260  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1)
261  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
262  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
263  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
264  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
265  return _mm_cmpgt_sd(A, B);
266}
267
268__m128d test_mm_cmple_pd(__m128d A, __m128d B) {
269  // CHECK-LABEL: test_mm_cmple_pd
270  // CHECK:         [[CMP:%.*]] = fcmp ole <2 x double>
271  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
272  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
273  // CHECK-NEXT:    ret <2 x double> [[BC]]
274  return _mm_cmple_pd(A, B);
275}
276
277__m128d test_mm_cmple_sd(__m128d A, __m128d B) {
278  // CHECK-LABEL: test_mm_cmple_sd
279  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2)
280  return _mm_cmple_sd(A, B);
281}
282
283__m128i test_mm_cmplt_epi8(__m128i A, __m128i B) {
284  // CHECK-LABEL: test_mm_cmplt_epi8
285  // CHECK: icmp sgt <16 x i8>
286  return _mm_cmplt_epi8(A, B);
287}
288
289__m128i test_mm_cmplt_epi16(__m128i A, __m128i B) {
290  // CHECK-LABEL: test_mm_cmplt_epi16
291  // CHECK: icmp sgt <8 x i16>
292  return _mm_cmplt_epi16(A, B);
293}
294
295__m128i test_mm_cmplt_epi32(__m128i A, __m128i B) {
296  // CHECK-LABEL: test_mm_cmplt_epi32
297  // CHECK: icmp sgt <4 x i32>
298  return _mm_cmplt_epi32(A, B);
299}
300
301__m128d test_mm_cmplt_pd(__m128d A, __m128d B) {
302  // CHECK-LABEL: test_mm_cmplt_pd
303  // CHECK:         [[CMP:%.*]] = fcmp olt <2 x double>
304  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
305  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
306  // CHECK-NEXT:    ret <2 x double> [[BC]]
307  return _mm_cmplt_pd(A, B);
308}
309
310__m128d test_mm_cmplt_sd(__m128d A, __m128d B) {
311  // CHECK-LABEL: test_mm_cmplt_sd
312  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1)
313  return _mm_cmplt_sd(A, B);
314}
315
316__m128d test_mm_cmpneq_pd(__m128d A, __m128d B) {
317  // CHECK-LABEL: test_mm_cmpneq_pd
318  // CHECK:         [[CMP:%.*]] = fcmp une <2 x double>
319  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
320  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
321  // CHECK-NEXT:    ret <2 x double> [[BC]]
322  return _mm_cmpneq_pd(A, B);
323}
324
325__m128d test_mm_cmpneq_sd(__m128d A, __m128d B) {
326  // CHECK-LABEL: test_mm_cmpneq_sd
327  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4)
328  return _mm_cmpneq_sd(A, B);
329}
330
331__m128d test_mm_cmpnge_pd(__m128d A, __m128d B) {
332  // CHECK-LABEL: test_mm_cmpnge_pd
333  // CHECK:         [[CMP:%.*]] = fcmp ugt <2 x double>
334  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
335  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
336  // CHECK-NEXT:    ret <2 x double> [[BC]]
337  return _mm_cmpnge_pd(A, B);
338}
339
340__m128d test_mm_cmpnge_sd(__m128d A, __m128d B) {
341  // CHECK-LABEL: test_mm_cmpnge_sd
342  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6)
343  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
344  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
345  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
346  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
347  return _mm_cmpnge_sd(A, B);
348}
349
350__m128d test_mm_cmpngt_pd(__m128d A, __m128d B) {
351  // CHECK-LABEL: test_mm_cmpngt_pd
352  // CHECK:         [[CMP:%.*]] = fcmp uge <2 x double>
353  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
354  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
355  // CHECK-NEXT:    ret <2 x double> [[BC]]
356  return _mm_cmpngt_pd(A, B);
357}
358
359__m128d test_mm_cmpngt_sd(__m128d A, __m128d B) {
360  // CHECK-LABEL: test_mm_cmpngt_sd
361  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5)
362  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
363  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
364  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
365  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
366  return _mm_cmpngt_sd(A, B);
367}
368
369__m128d test_mm_cmpnle_pd(__m128d A, __m128d B) {
370  // CHECK-LABEL: test_mm_cmpnle_pd
371  // CHECK:         [[CMP:%.*]] = fcmp ugt <2 x double>
372  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
373  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
374  // CHECK-NEXT:    ret <2 x double> [[BC]]
375  return _mm_cmpnle_pd(A, B);
376}
377
378__m128d test_mm_cmpnle_sd(__m128d A, __m128d B) {
379  // CHECK-LABEL: test_mm_cmpnle_sd
380  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6)
381  return _mm_cmpnle_sd(A, B);
382}
383
384__m128d test_mm_cmpnlt_pd(__m128d A, __m128d B) {
385  // CHECK-LABEL: test_mm_cmpnlt_pd
386  // CHECK:         [[CMP:%.*]] = fcmp uge <2 x double>
387  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
388  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
389  // CHECK-NEXT:    ret <2 x double> [[BC]]
390  return _mm_cmpnlt_pd(A, B);
391}
392
393__m128d test_mm_cmpnlt_sd(__m128d A, __m128d B) {
394  // CHECK-LABEL: test_mm_cmpnlt_sd
395  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5)
396  return _mm_cmpnlt_sd(A, B);
397}
398
399__m128d test_mm_cmpord_pd(__m128d A, __m128d B) {
400  // CHECK-LABEL: test_mm_cmpord_pd
401  // CHECK:         [[CMP:%.*]] = fcmp ord <2 x double>
402  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
403  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
404  // CHECK-NEXT:    ret <2 x double> [[BC]]
405  return _mm_cmpord_pd(A, B);
406}
407
408__m128d test_mm_cmpord_sd(__m128d A, __m128d B) {
409  // CHECK-LABEL: test_mm_cmpord_sd
410  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7)
411  return _mm_cmpord_sd(A, B);
412}
413
414__m128d test_mm_cmpunord_pd(__m128d A, __m128d B) {
415  // CHECK-LABEL: test_mm_cmpunord_pd
416  // CHECK:         [[CMP:%.*]] = fcmp uno <2 x double>
417  // CHECK-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
418  // CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
419  // CHECK-NEXT:    ret <2 x double> [[BC]]
420  return _mm_cmpunord_pd(A, B);
421}
422
423__m128d test_mm_cmpunord_sd(__m128d A, __m128d B) {
424  // CHECK-LABEL: test_mm_cmpunord_sd
425  // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3)
426  return _mm_cmpunord_sd(A, B);
427}
428
429int test_mm_comieq_sd(__m128d A, __m128d B) {
430  // CHECK-LABEL: test_mm_comieq_sd
431  // CHECK: call i32 @llvm.x86.sse2.comieq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
432  return _mm_comieq_sd(A, B);
433}
434
435int test_mm_comige_sd(__m128d A, __m128d B) {
436  // CHECK-LABEL: test_mm_comige_sd
437  // CHECK: call i32 @llvm.x86.sse2.comige.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
438  return _mm_comige_sd(A, B);
439}
440
441int test_mm_comigt_sd(__m128d A, __m128d B) {
442  // CHECK-LABEL: test_mm_comigt_sd
443  // CHECK: call i32 @llvm.x86.sse2.comigt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
444  return _mm_comigt_sd(A, B);
445}
446
447int test_mm_comile_sd(__m128d A, __m128d B) {
448  // CHECK-LABEL: test_mm_comile_sd
449  // CHECK: call i32 @llvm.x86.sse2.comile.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
450  return _mm_comile_sd(A, B);
451}
452
453int test_mm_comilt_sd(__m128d A, __m128d B) {
454  // CHECK-LABEL: test_mm_comilt_sd
455  // CHECK: call i32 @llvm.x86.sse2.comilt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
456  return _mm_comilt_sd(A, B);
457}
458
459int test_mm_comineq_sd(__m128d A, __m128d B) {
460  // CHECK-LABEL: test_mm_comineq_sd
461  // CHECK: call i32 @llvm.x86.sse2.comineq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
462  return _mm_comineq_sd(A, B);
463}
464
465__m128d test_mm_cvtepi32_pd(__m128i A) {
466  // CHECK-LABEL: test_mm_cvtepi32_pd
467  // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <2 x i32> <i32 0, i32 1>
468  // CHECK: sitofp <2 x i32> %{{.*}} to <2 x double>
469  return _mm_cvtepi32_pd(A);
470}
471
472__m128 test_mm_cvtepi32_ps(__m128i A) {
473  // CHECK-LABEL: test_mm_cvtepi32_ps
474  // CHECK: sitofp <4 x i32> %{{.*}} to <4 x float>
475  return _mm_cvtepi32_ps(A);
476}
477
478__m128i test_mm_cvtpd_epi32(__m128d A) {
479  // CHECK-LABEL: test_mm_cvtpd_epi32
480  // CHECK: call <4 x i32> @llvm.x86.sse2.cvtpd2dq(<2 x double> %{{.*}})
481  return _mm_cvtpd_epi32(A);
482}
483
484__m128 test_mm_cvtpd_ps(__m128d A) {
485  // CHECK-LABEL: test_mm_cvtpd_ps
486  // CHECK: call <4 x float> @llvm.x86.sse2.cvtpd2ps(<2 x double> %{{.*}})
487  return _mm_cvtpd_ps(A);
488}
489
490__m128i test_mm_cvtps_epi32(__m128 A) {
491  // CHECK-LABEL: test_mm_cvtps_epi32
492  // CHECK: call <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float> %{{.*}})
493  return _mm_cvtps_epi32(A);
494}
495
496__m128d test_mm_cvtps_pd(__m128 A) {
497  // CHECK-LABEL: test_mm_cvtps_pd
498  // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <2 x i32> <i32 0, i32 1>
499  // CHECK: fpext <2 x float> %{{.*}} to <2 x double>
500  return _mm_cvtps_pd(A);
501}
502
503double test_mm_cvtsd_f64(__m128d A) {
504  // CHECK-LABEL: test_mm_cvtsd_f64
505  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
506  return _mm_cvtsd_f64(A);
507}
508
509int test_mm_cvtsd_si32(__m128d A) {
510  // CHECK-LABEL: test_mm_cvtsd_si32
511  // CHECK: call i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %{{.*}})
512  return _mm_cvtsd_si32(A);
513}
514
515long long test_mm_cvtsd_si64(__m128d A) {
516  // CHECK-LABEL: test_mm_cvtsd_si64
517  // CHECK: call i64 @llvm.x86.sse2.cvtsd2si64(<2 x double> %{{.*}})
518  return _mm_cvtsd_si64(A);
519}
520
521__m128 test_mm_cvtsd_ss(__m128 A, __m128d B) {
522  // CHECK-LABEL: test_mm_cvtsd_ss
523  // CHECK: call <4 x float> @llvm.x86.sse2.cvtsd2ss(<4 x float> %{{.*}}, <2 x double> %{{.*}})
524  return _mm_cvtsd_ss(A, B);
525}
526
527int test_mm_cvtsi128_si32(__m128i A) {
528  // CHECK-LABEL: test_mm_cvtsi128_si32
529  // CHECK: extractelement <4 x i32> %{{.*}}, i32 0
530  return _mm_cvtsi128_si32(A);
531}
532
533long long test_mm_cvtsi128_si64(__m128i A) {
534  // CHECK-LABEL: test_mm_cvtsi128_si64
535  // CHECK: extractelement <2 x i64> %{{.*}}, i32 0
536  return _mm_cvtsi128_si64(A);
537}
538
539__m128d test_mm_cvtsi32_sd(__m128d A, int B) {
540  // CHECK-LABEL: test_mm_cvtsi32_sd
541  // CHECK: sitofp i32 %{{.*}} to double
542  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
543  return _mm_cvtsi32_sd(A, B);
544}
545
546__m128i test_mm_cvtsi32_si128(int A) {
547  // CHECK-LABEL: test_mm_cvtsi32_si128
548  // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
549  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 1
550  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 2
551  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 3
552  return _mm_cvtsi32_si128(A);
553}
554
555__m128d test_mm_cvtsi64_sd(__m128d A, long long B) {
556  // CHECK-LABEL: test_mm_cvtsi64_sd
557  // CHECK: sitofp i64 %{{.*}} to double
558  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
559  return _mm_cvtsi64_sd(A, B);
560}
561
562__m128i test_mm_cvtsi64_si128(long long A) {
563  // CHECK-LABEL: test_mm_cvtsi64_si128
564  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
565  // CHECK: insertelement <2 x i64> %{{.*}}, i64 0, i32 1
566  return _mm_cvtsi64_si128(A);
567}
568
569__m128d test_mm_cvtss_sd(__m128d A, __m128 B) {
570  // CHECK-LABEL: test_mm_cvtss_sd
571  // CHECK: extractelement <4 x float> %{{.*}}, i32 0
572  // CHECK: fpext float %{{.*}} to double
573  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
574  return _mm_cvtss_sd(A, B);
575}
576
577__m128i test_mm_cvttpd_epi32(__m128d A) {
578  // CHECK-LABEL: test_mm_cvttpd_epi32
579  // CHECK: call <4 x i32> @llvm.x86.sse2.cvttpd2dq(<2 x double> %{{.*}})
580  return _mm_cvttpd_epi32(A);
581}
582
583__m128i test_mm_cvttps_epi32(__m128 A) {
584  // CHECK-LABEL: test_mm_cvttps_epi32
585  // CHECK: call <4 x i32> @llvm.x86.sse2.cvttps2dq(<4 x float> %{{.*}})
586  return _mm_cvttps_epi32(A);
587}
588
589int test_mm_cvttsd_si32(__m128d A) {
590  // CHECK-LABEL: test_mm_cvttsd_si32
591  // CHECK: call i32 @llvm.x86.sse2.cvttsd2si(<2 x double> %{{.*}})
592  return _mm_cvttsd_si32(A);
593}
594
595long long test_mm_cvttsd_si64(__m128d A) {
596  // CHECK-LABEL: test_mm_cvttsd_si64
597  // CHECK: call i64 @llvm.x86.sse2.cvttsd2si64(<2 x double> %{{.*}})
598  return _mm_cvttsd_si64(A);
599}
600
601__m128d test_mm_div_pd(__m128d A, __m128d B) {
602  // CHECK-LABEL: test_mm_div_pd
603  // CHECK: fdiv <2 x double>
604  return _mm_div_pd(A, B);
605}
606
607__m128d test_mm_div_sd(__m128d A, __m128d B) {
608  // CHECK-LABEL: test_mm_div_sd
609  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
610  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
611  // CHECK: fdiv double
612  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
613  return _mm_div_sd(A, B);
614}
615
616// Lowering to pextrw requires optimization.
617int test_mm_extract_epi16(__m128i A) {
618  // CHECK-LABEL: test_mm_extract_epi16
619  // CHECK: extractelement <8 x i16> %{{.*}}, {{i32|i64}} 1
620  // CHECK: zext i16 %{{.*}} to i32
621  return _mm_extract_epi16(A, 1);
622}
623
624__m128i test_mm_insert_epi16(__m128i A, int B) {
625  // CHECK-LABEL: test_mm_insert_epi16
626  // CHECK: insertelement <8 x i16> %{{.*}}, {{i32|i64}} 0
627  return _mm_insert_epi16(A, B, 0);
628}
629
630void test_mm_lfence() {
631  // CHECK-LABEL: test_mm_lfence
632  // CHECK: call void @llvm.x86.sse2.lfence()
633  _mm_lfence();
634}
635
636__m128d test_mm_load_pd(double const* A) {
637  // CHECK-LABEL: test_mm_load_pd
638  // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16
639  return _mm_load_pd(A);
640}
641
642__m128d test_mm_load_pd1(double const* A) {
643  // CHECK-LABEL: test_mm_load_pd1
644  // CHECK: load double, double* %{{.*}}, align 8
645  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
646  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
647  return _mm_load_pd1(A);
648}
649
650__m128d test_mm_load_sd(double const* A) {
651  // CHECK-LABEL: test_mm_load_sd
652  // CHECK: load double, double* %{{.*}}, align 1{{$}}
653  return _mm_load_sd(A);
654}
655
656__m128i test_mm_load_si128(__m128i const* A) {
657  // CHECK-LABEL: test_mm_load_si128
658  // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 16
659  return _mm_load_si128(A);
660}
661
662__m128d test_mm_load1_pd(double const* A) {
663  // CHECK-LABEL: test_mm_load1_pd
664  // CHECK: load double, double* %{{.*}}, align 8
665  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
666  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
667  return _mm_load1_pd(A);
668}
669
670__m128d test_mm_loadh_pd(__m128d x, void* y) {
671  // CHECK-LABEL: test_mm_loadh_pd
672  // CHECK: load double, double* %{{.*}}, align 1{{$}}
673  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
674  return _mm_loadh_pd(x, y);
675}
676
677__m128i test_mm_loadl_epi64(__m128i* y) {
678  // CHECK: test_mm_loadl_epi64
679  // CHECK: load i64, i64* {{.*}}, align 1{{$}}
680  // CHECK: insertelement <2 x i64> undef, i64 {{.*}}, i32 0
681  // CHECK: insertelement <2 x i64> {{.*}}, i64 0, i32 1
682  return _mm_loadl_epi64(y);
683}
684
685__m128d test_mm_loadl_pd(__m128d x, void* y) {
686  // CHECK-LABEL: test_mm_loadl_pd
687  // CHECK: load double, double* %{{.*}}, align 1{{$}}
688  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
689  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
690  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
691  return _mm_loadl_pd(x, y);
692}
693
694__m128d test_mm_loadr_pd(double const* A) {
695  // CHECK-LABEL: test_mm_loadr_pd
696  // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16
697  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 0>
698  return _mm_loadr_pd(A);
699}
700
701__m128d test_mm_loadu_pd(double const* A) {
702  // CHECK-LABEL: test_mm_loadu_pd
703  // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
704  return _mm_loadu_pd(A);
705}
706
707__m128i test_mm_loadu_si128(__m128i const* A) {
708  // CHECK-LABEL: test_mm_loadu_si128
709  // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
710  return _mm_loadu_si128(A);
711}
712
713__m128i test_mm_loadu_si64(void const* A) {
714  // CHECK-LABEL: test_mm_loadu_si64
715  // CHECK: load i64, i64* %{{.*}}, align 1{{$}}
716  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
717  // CHECK: insertelement <2 x i64> %{{.*}}, i64 0, i32 1
718  return _mm_loadu_si64(A);
719}
720
721__m128i test_mm_loadu_si32(void const* A) {
722  // CHECK-LABEL: test_mm_loadu_si32
723  // CHECK: load i32, i32* %{{.*}}, align 1{{$}}
724  // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
725  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 1
726  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 2
727  // CHECK: insertelement <4 x i32> %{{.*}}, i32 0, i32 3
728  return _mm_loadu_si32(A);
729}
730
731__m128i test_mm_loadu_si16(void const* A) {
732  // CHECK-LABEL: test_mm_loadu_si16
733  // CHECK: load i16, i16* %{{.*}}, align 1{{$}}
734  // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
735  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 1
736  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 2
737  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 3
738  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 4
739  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 5
740  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 6
741  // CHECK: insertelement <8 x i16> %{{.*}}, i16 0, i32 7
742  return _mm_loadu_si16(A);
743}
744
745__m128i test_mm_madd_epi16(__m128i A, __m128i B) {
746  // CHECK-LABEL: test_mm_madd_epi16
747  // CHECK: call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
748  return _mm_madd_epi16(A, B);
749}
750
751void test_mm_maskmoveu_si128(__m128i A, __m128i B, char* C) {
752  // CHECK-LABEL: test_mm_maskmoveu_si128
753  // CHECK: call void @llvm.x86.sse2.maskmov.dqu(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i8* %{{.*}})
754  _mm_maskmoveu_si128(A, B, C);
755}
756
757__m128i test_mm_max_epi16(__m128i A, __m128i B) {
758  // CHECK-LABEL: test_mm_max_epi16
759  // CHECK:       [[CMP:%.*]] = icmp sgt <8 x i16> [[X:%.*]], [[Y:%.*]]
760  // CHECK-NEXT:  select <8 x i1> [[CMP]], <8 x i16> [[X]], <8 x i16> [[Y]]
761  return _mm_max_epi16(A, B);
762}
763
764__m128i test_mm_max_epu8(__m128i A, __m128i B) {
765  // CHECK-LABEL: test_mm_max_epu8
766  // CHECK:       [[CMP:%.*]] = icmp ugt <16 x i8> [[X:%.*]], [[Y:%.*]]
767  // CHECK-NEXT:  select <16 x i1> [[CMP]], <16 x i8> [[X]], <16 x i8> [[Y]]
768  return _mm_max_epu8(A, B);
769}
770
771__m128d test_mm_max_pd(__m128d A, __m128d B) {
772  // CHECK-LABEL: test_mm_max_pd
773  // CHECK: call <2 x double> @llvm.x86.sse2.max.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
774  return _mm_max_pd(A, B);
775}
776
777__m128d test_mm_max_sd(__m128d A, __m128d B) {
778  // CHECK-LABEL: test_mm_max_sd
779  // CHECK: call <2 x double> @llvm.x86.sse2.max.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
780  return _mm_max_sd(A, B);
781}
782
783void test_mm_mfence() {
784  // CHECK-LABEL: test_mm_mfence
785  // CHECK: call void @llvm.x86.sse2.mfence()
786  _mm_mfence();
787}
788
789__m128i test_mm_min_epi16(__m128i A, __m128i B) {
790  // CHECK-LABEL: test_mm_min_epi16
791  // CHECK:       [[CMP:%.*]] = icmp slt <8 x i16> [[X:%.*]], [[Y:%.*]]
792  // CHECK-NEXT:  select <8 x i1> [[CMP]], <8 x i16> [[X]], <8 x i16> [[Y]]
793  return _mm_min_epi16(A, B);
794}
795
796__m128i test_mm_min_epu8(__m128i A, __m128i B) {
797  // CHECK-LABEL: test_mm_min_epu8
798  // CHECK:       [[CMP:%.*]] = icmp ult <16 x i8> [[X:%.*]], [[Y:%.*]]
799  // CHECK-NEXT:  select <16 x i1> [[CMP]], <16 x i8> [[X]], <16 x i8> [[Y]]
800  return _mm_min_epu8(A, B);
801}
802
803__m128d test_mm_min_pd(__m128d A, __m128d B) {
804  // CHECK-LABEL: test_mm_min_pd
805  // CHECK: call <2 x double> @llvm.x86.sse2.min.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
806  return _mm_min_pd(A, B);
807}
808
809__m128d test_mm_min_sd(__m128d A, __m128d B) {
810  // CHECK-LABEL: test_mm_min_sd
811  // CHECK: call <2 x double> @llvm.x86.sse2.min.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
812  return _mm_min_sd(A, B);
813}
814
815__m128i test_mm_move_epi64(__m128i A) {
816  // CHECK-LABEL: test_mm_move_epi64
817  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
818  return _mm_move_epi64(A);
819}
820
821__m128d test_mm_move_sd(__m128d A, __m128d B) {
822  // CHECK-LABEL: test_mm_move_sd
823  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
824  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
825  return _mm_move_sd(A, B);
826}
827
828int test_mm_movemask_epi8(__m128i A) {
829  // CHECK-LABEL: test_mm_movemask_epi8
830  // CHECK: call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %{{.*}})
831  return _mm_movemask_epi8(A);
832}
833
834int test_mm_movemask_pd(__m128d A) {
835  // CHECK-LABEL: test_mm_movemask_pd
836  // CHECK: call i32 @llvm.x86.sse2.movmsk.pd(<2 x double> %{{.*}})
837  return _mm_movemask_pd(A);
838}
839
840__m128i test_mm_mul_epu32(__m128i A, __m128i B) {
841  // CHECK-LABEL: test_mm_mul_epu32
842  // CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
843  // CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
844  // CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
845  return _mm_mul_epu32(A, B);
846}
847
848__m128d test_mm_mul_pd(__m128d A, __m128d B) {
849  // CHECK-LABEL: test_mm_mul_pd
850  // CHECK: fmul <2 x double> %{{.*}}, %{{.*}}
851  return _mm_mul_pd(A, B);
852}
853
854__m128d test_mm_mul_sd(__m128d A, __m128d B) {
855  // CHECK-LABEL: test_mm_mul_sd
856  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
857  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
858  // CHECK: fmul double
859  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
860  return _mm_mul_sd(A, B);
861}
862
863__m128i test_mm_mulhi_epi16(__m128i A, __m128i B) {
864  // CHECK-LABEL: test_mm_mulhi_epi16
865  // CHECK: call <8 x i16> @llvm.x86.sse2.pmulh.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
866  return _mm_mulhi_epi16(A, B);
867}
868
869__m128i test_mm_mulhi_epu16(__m128i A, __m128i B) {
870  // CHECK-LABEL: test_mm_mulhi_epu16
871  // CHECK: call <8 x i16> @llvm.x86.sse2.pmulhu.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
872  return _mm_mulhi_epu16(A, B);
873}
874
875__m128i test_mm_mullo_epi16(__m128i A, __m128i B) {
876  // CHECK-LABEL: test_mm_mullo_epi16
877  // CHECK: mul <8 x i16> %{{.*}}, %{{.*}}
878  return _mm_mullo_epi16(A, B);
879}
880
881__m128d test_mm_or_pd(__m128d A, __m128d B) {
882  // CHECK-LABEL: test_mm_or_pd
883  // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
884  return _mm_or_pd(A, B);
885}
886
887__m128i test_mm_or_si128(__m128i A, __m128i B) {
888  // CHECK-LABEL: test_mm_or_si128
889  // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
890  return _mm_or_si128(A, B);
891}
892
893__m128i test_mm_packs_epi16(__m128i A, __m128i B) {
894  // CHECK-LABEL: test_mm_packs_epi16
895  // CHECK: call <16 x i8> @llvm.x86.sse2.packsswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
896  return _mm_packs_epi16(A, B);
897}
898
899__m128i test_mm_packs_epi32(__m128i A, __m128i B) {
900  // CHECK-LABEL: test_mm_packs_epi32
901  // CHECK: call <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
902  return _mm_packs_epi32(A, B);
903}
904
905__m128i test_mm_packus_epi16(__m128i A, __m128i B) {
906  // CHECK-LABEL: test_mm_packus_epi16
907  // CHECK: call <16 x i8> @llvm.x86.sse2.packuswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
908  return _mm_packus_epi16(A, B);
909}
910
911void test_mm_pause() {
912  // CHECK-LABEL: test_mm_pause
913  // CHECK: call void @llvm.x86.sse2.pause()
914  return _mm_pause();
915}
916
917__m128i test_mm_sad_epu8(__m128i A, __m128i B) {
918  // CHECK-LABEL: test_mm_sad_epu8
919  // CHECK: call <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
920  return _mm_sad_epu8(A, B);
921}
922
923__m128i test_mm_set_epi8(char A, char B, char C, char D,
924                         char E, char F, char G, char H,
925                         char I, char J, char K, char L,
926                         char M, char N, char O, char P) {
927  // CHECK-LABEL: test_mm_set_epi8
928  // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
929  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
930  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
931  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
932  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
933  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
934  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
935  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
936  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
937  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
938  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
939  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
940  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
941  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
942  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
943  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
944  return _mm_set_epi8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
945}
946
947__m128i test_mm_set_epi16(short A, short B, short C, short D,
948                          short E, short F, short G, short H) {
949  // CHECK-LABEL: test_mm_set_epi16
950  // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
951  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
952  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
953  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
954  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
955  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
956  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
957  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
958  return _mm_set_epi16(A, B, C, D, E, F, G, H);
959}
960
961__m128i test_mm_set_epi32(int A, int B, int C, int D) {
962  // CHECK-LABEL: test_mm_set_epi32
963  // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
964  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
965  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
966  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
967  return _mm_set_epi32(A, B, C, D);
968}
969
970__m128i test_mm_set_epi64(__m64 A, __m64 B) {
971  // CHECK-LABEL: test_mm_set_epi64
972  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
973  // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
974  return _mm_set_epi64(A, B);
975}
976
977__m128i test_mm_set_epi64x(long long A, long long B) {
978  // CHECK-LABEL: test_mm_set_epi64x
979  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
980  // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
981  return _mm_set_epi64x(A, B);
982}
983
984__m128d test_mm_set_pd(double A, double B) {
985  // CHECK-LABEL: test_mm_set_pd
986  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
987  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
988  return _mm_set_pd(A, B);
989}
990
991__m128d test_mm_set_pd1(double A) {
992  // CHECK-LABEL: test_mm_set_pd1
993  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
994  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
995  return _mm_set_pd1(A);
996}
997
998__m128d test_mm_set_sd(double A) {
999  // CHECK-LABEL: test_mm_set_sd
1000  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1001  // CHECK: insertelement <2 x double> %{{.*}}, double 0.000000e+00, i32 1
1002  return _mm_set_sd(A);
1003}
1004
1005__m128i test_mm_set1_epi8(char A) {
1006  // CHECK-LABEL: test_mm_set1_epi8
1007  // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
1008  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1009  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1010  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1011  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1012  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1013  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1014  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1015  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1016  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1017  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1018  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1019  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1020  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1021  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1022  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1023  return _mm_set1_epi8(A);
1024}
1025
1026__m128i test_mm_set1_epi16(short A) {
1027  // CHECK-LABEL: test_mm_set1_epi16
1028  // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
1029  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1030  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1031  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1032  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1033  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1034  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1035  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1036  return _mm_set1_epi16(A);
1037}
1038
1039__m128i test_mm_set1_epi32(int A) {
1040  // CHECK-LABEL: test_mm_set1_epi32
1041  // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
1042  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1043  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1044  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1045  return _mm_set1_epi32(A);
1046}
1047
1048__m128i test_mm_set1_epi64(__m64 A) {
1049  // CHECK-LABEL: test_mm_set1_epi64
1050  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1051  // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1052  return _mm_set1_epi64(A);
1053}
1054
1055__m128i test_mm_set1_epi64x(long long A) {
1056  // CHECK-LABEL: test_mm_set1_epi64x
1057  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1058  // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1059  return _mm_set1_epi64x(A);
1060}
1061
1062__m128d test_mm_set1_pd(double A) {
1063  // CHECK-LABEL: test_mm_set1_pd
1064  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1065  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
1066  return _mm_set1_pd(A);
1067}
1068
1069__m128i test_mm_setr_epi8(char A, char B, char C, char D,
1070                          char E, char F, char G, char H,
1071                          char I, char J, char K, char L,
1072                          char M, char N, char O, char P) {
1073  // CHECK-LABEL: test_mm_setr_epi8
1074  // CHECK: insertelement <16 x i8> undef, i8 %{{.*}}, i32 0
1075  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1076  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1077  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1078  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1079  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1080  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1081  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1082  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1083  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1084  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1085  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1086  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1087  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1088  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1089  // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1090  return _mm_setr_epi8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
1091}
1092
1093__m128i test_mm_setr_epi16(short A, short B, short C, short D,
1094                           short E, short F, short G, short H) {
1095  // CHECK-LABEL: test_mm_setr_epi16
1096  // CHECK: insertelement <8 x i16> undef, i16 %{{.*}}, i32 0
1097  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1098  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1099  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1100  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1101  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1102  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1103  // CHECK: insertelement <8 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1104  return _mm_setr_epi16(A, B, C, D, E, F, G, H);
1105}
1106
1107__m128i test_mm_setr_epi32(int A, int B, int C, int D) {
1108  // CHECK-LABEL: test_mm_setr_epi32
1109  // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0
1110  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1111  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1112  // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1113  return _mm_setr_epi32(A, B, C, D);
1114}
1115
1116__m128i test_mm_setr_epi64(__m64 A, __m64 B) {
1117  // CHECK-LABEL: test_mm_setr_epi64
1118  // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0
1119  // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1120  return _mm_setr_epi64(A, B);
1121}
1122
1123__m128d test_mm_setr_pd(double A, double B) {
1124  // CHECK-LABEL: test_mm_setr_pd
1125  // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0
1126  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1
1127  return _mm_setr_pd(A, B);
1128}
1129
1130__m128d test_mm_setzero_pd() {
1131  // CHECK-LABEL: test_mm_setzero_pd
1132  // CHECK: store <2 x double> zeroinitializer
1133  return _mm_setzero_pd();
1134}
1135
1136__m128i test_mm_setzero_si128() {
1137  // CHECK-LABEL: test_mm_setzero_si128
1138  // CHECK: store <2 x i64> zeroinitializer
1139  return _mm_setzero_si128();
1140}
1141
1142__m128i test_mm_shuffle_epi32(__m128i A) {
1143  // CHECK-LABEL: test_mm_shuffle_epi32
1144  // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <4 x i32> zeroinitializer
1145  return _mm_shuffle_epi32(A, 0);
1146}
1147
1148__m128d test_mm_shuffle_pd(__m128d A, __m128d B) {
1149  // CHECK-LABEL: test_mm_shuffle_pd
1150  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 2>
1151  return _mm_shuffle_pd(A, B, 1);
1152}
1153
1154__m128i test_mm_shufflehi_epi16(__m128i A) {
1155  // CHECK-LABEL: test_mm_shufflehi_epi16
1156  // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 4, i32 4, i32 4>
1157  return _mm_shufflehi_epi16(A, 0);
1158}
1159
1160__m128i test_mm_shufflelo_epi16(__m128i A) {
1161  // CHECK-LABEL: test_mm_shufflelo_epi16
1162  // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> undef, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 5, i32 6, i32 7>
1163  return _mm_shufflelo_epi16(A, 0);
1164}
1165
1166__m128i test_mm_sll_epi16(__m128i A, __m128i B) {
1167  // CHECK-LABEL: test_mm_sll_epi16
1168  // CHECK: call <8 x i16> @llvm.x86.sse2.psll.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1169  return _mm_sll_epi16(A, B);
1170}
1171
1172__m128i test_mm_sll_epi32(__m128i A, __m128i B) {
1173  // CHECK-LABEL: test_mm_sll_epi32
1174  // CHECK: call <4 x i32> @llvm.x86.sse2.psll.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1175  return _mm_sll_epi32(A, B);
1176}
1177
1178__m128i test_mm_sll_epi64(__m128i A, __m128i B) {
1179  // CHECK-LABEL: test_mm_sll_epi64
1180  // CHECK: call <2 x i64> @llvm.x86.sse2.psll.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1181  return _mm_sll_epi64(A, B);
1182}
1183
1184__m128i test_mm_slli_epi16(__m128i A) {
1185  // CHECK-LABEL: test_mm_slli_epi16
1186  // CHECK: call <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1187  return _mm_slli_epi16(A, 1);
1188}
1189
1190__m128i test_mm_slli_epi16_1(__m128i A) {
1191  // CHECK-LABEL: test_mm_slli_epi16_1
1192  // CHECK: call <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1193  return _mm_slli_epi16(A, -1);
1194}
1195
1196__m128i test_mm_slli_epi16_2(__m128i A, int B) {
1197  // CHECK-LABEL: test_mm_slli_epi16_2
1198  // CHECK: call <8 x i16> @llvm.x86.sse2.pslli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1199  return _mm_slli_epi16(A, B);
1200}
1201
1202__m128i test_mm_slli_epi32(__m128i A) {
1203  // CHECK-LABEL: test_mm_slli_epi32
1204  // CHECK: call <4 x i32> @llvm.x86.sse2.pslli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1205  return _mm_slli_epi32(A, 1);
1206}
1207
1208__m128i test_mm_slli_epi32_1(__m128i A) {
1209  // CHECK-LABEL: test_mm_slli_epi32_1
1210  // CHECK: call <4 x i32> @llvm.x86.sse2.pslli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1211  return _mm_slli_epi32(A, -1);
1212}
1213
1214__m128i test_mm_slli_epi32_2(__m128i A, int B) {
1215  // CHECK-LABEL: test_mm_slli_epi32_2
1216  // CHECK: call <4 x i32> @llvm.x86.sse2.pslli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1217  return _mm_slli_epi32(A, B);
1218}
1219
1220__m128i test_mm_slli_epi64(__m128i A) {
1221  // CHECK-LABEL: test_mm_slli_epi64
1222  // CHECK: call <2 x i64> @llvm.x86.sse2.pslli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1223  return _mm_slli_epi64(A, 1);
1224}
1225
1226__m128i test_mm_slli_epi64_1(__m128i A) {
1227  // CHECK-LABEL: test_mm_slli_epi64_1
1228  // CHECK: call <2 x i64> @llvm.x86.sse2.pslli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1229  return _mm_slli_epi64(A, -1);
1230}
1231
1232__m128i test_mm_slli_epi64_2(__m128i A, int B) {
1233  // CHECK-LABEL: test_mm_slli_epi64_2
1234  // CHECK: call <2 x i64> @llvm.x86.sse2.pslli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1235  return _mm_slli_epi64(A, B);
1236}
1237
1238__m128i test_mm_slli_si128(__m128i A) {
1239  // CHECK-LABEL: test_mm_slli_si128
1240  // CHECK: shufflevector <16 x i8> zeroinitializer, <16 x i8> %{{.*}}, <16 x i32> <i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26>
1241  return _mm_slli_si128(A, 5);
1242}
1243
1244__m128i test_mm_slli_si128_2(__m128i A) {
1245  // CHECK-LABEL: test_mm_slli_si128_2
1246  // CHECK: ret <2 x i64> zeroinitializer
1247  return _mm_slli_si128(A, 17);
1248}
1249
1250__m128d test_mm_sqrt_pd(__m128d A) {
1251  // CHECK-LABEL: test_mm_sqrt_pd
1252  // CHECK: call <2 x double> @llvm.sqrt.v2f64(<2 x double> %{{.*}})
1253  return _mm_sqrt_pd(A);
1254}
1255
1256__m128d test_mm_sqrt_sd(__m128d A, __m128d B) {
1257  // CHECK-LABEL: test_mm_sqrt_sd
1258  // CHECK: extractelement <2 x double> %{{.*}}, i64 0
1259  // CHECK: call double @llvm.sqrt.f64(double {{.*}})
1260  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0
1261  return _mm_sqrt_sd(A, B);
1262}
1263
1264__m128i test_mm_sra_epi16(__m128i A, __m128i B) {
1265  // CHECK-LABEL: test_mm_sra_epi16
1266  // CHECK: call <8 x i16> @llvm.x86.sse2.psra.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1267  return _mm_sra_epi16(A, B);
1268}
1269
1270__m128i test_mm_sra_epi32(__m128i A, __m128i B) {
1271  // CHECK-LABEL: test_mm_sra_epi32
1272  // CHECK: call <4 x i32> @llvm.x86.sse2.psra.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1273  return _mm_sra_epi32(A, B);
1274}
1275
1276__m128i test_mm_srai_epi16(__m128i A) {
1277  // CHECK-LABEL: test_mm_srai_epi16
1278  // CHECK: call <8 x i16> @llvm.x86.sse2.psrai.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1279  return _mm_srai_epi16(A, 1);
1280}
1281
1282__m128i test_mm_srai_epi16_1(__m128i A) {
1283  // CHECK-LABEL: test_mm_srai_epi16_1
1284  // CHECK: call <8 x i16> @llvm.x86.sse2.psrai.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1285  return _mm_srai_epi16(A, -1);
1286}
1287
1288__m128i test_mm_srai_epi16_2(__m128i A, int B) {
1289  // CHECK-LABEL: test_mm_srai_epi16_2
1290  // CHECK: call <8 x i16> @llvm.x86.sse2.psrai.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1291  return _mm_srai_epi16(A, B);
1292}
1293
1294__m128i test_mm_srai_epi32(__m128i A) {
1295  // CHECK-LABEL: test_mm_srai_epi32
1296  // CHECK: call <4 x i32> @llvm.x86.sse2.psrai.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1297  return _mm_srai_epi32(A, 1);
1298}
1299
1300__m128i test_mm_srai_epi32_1(__m128i A) {
1301  // CHECK-LABEL: test_mm_srai_epi32_1
1302  // CHECK: call <4 x i32> @llvm.x86.sse2.psrai.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1303  return _mm_srai_epi32(A, -1);
1304}
1305
1306__m128i test_mm_srai_epi32_2(__m128i A, int B) {
1307  // CHECK-LABEL: test_mm_srai_epi32_2
1308  // CHECK: call <4 x i32> @llvm.x86.sse2.psrai.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1309  return _mm_srai_epi32(A, B);
1310}
1311
1312__m128i test_mm_srl_epi16(__m128i A, __m128i B) {
1313  // CHECK-LABEL: test_mm_srl_epi16
1314  // CHECK: call <8 x i16> @llvm.x86.sse2.psrl.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1315  return _mm_srl_epi16(A, B);
1316}
1317
1318__m128i test_mm_srl_epi32(__m128i A, __m128i B) {
1319  // CHECK-LABEL: test_mm_srl_epi32
1320  // CHECK: call <4 x i32> @llvm.x86.sse2.psrl.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1321  return _mm_srl_epi32(A, B);
1322}
1323
1324__m128i test_mm_srl_epi64(__m128i A, __m128i B) {
1325  // CHECK-LABEL: test_mm_srl_epi64
1326  // CHECK: call <2 x i64> @llvm.x86.sse2.psrl.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1327  return _mm_srl_epi64(A, B);
1328}
1329
1330__m128i test_mm_srli_epi16(__m128i A) {
1331  // CHECK-LABEL: test_mm_srli_epi16
1332  // CHECK: call <8 x i16> @llvm.x86.sse2.psrli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1333  return _mm_srli_epi16(A, 1);
1334}
1335
1336__m128i test_mm_srli_epi16_1(__m128i A) {
1337  // CHECK-LABEL: test_mm_srli_epi16_1
1338  // CHECK: call <8 x i16> @llvm.x86.sse2.psrli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1339  return _mm_srli_epi16(A, -1);
1340}
1341
1342__m128i test_mm_srli_epi16_2(__m128i A, int B) {
1343  // CHECK-LABEL: test_mm_srli_epi16
1344  // CHECK: call <8 x i16> @llvm.x86.sse2.psrli.w(<8 x i16> %{{.*}}, i32 %{{.*}})
1345  return _mm_srli_epi16(A, B);
1346}
1347
1348__m128i test_mm_srli_epi32(__m128i A) {
1349  // CHECK-LABEL: test_mm_srli_epi32
1350  // CHECK: call <4 x i32> @llvm.x86.sse2.psrli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1351  return _mm_srli_epi32(A, 1);
1352}
1353
1354__m128i test_mm_srli_epi32_1(__m128i A) {
1355  // CHECK-LABEL: test_mm_srli_epi32_1
1356  // CHECK: call <4 x i32> @llvm.x86.sse2.psrli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1357  return _mm_srli_epi32(A, -1);
1358}
1359
1360__m128i test_mm_srli_epi32_2(__m128i A, int B) {
1361  // CHECK-LABEL: test_mm_srli_epi32_2
1362  // CHECK: call <4 x i32> @llvm.x86.sse2.psrli.d(<4 x i32> %{{.*}}, i32 %{{.*}})
1363  return _mm_srli_epi32(A, B);
1364}
1365
1366__m128i test_mm_srli_epi64(__m128i A) {
1367  // CHECK-LABEL: test_mm_srli_epi64
1368  // CHECK: call <2 x i64> @llvm.x86.sse2.psrli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1369  return _mm_srli_epi64(A, 1);
1370}
1371
1372__m128i test_mm_srli_epi64_1(__m128i A) {
1373  // CHECK-LABEL: test_mm_srli_epi64_1
1374  // CHECK: call <2 x i64> @llvm.x86.sse2.psrli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1375  return _mm_srli_epi64(A, -1);
1376}
1377
1378__m128i test_mm_srli_epi64_2(__m128i A, int B) {
1379  // CHECK-LABEL: test_mm_srli_epi64_2
1380  // CHECK: call <2 x i64> @llvm.x86.sse2.psrli.q(<2 x i64> %{{.*}}, i32 %{{.*}})
1381  return _mm_srli_epi64(A, B);
1382}
1383
1384__m128i test_mm_srli_si128(__m128i A) {
1385  // CHECK-LABEL: test_mm_srli_si128
1386  // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> zeroinitializer, <16 x i32> <i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20>
1387  return _mm_srli_si128(A, 5);
1388}
1389
1390__m128i test_mm_srli_si128_2(__m128i A) {
1391  // CHECK-LABEL: test_mm_srli_si128_2
1392  // ret <2 x i64> zeroinitializer
1393  return _mm_srli_si128(A, 17);
1394}
1395
1396void test_mm_store_pd(double* A, __m128d B) {
1397  // CHECK-LABEL: test_mm_store_pd
1398  // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16
1399  _mm_store_pd(A, B);
1400}
1401
1402void test_mm_store_pd1(double* x, __m128d y) {
1403  // CHECK-LABEL: test_mm_store_pd1
1404  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
1405  // CHECK: store <2 x double> %{{.*}}, <2 x double>* {{.*}}, align 16
1406  _mm_store_pd1(x, y);
1407}
1408
1409void test_mm_store_sd(double* A, __m128d B) {
1410  // CHECK-LABEL: test_mm_store_sd
1411  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1412  // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1413  _mm_store_sd(A, B);
1414}
1415
1416void test_mm_store_si128(__m128i* A, __m128i B) {
1417  // CHECK-LABEL: test_mm_store_si128
1418  // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16
1419  _mm_store_si128(A, B);
1420}
1421
1422void test_mm_store1_pd(double* x, __m128d y) {
1423  // CHECK-LABEL: test_mm_store1_pd
1424  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
1425  // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16
1426  _mm_store1_pd(x, y);
1427}
1428
1429void test_mm_storeh_pd(double* A, __m128d B) {
1430  // CHECK-LABEL: test_mm_storeh_pd
1431  // CHECK: extractelement <2 x double> %{{.*}}, i32 1
1432  // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1433  _mm_storeh_pd(A, B);
1434}
1435
1436void test_mm_storel_epi64(__m128i x, void* y) {
1437  // CHECK-LABEL: test_mm_storel_epi64
1438  // CHECK: extractelement <2 x i64> %{{.*}}, i32 0
1439  // CHECK: store {{.*}} i64* {{.*}}, align 1{{$}}
1440  _mm_storel_epi64(y, x);
1441}
1442
1443void test_mm_storel_pd(double* A, __m128d B) {
1444  // CHECK-LABEL: test_mm_storel_pd
1445  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1446  // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}}
1447  _mm_storel_pd(A, B);
1448}
1449
1450void test_mm_storer_pd(__m128d A, double* B) {
1451  // CHECK-LABEL: test_mm_storer_pd
1452  // CHECK: shufflevector <2 x double> {{.*}}, <2 x double> {{.*}}, <2 x i32> <i32 1, i32 0>
1453  // CHECK: store {{.*}} <2 x double>* {{.*}}, align 16{{$}}
1454  _mm_storer_pd(B, A);
1455}
1456
1457void test_mm_storeu_pd(double* A, __m128d B) {
1458  // CHECK-LABEL: test_mm_storeu_pd
1459  // CHECK: store {{.*}} <2 x double>* {{.*}}, align 1{{$}}
1460  // CHECK-NEXT: ret void
1461  _mm_storeu_pd(A, B);
1462}
1463
1464void test_mm_storeu_si128(__m128i* A, __m128i B) {
1465  // CHECK-LABEL: test_mm_storeu_si128
1466  // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1467  // CHECK-NEXT: ret void
1468  _mm_storeu_si128(A, B);
1469}
1470
1471void test_mm_storeu_si64(void* A, __m128i B) {
1472  // CHECK-LABEL: test_mm_storeu_si64
1473  // CHECK: [[EXT:%.*]] = extractelement <2 x i64> %{{.*}}, i32 0
1474  // CHECK: store i64 [[EXT]], i64* %{{.*}}, align 1{{$}}
1475  // CHECK-NEXT: ret void
1476  _mm_storeu_si64(A, B);
1477}
1478
1479void test_mm_storeu_si32(void* A, __m128i B) {
1480  // CHECK-LABEL: test_mm_storeu_si32
1481  // CHECK: [[EXT:%.*]] = extractelement <4 x i32> %{{.*}}, i32 0
1482  // CHECK: store i32 [[EXT]], i32* %{{.*}}, align 1{{$}}
1483  // CHECK-NEXT: ret void
1484  _mm_storeu_si32(A, B);
1485}
1486
1487void test_mm_storeu_si16(void* A, __m128i B) {
1488  // CHECK-LABEL: test_mm_storeu_si16
1489  // CHECK: [[EXT:%.*]] = extractelement <8 x i16> %{{.*}}, i32 0
1490  // CHECK: store i16 [[EXT]], i16* %{{.*}}, align 1{{$}}
1491  // CHECK-NEXT: ret void
1492  _mm_storeu_si16(A, B);
1493}
1494
1495void test_mm_stream_pd(double *A, __m128d B) {
1496  // CHECK-LABEL: test_mm_stream_pd
1497  // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16, !nontemporal
1498  _mm_stream_pd(A, B);
1499}
1500
1501void test_mm_stream_si32(int *A, int B) {
1502  // CHECK-LABEL: test_mm_stream_si32
1503  // CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1, !nontemporal
1504  _mm_stream_si32(A, B);
1505}
1506
1507void test_mm_stream_si64(long long *A, long long B) {
1508  // CHECK-LABEL: test_mm_stream_si64
1509  // CHECK: store i64 %{{.*}}, i64* %{{.*}}, align 1, !nontemporal
1510  _mm_stream_si64(A, B);
1511}
1512
1513void test_mm_stream_si128(__m128i *A, __m128i B) {
1514  // CHECK-LABEL: test_mm_stream_si128
1515  // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16, !nontemporal
1516  _mm_stream_si128(A, B);
1517}
1518
1519__m128i test_mm_sub_epi8(__m128i A, __m128i B) {
1520  // CHECK-LABEL: test_mm_sub_epi8
1521  // CHECK: sub <16 x i8>
1522  return _mm_sub_epi8(A, B);
1523}
1524
1525__m128i test_mm_sub_epi16(__m128i A, __m128i B) {
1526  // CHECK-LABEL: test_mm_sub_epi16
1527  // CHECK: sub <8 x i16>
1528  return _mm_sub_epi16(A, B);
1529}
1530
1531__m128i test_mm_sub_epi32(__m128i A, __m128i B) {
1532  // CHECK-LABEL: test_mm_sub_epi32
1533  // CHECK: sub <4 x i32>
1534  return _mm_sub_epi32(A, B);
1535}
1536
1537__m128i test_mm_sub_epi64(__m128i A, __m128i B) {
1538  // CHECK-LABEL: test_mm_sub_epi64
1539  // CHECK: sub <2 x i64>
1540  return _mm_sub_epi64(A, B);
1541}
1542
1543__m128d test_mm_sub_pd(__m128d A, __m128d B) {
1544  // CHECK-LABEL: test_mm_sub_pd
1545  // CHECK: fsub <2 x double>
1546  return _mm_sub_pd(A, B);
1547}
1548
1549__m128d test_mm_sub_sd(__m128d A, __m128d B) {
1550  // CHECK-LABEL: test_mm_sub_sd
1551  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1552  // CHECK: extractelement <2 x double> %{{.*}}, i32 0
1553  // CHECK: fsub double
1554  // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0
1555  return _mm_sub_sd(A, B);
1556}
1557
1558__m128i test_mm_subs_epi8(__m128i A, __m128i B) {
1559  // CHECK-LABEL: test_mm_subs_epi8
1560  // CHECK: call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1561  return _mm_subs_epi8(A, B);
1562}
1563
1564__m128i test_mm_subs_epi16(__m128i A, __m128i B) {
1565  // CHECK-LABEL: test_mm_subs_epi16
1566  // CHECK: call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1567  return _mm_subs_epi16(A, B);
1568}
1569
1570__m128i test_mm_subs_epu8(__m128i A, __m128i B) {
1571  // CHECK-LABEL: test_mm_subs_epu8
1572  // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1573  // CHECK: call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{.*}}, <16 x i8> %{{.*}})
1574  return _mm_subs_epu8(A, B);
1575}
1576
1577__m128i test_mm_subs_epu16(__m128i A, __m128i B) {
1578  // CHECK-LABEL: test_mm_subs_epu16
1579  // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1580  // CHECK: call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
1581  return _mm_subs_epu16(A, B);
1582}
1583
1584int test_mm_ucomieq_sd(__m128d A, __m128d B) {
1585  // CHECK-LABEL: test_mm_ucomieq_sd
1586  // CHECK: call i32 @llvm.x86.sse2.ucomieq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1587  return _mm_ucomieq_sd(A, B);
1588}
1589
1590int test_mm_ucomige_sd(__m128d A, __m128d B) {
1591  // CHECK-LABEL: test_mm_ucomige_sd
1592  // CHECK: call i32 @llvm.x86.sse2.ucomige.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1593  return _mm_ucomige_sd(A, B);
1594}
1595
1596int test_mm_ucomigt_sd(__m128d A, __m128d B) {
1597  // CHECK-LABEL: test_mm_ucomigt_sd
1598  // CHECK: call i32 @llvm.x86.sse2.ucomigt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1599  return _mm_ucomigt_sd(A, B);
1600}
1601
1602int test_mm_ucomile_sd(__m128d A, __m128d B) {
1603  // CHECK-LABEL: test_mm_ucomile_sd
1604  // CHECK: call i32 @llvm.x86.sse2.ucomile.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1605  return _mm_ucomile_sd(A, B);
1606}
1607
1608int test_mm_ucomilt_sd(__m128d A, __m128d B) {
1609  // CHECK-LABEL: test_mm_ucomilt_sd
1610  // CHECK: call i32 @llvm.x86.sse2.ucomilt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1611  return _mm_ucomilt_sd(A, B);
1612}
1613
1614int test_mm_ucomineq_sd(__m128d A, __m128d B) {
1615  // CHECK-LABEL: test_mm_ucomineq_sd
1616  // CHECK: call i32 @llvm.x86.sse2.ucomineq.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1617  return _mm_ucomineq_sd(A, B);
1618}
1619
1620__m128d test_mm_undefined_pd() {
1621  // CHECK-LABEL: @test_mm_undefined_pd
1622  // CHECK: ret <2 x double> zeroinitializer
1623  return _mm_undefined_pd();
1624}
1625
1626__m128i test_mm_undefined_si128() {
1627  // CHECK-LABEL: @test_mm_undefined_si128
1628  // CHECK: ret <2 x i64> zeroinitializer
1629  return _mm_undefined_si128();
1630}
1631
1632__m128i test_mm_unpackhi_epi8(__m128i A, __m128i B) {
1633  // CHECK-LABEL: test_mm_unpackhi_epi8
1634  // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1635  return _mm_unpackhi_epi8(A, B);
1636}
1637
1638__m128i test_mm_unpackhi_epi16(__m128i A, __m128i B) {
1639  // CHECK-LABEL: test_mm_unpackhi_epi16
1640  // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1641  return _mm_unpackhi_epi16(A, B);
1642}
1643
1644__m128i test_mm_unpackhi_epi32(__m128i A, __m128i B) {
1645  // CHECK-LABEL: test_mm_unpackhi_epi32
1646  // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1647  return _mm_unpackhi_epi32(A, B);
1648}
1649
1650__m128i test_mm_unpackhi_epi64(__m128i A, __m128i B) {
1651  // CHECK-LABEL: test_mm_unpackhi_epi64
1652  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 1, i32 3>
1653  return _mm_unpackhi_epi64(A, B);
1654}
1655
1656__m128d test_mm_unpackhi_pd(__m128d A, __m128d B) {
1657  // CHECK-LABEL: test_mm_unpackhi_pd
1658  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 1, i32 3>
1659  return _mm_unpackhi_pd(A, B);
1660}
1661
1662__m128i test_mm_unpacklo_epi8(__m128i A, __m128i B) {
1663  // CHECK-LABEL: test_mm_unpacklo_epi8
1664  // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1665  return _mm_unpacklo_epi8(A, B);
1666}
1667
1668__m128i test_mm_unpacklo_epi16(__m128i A, __m128i B) {
1669  // CHECK-LABEL: test_mm_unpacklo_epi16
1670  // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1671  return _mm_unpacklo_epi16(A, B);
1672}
1673
1674__m128i test_mm_unpacklo_epi32(__m128i A, __m128i B) {
1675  // CHECK-LABEL: test_mm_unpacklo_epi32
1676  // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1677  return _mm_unpacklo_epi32(A, B);
1678}
1679
1680__m128i test_mm_unpacklo_epi64(__m128i A, __m128i B) {
1681  // CHECK-LABEL: test_mm_unpacklo_epi64
1682  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> <i32 0, i32 2>
1683  return _mm_unpacklo_epi64(A, B);
1684}
1685
1686__m128d test_mm_unpacklo_pd(__m128d A, __m128d B) {
1687  // CHECK-LABEL: test_mm_unpacklo_pd
1688  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 0, i32 2>
1689  return _mm_unpacklo_pd(A, B);
1690}
1691
1692__m128d test_mm_xor_pd(__m128d A, __m128d B) {
1693  // CHECK-LABEL: test_mm_xor_pd
1694  // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
1695  return _mm_xor_pd(A, B);
1696}
1697
1698__m128i test_mm_xor_si128(__m128i A, __m128i B) {
1699  // CHECK-LABEL: test_mm_xor_si128
1700  // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
1701  return _mm_xor_si128(A, B);
1702}
1703
CodeThinker, Enjoy your reading code