Clang Project

clang_source_code/test/CodeGen/aarch64-neon-3v.c
1// RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon  -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
2
3// Test new aarch64 intrinsics and types
4
5#include <arm_neon.h>
6
7// CHECK-LABEL: define <8 x i8> @test_vand_s8(<8 x i8> %a, <8 x i8> %b) #0 {
8// CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, %b
9// CHECK:   ret <8 x i8> [[AND_I]]
10int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) {
11  return vand_s8(a, b);
12}
13
14// CHECK-LABEL: define <16 x i8> @test_vandq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
15// CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, %b
16// CHECK:   ret <16 x i8> [[AND_I]]
17int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) {
18  return vandq_s8(a, b);
19}
20
21// CHECK-LABEL: define <4 x i16> @test_vand_s16(<4 x i16> %a, <4 x i16> %b) #0 {
22// CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, %b
23// CHECK:   ret <4 x i16> [[AND_I]]
24int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) {
25  return vand_s16(a, b);
26}
27
28// CHECK-LABEL: define <8 x i16> @test_vandq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
29// CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, %b
30// CHECK:   ret <8 x i16> [[AND_I]]
31int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) {
32  return vandq_s16(a, b);
33}
34
35// CHECK-LABEL: define <2 x i32> @test_vand_s32(<2 x i32> %a, <2 x i32> %b) #0 {
36// CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, %b
37// CHECK:   ret <2 x i32> [[AND_I]]
38int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) {
39  return vand_s32(a, b);
40}
41
42// CHECK-LABEL: define <4 x i32> @test_vandq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
43// CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, %b
44// CHECK:   ret <4 x i32> [[AND_I]]
45int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) {
46  return vandq_s32(a, b);
47}
48
49// CHECK-LABEL: define <1 x i64> @test_vand_s64(<1 x i64> %a, <1 x i64> %b) #0 {
50// CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, %b
51// CHECK:   ret <1 x i64> [[AND_I]]
52int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) {
53  return vand_s64(a, b);
54}
55
56// CHECK-LABEL: define <2 x i64> @test_vandq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
57// CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, %b
58// CHECK:   ret <2 x i64> [[AND_I]]
59int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) {
60  return vandq_s64(a, b);
61}
62
63// CHECK-LABEL: define <8 x i8> @test_vand_u8(<8 x i8> %a, <8 x i8> %b) #0 {
64// CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, %b
65// CHECK:   ret <8 x i8> [[AND_I]]
66uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) {
67  return vand_u8(a, b);
68}
69
70// CHECK-LABEL: define <16 x i8> @test_vandq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
71// CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, %b
72// CHECK:   ret <16 x i8> [[AND_I]]
73uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) {
74  return vandq_u8(a, b);
75}
76
77// CHECK-LABEL: define <4 x i16> @test_vand_u16(<4 x i16> %a, <4 x i16> %b) #0 {
78// CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, %b
79// CHECK:   ret <4 x i16> [[AND_I]]
80uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) {
81  return vand_u16(a, b);
82}
83
84// CHECK-LABEL: define <8 x i16> @test_vandq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
85// CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, %b
86// CHECK:   ret <8 x i16> [[AND_I]]
87uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) {
88  return vandq_u16(a, b);
89}
90
91// CHECK-LABEL: define <2 x i32> @test_vand_u32(<2 x i32> %a, <2 x i32> %b) #0 {
92// CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, %b
93// CHECK:   ret <2 x i32> [[AND_I]]
94uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) {
95  return vand_u32(a, b);
96}
97
98// CHECK-LABEL: define <4 x i32> @test_vandq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
99// CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, %b
100// CHECK:   ret <4 x i32> [[AND_I]]
101uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) {
102  return vandq_u32(a, b);
103}
104
105// CHECK-LABEL: define <1 x i64> @test_vand_u64(<1 x i64> %a, <1 x i64> %b) #0 {
106// CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, %b
107// CHECK:   ret <1 x i64> [[AND_I]]
108uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) {
109  return vand_u64(a, b);
110}
111
112// CHECK-LABEL: define <2 x i64> @test_vandq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
113// CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, %b
114// CHECK:   ret <2 x i64> [[AND_I]]
115uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) {
116  return vandq_u64(a, b);
117}
118
119// CHECK-LABEL: define <8 x i8> @test_vorr_s8(<8 x i8> %a, <8 x i8> %b) #0 {
120// CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, %b
121// CHECK:   ret <8 x i8> [[OR_I]]
122int8x8_t test_vorr_s8(int8x8_t a, int8x8_t b) {
123  return vorr_s8(a, b);
124}
125
126// CHECK-LABEL: define <16 x i8> @test_vorrq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
127// CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, %b
128// CHECK:   ret <16 x i8> [[OR_I]]
129int8x16_t test_vorrq_s8(int8x16_t a, int8x16_t b) {
130  return vorrq_s8(a, b);
131}
132
133// CHECK-LABEL: define <4 x i16> @test_vorr_s16(<4 x i16> %a, <4 x i16> %b) #0 {
134// CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, %b
135// CHECK:   ret <4 x i16> [[OR_I]]
136int16x4_t test_vorr_s16(int16x4_t a, int16x4_t b) {
137  return vorr_s16(a, b);
138}
139
140// CHECK-LABEL: define <8 x i16> @test_vorrq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
141// CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, %b
142// CHECK:   ret <8 x i16> [[OR_I]]
143int16x8_t test_vorrq_s16(int16x8_t a, int16x8_t b) {
144  return vorrq_s16(a, b);
145}
146
147// CHECK-LABEL: define <2 x i32> @test_vorr_s32(<2 x i32> %a, <2 x i32> %b) #0 {
148// CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, %b
149// CHECK:   ret <2 x i32> [[OR_I]]
150int32x2_t test_vorr_s32(int32x2_t a, int32x2_t b) {
151  return vorr_s32(a, b);
152}
153
154// CHECK-LABEL: define <4 x i32> @test_vorrq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
155// CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, %b
156// CHECK:   ret <4 x i32> [[OR_I]]
157int32x4_t test_vorrq_s32(int32x4_t a, int32x4_t b) {
158  return vorrq_s32(a, b);
159}
160
161// CHECK-LABEL: define <1 x i64> @test_vorr_s64(<1 x i64> %a, <1 x i64> %b) #0 {
162// CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, %b
163// CHECK:   ret <1 x i64> [[OR_I]]
164int64x1_t test_vorr_s64(int64x1_t a, int64x1_t b) {
165  return vorr_s64(a, b);
166}
167
168// CHECK-LABEL: define <2 x i64> @test_vorrq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
169// CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, %b
170// CHECK:   ret <2 x i64> [[OR_I]]
171int64x2_t test_vorrq_s64(int64x2_t a, int64x2_t b) {
172  return vorrq_s64(a, b);
173}
174
175// CHECK-LABEL: define <8 x i8> @test_vorr_u8(<8 x i8> %a, <8 x i8> %b) #0 {
176// CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, %b
177// CHECK:   ret <8 x i8> [[OR_I]]
178uint8x8_t test_vorr_u8(uint8x8_t a, uint8x8_t b) {
179  return vorr_u8(a, b);
180}
181
182// CHECK-LABEL: define <16 x i8> @test_vorrq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
183// CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, %b
184// CHECK:   ret <16 x i8> [[OR_I]]
185uint8x16_t test_vorrq_u8(uint8x16_t a, uint8x16_t b) {
186  return vorrq_u8(a, b);
187}
188
189// CHECK-LABEL: define <4 x i16> @test_vorr_u16(<4 x i16> %a, <4 x i16> %b) #0 {
190// CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, %b
191// CHECK:   ret <4 x i16> [[OR_I]]
192uint16x4_t test_vorr_u16(uint16x4_t a, uint16x4_t b) {
193  return vorr_u16(a, b);
194}
195
196// CHECK-LABEL: define <8 x i16> @test_vorrq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
197// CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, %b
198// CHECK:   ret <8 x i16> [[OR_I]]
199uint16x8_t test_vorrq_u16(uint16x8_t a, uint16x8_t b) {
200  return vorrq_u16(a, b);
201}
202
203// CHECK-LABEL: define <2 x i32> @test_vorr_u32(<2 x i32> %a, <2 x i32> %b) #0 {
204// CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, %b
205// CHECK:   ret <2 x i32> [[OR_I]]
206uint32x2_t test_vorr_u32(uint32x2_t a, uint32x2_t b) {
207  return vorr_u32(a, b);
208}
209
210// CHECK-LABEL: define <4 x i32> @test_vorrq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
211// CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, %b
212// CHECK:   ret <4 x i32> [[OR_I]]
213uint32x4_t test_vorrq_u32(uint32x4_t a, uint32x4_t b) {
214  return vorrq_u32(a, b);
215}
216
217// CHECK-LABEL: define <1 x i64> @test_vorr_u64(<1 x i64> %a, <1 x i64> %b) #0 {
218// CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, %b
219// CHECK:   ret <1 x i64> [[OR_I]]
220uint64x1_t test_vorr_u64(uint64x1_t a, uint64x1_t b) {
221  return vorr_u64(a, b);
222}
223
224// CHECK-LABEL: define <2 x i64> @test_vorrq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
225// CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, %b
226// CHECK:   ret <2 x i64> [[OR_I]]
227uint64x2_t test_vorrq_u64(uint64x2_t a, uint64x2_t b) {
228  return vorrq_u64(a, b);
229}
230
231// CHECK-LABEL: define <8 x i8> @test_veor_s8(<8 x i8> %a, <8 x i8> %b) #0 {
232// CHECK:   [[XOR_I:%.*]] = xor <8 x i8> %a, %b
233// CHECK:   ret <8 x i8> [[XOR_I]]
234int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) {
235  return veor_s8(a, b);
236}
237
238// CHECK-LABEL: define <16 x i8> @test_veorq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
239// CHECK:   [[XOR_I:%.*]] = xor <16 x i8> %a, %b
240// CHECK:   ret <16 x i8> [[XOR_I]]
241int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) {
242  return veorq_s8(a, b);
243}
244
245// CHECK-LABEL: define <4 x i16> @test_veor_s16(<4 x i16> %a, <4 x i16> %b) #0 {
246// CHECK:   [[XOR_I:%.*]] = xor <4 x i16> %a, %b
247// CHECK:   ret <4 x i16> [[XOR_I]]
248int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) {
249  return veor_s16(a, b);
250}
251
252// CHECK-LABEL: define <8 x i16> @test_veorq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
253// CHECK:   [[XOR_I:%.*]] = xor <8 x i16> %a, %b
254// CHECK:   ret <8 x i16> [[XOR_I]]
255int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) {
256  return veorq_s16(a, b);
257}
258
259// CHECK-LABEL: define <2 x i32> @test_veor_s32(<2 x i32> %a, <2 x i32> %b) #0 {
260// CHECK:   [[XOR_I:%.*]] = xor <2 x i32> %a, %b
261// CHECK:   ret <2 x i32> [[XOR_I]]
262int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) {
263  return veor_s32(a, b);
264}
265
266// CHECK-LABEL: define <4 x i32> @test_veorq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
267// CHECK:   [[XOR_I:%.*]] = xor <4 x i32> %a, %b
268// CHECK:   ret <4 x i32> [[XOR_I]]
269int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) {
270  return veorq_s32(a, b);
271}
272
273// CHECK-LABEL: define <1 x i64> @test_veor_s64(<1 x i64> %a, <1 x i64> %b) #0 {
274// CHECK:   [[XOR_I:%.*]] = xor <1 x i64> %a, %b
275// CHECK:   ret <1 x i64> [[XOR_I]]
276int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) {
277  return veor_s64(a, b);
278}
279
280// CHECK-LABEL: define <2 x i64> @test_veorq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
281// CHECK:   [[XOR_I:%.*]] = xor <2 x i64> %a, %b
282// CHECK:   ret <2 x i64> [[XOR_I]]
283int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) {
284  return veorq_s64(a, b);
285}
286
287// CHECK-LABEL: define <8 x i8> @test_veor_u8(<8 x i8> %a, <8 x i8> %b) #0 {
288// CHECK:   [[XOR_I:%.*]] = xor <8 x i8> %a, %b
289// CHECK:   ret <8 x i8> [[XOR_I]]
290uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) {
291  return veor_u8(a, b);
292}
293
294// CHECK-LABEL: define <16 x i8> @test_veorq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
295// CHECK:   [[XOR_I:%.*]] = xor <16 x i8> %a, %b
296// CHECK:   ret <16 x i8> [[XOR_I]]
297uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) {
298  return veorq_u8(a, b);
299}
300
301// CHECK-LABEL: define <4 x i16> @test_veor_u16(<4 x i16> %a, <4 x i16> %b) #0 {
302// CHECK:   [[XOR_I:%.*]] = xor <4 x i16> %a, %b
303// CHECK:   ret <4 x i16> [[XOR_I]]
304uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) {
305  return veor_u16(a, b);
306}
307
308// CHECK-LABEL: define <8 x i16> @test_veorq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
309// CHECK:   [[XOR_I:%.*]] = xor <8 x i16> %a, %b
310// CHECK:   ret <8 x i16> [[XOR_I]]
311uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) {
312  return veorq_u16(a, b);
313}
314
315// CHECK-LABEL: define <2 x i32> @test_veor_u32(<2 x i32> %a, <2 x i32> %b) #0 {
316// CHECK:   [[XOR_I:%.*]] = xor <2 x i32> %a, %b
317// CHECK:   ret <2 x i32> [[XOR_I]]
318uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) {
319  return veor_u32(a, b);
320}
321
322// CHECK-LABEL: define <4 x i32> @test_veorq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
323// CHECK:   [[XOR_I:%.*]] = xor <4 x i32> %a, %b
324// CHECK:   ret <4 x i32> [[XOR_I]]
325uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) {
326  return veorq_u32(a, b);
327}
328
329// CHECK-LABEL: define <1 x i64> @test_veor_u64(<1 x i64> %a, <1 x i64> %b) #0 {
330// CHECK:   [[XOR_I:%.*]] = xor <1 x i64> %a, %b
331// CHECK:   ret <1 x i64> [[XOR_I]]
332uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) {
333  return veor_u64(a, b);
334}
335
336// CHECK-LABEL: define <2 x i64> @test_veorq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
337// CHECK:   [[XOR_I:%.*]] = xor <2 x i64> %a, %b
338// CHECK:   ret <2 x i64> [[XOR_I]]
339uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) {
340  return veorq_u64(a, b);
341}
342
343// CHECK-LABEL: define <8 x i8> @test_vbic_s8(<8 x i8> %a, <8 x i8> %b) #0 {
344// CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
345// CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, [[NEG_I]]
346// CHECK:   ret <8 x i8> [[AND_I]]
347int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) {
348  return vbic_s8(a, b);
349}
350
351// CHECK-LABEL: define <16 x i8> @test_vbicq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
352// CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
353// CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, [[NEG_I]]
354// CHECK:   ret <16 x i8> [[AND_I]]
355int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) {
356  return vbicq_s8(a, b);
357}
358
359// CHECK-LABEL: define <4 x i16> @test_vbic_s16(<4 x i16> %a, <4 x i16> %b) #0 {
360// CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
361// CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, [[NEG_I]]
362// CHECK:   ret <4 x i16> [[AND_I]]
363int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) {
364  return vbic_s16(a, b);
365}
366
367// CHECK-LABEL: define <8 x i16> @test_vbicq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
368// CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
369// CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, [[NEG_I]]
370// CHECK:   ret <8 x i16> [[AND_I]]
371int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) {
372  return vbicq_s16(a, b);
373}
374
375// CHECK-LABEL: define <2 x i32> @test_vbic_s32(<2 x i32> %a, <2 x i32> %b) #0 {
376// CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
377// CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, [[NEG_I]]
378// CHECK:   ret <2 x i32> [[AND_I]]
379int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) {
380  return vbic_s32(a, b);
381}
382
383// CHECK-LABEL: define <4 x i32> @test_vbicq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
384// CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
385// CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, [[NEG_I]]
386// CHECK:   ret <4 x i32> [[AND_I]]
387int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) {
388  return vbicq_s32(a, b);
389}
390
391// CHECK-LABEL: define <1 x i64> @test_vbic_s64(<1 x i64> %a, <1 x i64> %b) #0 {
392// CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
393// CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, [[NEG_I]]
394// CHECK:   ret <1 x i64> [[AND_I]]
395int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) {
396  return vbic_s64(a, b);
397}
398
399// CHECK-LABEL: define <2 x i64> @test_vbicq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
400// CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
401// CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, [[NEG_I]]
402// CHECK:   ret <2 x i64> [[AND_I]]
403int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) {
404  return vbicq_s64(a, b);
405}
406
407// CHECK-LABEL: define <8 x i8> @test_vbic_u8(<8 x i8> %a, <8 x i8> %b) #0 {
408// CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
409// CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, [[NEG_I]]
410// CHECK:   ret <8 x i8> [[AND_I]]
411uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) {
412  return vbic_u8(a, b);
413}
414
415// CHECK-LABEL: define <16 x i8> @test_vbicq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
416// CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
417// CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, [[NEG_I]]
418// CHECK:   ret <16 x i8> [[AND_I]]
419uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) {
420  return vbicq_u8(a, b);
421}
422
423// CHECK-LABEL: define <4 x i16> @test_vbic_u16(<4 x i16> %a, <4 x i16> %b) #0 {
424// CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
425// CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, [[NEG_I]]
426// CHECK:   ret <4 x i16> [[AND_I]]
427uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) {
428  return vbic_u16(a, b);
429}
430
431// CHECK-LABEL: define <8 x i16> @test_vbicq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
432// CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
433// CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, [[NEG_I]]
434// CHECK:   ret <8 x i16> [[AND_I]]
435uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) {
436  return vbicq_u16(a, b);
437}
438
439// CHECK-LABEL: define <2 x i32> @test_vbic_u32(<2 x i32> %a, <2 x i32> %b) #0 {
440// CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
441// CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, [[NEG_I]]
442// CHECK:   ret <2 x i32> [[AND_I]]
443uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) {
444  return vbic_u32(a, b);
445}
446
447// CHECK-LABEL: define <4 x i32> @test_vbicq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
448// CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
449// CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, [[NEG_I]]
450// CHECK:   ret <4 x i32> [[AND_I]]
451uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) {
452  return vbicq_u32(a, b);
453}
454
455// CHECK-LABEL: define <1 x i64> @test_vbic_u64(<1 x i64> %a, <1 x i64> %b) #0 {
456// CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
457// CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, [[NEG_I]]
458// CHECK:   ret <1 x i64> [[AND_I]]
459uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) {
460  return vbic_u64(a, b);
461}
462
463// CHECK-LABEL: define <2 x i64> @test_vbicq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
464// CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
465// CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, [[NEG_I]]
466// CHECK:   ret <2 x i64> [[AND_I]]
467uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) {
468  return vbicq_u64(a, b);
469}
470
471// CHECK-LABEL: define <8 x i8> @test_vorn_s8(<8 x i8> %a, <8 x i8> %b) #0 {
472// CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
473// CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, [[NEG_I]]
474// CHECK:   ret <8 x i8> [[OR_I]]
475int8x8_t test_vorn_s8(int8x8_t a, int8x8_t b) {
476  return vorn_s8(a, b);
477}
478
479// CHECK-LABEL: define <16 x i8> @test_vornq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
480// CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
481// CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, [[NEG_I]]
482// CHECK:   ret <16 x i8> [[OR_I]]
483int8x16_t test_vornq_s8(int8x16_t a, int8x16_t b) {
484  return vornq_s8(a, b);
485}
486
487// CHECK-LABEL: define <4 x i16> @test_vorn_s16(<4 x i16> %a, <4 x i16> %b) #0 {
488// CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
489// CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, [[NEG_I]]
490// CHECK:   ret <4 x i16> [[OR_I]]
491int16x4_t test_vorn_s16(int16x4_t a, int16x4_t b) {
492  return vorn_s16(a, b);
493}
494
495// CHECK-LABEL: define <8 x i16> @test_vornq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
496// CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
497// CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, [[NEG_I]]
498// CHECK:   ret <8 x i16> [[OR_I]]
499int16x8_t test_vornq_s16(int16x8_t a, int16x8_t b) {
500  return vornq_s16(a, b);
501}
502
503// CHECK-LABEL: define <2 x i32> @test_vorn_s32(<2 x i32> %a, <2 x i32> %b) #0 {
504// CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
505// CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, [[NEG_I]]
506// CHECK:   ret <2 x i32> [[OR_I]]
507int32x2_t test_vorn_s32(int32x2_t a, int32x2_t b) {
508  return vorn_s32(a, b);
509}
510
511// CHECK-LABEL: define <4 x i32> @test_vornq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
512// CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
513// CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, [[NEG_I]]
514// CHECK:   ret <4 x i32> [[OR_I]]
515int32x4_t test_vornq_s32(int32x4_t a, int32x4_t b) {
516  return vornq_s32(a, b);
517}
518
519// CHECK-LABEL: define <1 x i64> @test_vorn_s64(<1 x i64> %a, <1 x i64> %b) #0 {
520// CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
521// CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, [[NEG_I]]
522// CHECK:   ret <1 x i64> [[OR_I]]
523int64x1_t test_vorn_s64(int64x1_t a, int64x1_t b) {
524  return vorn_s64(a, b);
525}
526
527// CHECK-LABEL: define <2 x i64> @test_vornq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
528// CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
529// CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, [[NEG_I]]
530// CHECK:   ret <2 x i64> [[OR_I]]
531int64x2_t test_vornq_s64(int64x2_t a, int64x2_t b) {
532  return vornq_s64(a, b);
533}
534
535// CHECK-LABEL: define <8 x i8> @test_vorn_u8(<8 x i8> %a, <8 x i8> %b) #0 {
536// CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
537// CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, [[NEG_I]]
538// CHECK:   ret <8 x i8> [[OR_I]]
539uint8x8_t test_vorn_u8(uint8x8_t a, uint8x8_t b) {
540  return vorn_u8(a, b);
541}
542
543// CHECK-LABEL: define <16 x i8> @test_vornq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
544// CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
545// CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, [[NEG_I]]
546// CHECK:   ret <16 x i8> [[OR_I]]
547uint8x16_t test_vornq_u8(uint8x16_t a, uint8x16_t b) {
548  return vornq_u8(a, b);
549}
550
551// CHECK-LABEL: define <4 x i16> @test_vorn_u16(<4 x i16> %a, <4 x i16> %b) #0 {
552// CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
553// CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, [[NEG_I]]
554// CHECK:   ret <4 x i16> [[OR_I]]
555uint16x4_t test_vorn_u16(uint16x4_t a, uint16x4_t b) {
556  return vorn_u16(a, b);
557}
558
559// CHECK-LABEL: define <8 x i16> @test_vornq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
560// CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
561// CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, [[NEG_I]]
562// CHECK:   ret <8 x i16> [[OR_I]]
563uint16x8_t test_vornq_u16(uint16x8_t a, uint16x8_t b) {
564  return vornq_u16(a, b);
565}
566
567// CHECK-LABEL: define <2 x i32> @test_vorn_u32(<2 x i32> %a, <2 x i32> %b) #0 {
568// CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
569// CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, [[NEG_I]]
570// CHECK:   ret <2 x i32> [[OR_I]]
571uint32x2_t test_vorn_u32(uint32x2_t a, uint32x2_t b) {
572  return vorn_u32(a, b);
573}
574
575// CHECK-LABEL: define <4 x i32> @test_vornq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
576// CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
577// CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, [[NEG_I]]
578// CHECK:   ret <4 x i32> [[OR_I]]
579uint32x4_t test_vornq_u32(uint32x4_t a, uint32x4_t b) {
580  return vornq_u32(a, b);
581}
582
583// CHECK-LABEL: define <1 x i64> @test_vorn_u64(<1 x i64> %a, <1 x i64> %b) #0 {
584// CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
585// CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, [[NEG_I]]
586// CHECK:   ret <1 x i64> [[OR_I]]
587uint64x1_t test_vorn_u64(uint64x1_t a, uint64x1_t b) {
588  return vorn_u64(a, b);
589}
590
591// CHECK-LABEL: define <2 x i64> @test_vornq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
592// CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
593// CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, [[NEG_I]]
594// CHECK:   ret <2 x i64> [[OR_I]]
595uint64x2_t test_vornq_u64(uint64x2_t a, uint64x2_t b) {
596  return vornq_u64(a, b);
597}
598
599// CHECK: attributes #0 ={{.*}}"min-legal-vector-width"="64"
600// CHECK: attributes #1 ={{.*}}"min-legal-vector-width"="128"
601
CodeThinker, Enjoy your reading code