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]]
test_vand_s8(int8x8_t a,int8x8_t b)10 int8x8_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]]
test_vandq_s8(int8x16_t a,int8x16_t b)17 int8x16_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]]
test_vand_s16(int16x4_t a,int16x4_t b)24 int16x4_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]]
test_vandq_s16(int16x8_t a,int16x8_t b)31 int16x8_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]]
test_vand_s32(int32x2_t a,int32x2_t b)38 int32x2_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]]
test_vandq_s32(int32x4_t a,int32x4_t b)45 int32x4_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]]
test_vand_s64(int64x1_t a,int64x1_t b)52 int64x1_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]]
test_vandq_s64(int64x2_t a,int64x2_t b)59 int64x2_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]]
test_vand_u8(uint8x8_t a,uint8x8_t b)66 uint8x8_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]]
test_vandq_u8(uint8x16_t a,uint8x16_t b)73 uint8x16_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]]
test_vand_u16(uint16x4_t a,uint16x4_t b)80 uint16x4_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]]
test_vandq_u16(uint16x8_t a,uint16x8_t b)87 uint16x8_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]]
test_vand_u32(uint32x2_t a,uint32x2_t b)94 uint32x2_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]]
test_vandq_u32(uint32x4_t a,uint32x4_t b)101 uint32x4_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]]
test_vand_u64(uint64x1_t a,uint64x1_t b)108 uint64x1_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]]
test_vandq_u64(uint64x2_t a,uint64x2_t b)115 uint64x2_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]]
test_vorr_s8(int8x8_t a,int8x8_t b)122 int8x8_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]]
test_vorrq_s8(int8x16_t a,int8x16_t b)129 int8x16_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]]
test_vorr_s16(int16x4_t a,int16x4_t b)136 int16x4_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]]
test_vorrq_s16(int16x8_t a,int16x8_t b)143 int16x8_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]]
test_vorr_s32(int32x2_t a,int32x2_t b)150 int32x2_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]]
test_vorrq_s32(int32x4_t a,int32x4_t b)157 int32x4_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]]
test_vorr_s64(int64x1_t a,int64x1_t b)164 int64x1_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]]
test_vorrq_s64(int64x2_t a,int64x2_t b)171 int64x2_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]]
test_vorr_u8(uint8x8_t a,uint8x8_t b)178 uint8x8_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]]
test_vorrq_u8(uint8x16_t a,uint8x16_t b)185 uint8x16_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]]
test_vorr_u16(uint16x4_t a,uint16x4_t b)192 uint16x4_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]]
test_vorrq_u16(uint16x8_t a,uint16x8_t b)199 uint16x8_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]]
test_vorr_u32(uint32x2_t a,uint32x2_t b)206 uint32x2_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]]
test_vorrq_u32(uint32x4_t a,uint32x4_t b)213 uint32x4_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]]
test_vorr_u64(uint64x1_t a,uint64x1_t b)220 uint64x1_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]]
test_vorrq_u64(uint64x2_t a,uint64x2_t b)227 uint64x2_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]]
test_veor_s8(int8x8_t a,int8x8_t b)234 int8x8_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]]
test_veorq_s8(int8x16_t a,int8x16_t b)241 int8x16_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]]
test_veor_s16(int16x4_t a,int16x4_t b)248 int16x4_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]]
test_veorq_s16(int16x8_t a,int16x8_t b)255 int16x8_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]]
test_veor_s32(int32x2_t a,int32x2_t b)262 int32x2_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]]
test_veorq_s32(int32x4_t a,int32x4_t b)269 int32x4_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]]
test_veor_s64(int64x1_t a,int64x1_t b)276 int64x1_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]]
test_veorq_s64(int64x2_t a,int64x2_t b)283 int64x2_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]]
test_veor_u8(uint8x8_t a,uint8x8_t b)290 uint8x8_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]]
test_veorq_u8(uint8x16_t a,uint8x16_t b)297 uint8x16_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]]
test_veor_u16(uint16x4_t a,uint16x4_t b)304 uint16x4_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]]
test_veorq_u16(uint16x8_t a,uint16x8_t b)311 uint16x8_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]]
test_veor_u32(uint32x2_t a,uint32x2_t b)318 uint32x2_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]]
test_veorq_u32(uint32x4_t a,uint32x4_t b)325 uint32x4_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]]
test_veor_u64(uint64x1_t a,uint64x1_t b)332 uint64x1_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]]
test_veorq_u64(uint64x2_t a,uint64x2_t b)339 uint64x2_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]]
test_vbic_s8(int8x8_t a,int8x8_t b)347 int8x8_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]]
test_vbicq_s8(int8x16_t a,int8x16_t b)355 int8x16_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]]
test_vbic_s16(int16x4_t a,int16x4_t b)363 int16x4_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]]
test_vbicq_s16(int16x8_t a,int16x8_t b)371 int16x8_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]]
test_vbic_s32(int32x2_t a,int32x2_t b)379 int32x2_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]]
test_vbicq_s32(int32x4_t a,int32x4_t b)387 int32x4_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]]
test_vbic_s64(int64x1_t a,int64x1_t b)395 int64x1_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]]
test_vbicq_s64(int64x2_t a,int64x2_t b)403 int64x2_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]]
test_vbic_u8(uint8x8_t a,uint8x8_t b)411 uint8x8_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]]
test_vbicq_u8(uint8x16_t a,uint8x16_t b)419 uint8x16_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]]
test_vbic_u16(uint16x4_t a,uint16x4_t b)427 uint16x4_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]]
test_vbicq_u16(uint16x8_t a,uint16x8_t b)435 uint16x8_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]]
test_vbic_u32(uint32x2_t a,uint32x2_t b)443 uint32x2_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]]
test_vbicq_u32(uint32x4_t a,uint32x4_t b)451 uint32x4_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]]
test_vbic_u64(uint64x1_t a,uint64x1_t b)459 uint64x1_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]]
test_vbicq_u64(uint64x2_t a,uint64x2_t b)467 uint64x2_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]]
test_vorn_s8(int8x8_t a,int8x8_t b)475 int8x8_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]]
test_vornq_s8(int8x16_t a,int8x16_t b)483 int8x16_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]]
test_vorn_s16(int16x4_t a,int16x4_t b)491 int16x4_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]]
test_vornq_s16(int16x8_t a,int16x8_t b)499 int16x8_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]]
test_vorn_s32(int32x2_t a,int32x2_t b)507 int32x2_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]]
test_vornq_s32(int32x4_t a,int32x4_t b)515 int32x4_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]]
test_vorn_s64(int64x1_t a,int64x1_t b)523 int64x1_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]]
test_vornq_s64(int64x2_t a,int64x2_t b)531 int64x2_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]]
test_vorn_u8(uint8x8_t a,uint8x8_t b)539 uint8x8_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]]
test_vornq_u8(uint8x16_t a,uint8x16_t b)547 uint8x16_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]]
test_vorn_u16(uint16x4_t a,uint16x4_t b)555 uint16x4_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]]
test_vornq_u16(uint16x8_t a,uint16x8_t b)563 uint16x8_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]]
test_vorn_u32(uint32x2_t a,uint32x2_t b)571 uint32x2_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]]
test_vornq_u32(uint32x4_t a,uint32x4_t b)579 uint32x4_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]]
test_vorn_u64(uint64x1_t a,uint64x1_t b)587 uint64x1_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]]
test_vornq_u64(uint64x2_t a,uint64x2_t b)595 uint64x2_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