llvm.org GIT mirror llvm / 4a2d958
Add a bunch of CHECK missing colons in tests. NFC. Some wouldn't pass; fixed most, the rest will be fixed separately. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232239 91177308-0d34-0410-b5e6-96231b3b80d8 Ahmed Bougacha 4 years ago
9 changed file(s) with 189 addition(s) and 188 deletion(s). Raw diff Collapse all Expand all
169169 %data = alloca <4 x float>, align 16
170170 %0 = load <4 x float>, <4 x float>* %data, align 16
171171 call void asm sideeffect "mov.2d v4, $0\0A", "x,~{v4}"(<4 x float> %0) nounwind
172 ; CHECK mov.2d v4, {{v([0-9])|(1[0-5])}}
172 ; CHECK: mov.2d v4, {{v([0-9])|(1[0-5])}}
173173 ret void
174174 }
175175
None ; RUN: llc < %s -march=arm64 -aarch64-neon-syntax=apple -verify-machineinstrs | FileCheck %s
0 ; RUN: llc < %s -march=arm64 -aarch64-neon-syntax=apple -verify-machineinstrs -asm-verbose=false | FileCheck %s
11
22 %struct.__neon_int8x8x2_t = type { <8 x i8>, <8 x i8> }
33 %struct.__neon_int8x8x3_t = type { <8 x i8>, <8 x i8>, <8 x i8> }
77 ; CHECK-LABEL: ld2_8b
88 ; Make sure we are loading into the results defined by the ABI (i.e., v0, v1)
99 ; and from the argument of the function also defined by ABI (i.e., x0)
10 ; CHECK ld2.8b { v0, v1 }, [x0]
11 ; CHECK-NEXT ret
10 ; CHECK: ld2.8b { v0, v1 }, [x0]
11 ; CHECK-NEXT: ret
1212 %tmp2 = call %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2.v8i8.p0i8(i8* %A)
1313 ret %struct.__neon_int8x8x2_t %tmp2
1414 }
1616 define %struct.__neon_int8x8x3_t @ld3_8b(i8* %A) nounwind {
1717 ; CHECK-LABEL: ld3_8b
1818 ; Make sure we are using the operands defined by the ABI
19 ; CHECK ld3.8b { v0, v1, v2 }, [x0]
20 ; CHECK-NEXT ret
19 ; CHECK: ld3.8b { v0, v1, v2 }, [x0]
20 ; CHECK-NEXT: ret
2121 %tmp2 = call %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld3.v8i8.p0i8(i8* %A)
2222 ret %struct.__neon_int8x8x3_t %tmp2
2323 }
2525 define %struct.__neon_int8x8x4_t @ld4_8b(i8* %A) nounwind {
2626 ; CHECK-LABEL: ld4_8b
2727 ; Make sure we are using the operands defined by the ABI
28 ; CHECK ld4.8b { v0, v1, v2, v3 }, [x0]
29 ; CHECK-NEXT ret
28 ; CHECK: ld4.8b { v0, v1, v2, v3 }, [x0]
29 ; CHECK-NEXT: ret
3030 %tmp2 = call %struct.__neon_int8x8x4_t @llvm.aarch64.neon.ld4.v8i8.p0i8(i8* %A)
3131 ret %struct.__neon_int8x8x4_t %tmp2
3232 }
4242 define %struct.__neon_int8x16x2_t @ld2_16b(i8* %A) nounwind {
4343 ; CHECK-LABEL: ld2_16b
4444 ; Make sure we are using the operands defined by the ABI
45 ; CHECK ld2.16b { v0, v1 }, [x0]
46 ; CHECK-NEXT ret
45 ; CHECK: ld2.16b { v0, v1 }, [x0]
46 ; CHECK-NEXT: ret
4747 %tmp2 = call %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2.v16i8.p0i8(i8* %A)
4848 ret %struct.__neon_int8x16x2_t %tmp2
4949 }
5151 define %struct.__neon_int8x16x3_t @ld3_16b(i8* %A) nounwind {
5252 ; CHECK-LABEL: ld3_16b
5353 ; Make sure we are using the operands defined by the ABI
54 ; CHECK ld3.16b { v0, v1, v2 }, [x0]
55 ; CHECK-NEXT ret
54 ; CHECK: ld3.16b { v0, v1, v2 }, [x0]
55 ; CHECK-NEXT: ret
5656 %tmp2 = call %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3.v16i8.p0i8(i8* %A)
5757 ret %struct.__neon_int8x16x3_t %tmp2
5858 }
6060 define %struct.__neon_int8x16x4_t @ld4_16b(i8* %A) nounwind {
6161 ; CHECK-LABEL: ld4_16b
6262 ; Make sure we are using the operands defined by the ABI
63 ; CHECK ld4.16b { v0, v1, v2, v3 }, [x0]
64 ; CHECK-NEXT ret
63 ; CHECK: ld4.16b { v0, v1, v2, v3 }, [x0]
64 ; CHECK-NEXT: ret
6565 %tmp2 = call %struct.__neon_int8x16x4_t @llvm.aarch64.neon.ld4.v16i8.p0i8(i8* %A)
6666 ret %struct.__neon_int8x16x4_t %tmp2
6767 }
7777 define %struct.__neon_int16x4x2_t @ld2_4h(i16* %A) nounwind {
7878 ; CHECK-LABEL: ld2_4h
7979 ; Make sure we are using the operands defined by the ABI
80 ; CHECK ld2.4h { v0, v1 }, [x0]
81 ; CHECK-NEXT ret
80 ; CHECK: ld2.4h { v0, v1 }, [x0]
81 ; CHECK-NEXT: ret
8282 %tmp2 = call %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld2.v4i16.p0i16(i16* %A)
8383 ret %struct.__neon_int16x4x2_t %tmp2
8484 }
8686 define %struct.__neon_int16x4x3_t @ld3_4h(i16* %A) nounwind {
8787 ; CHECK-LABEL: ld3_4h
8888 ; Make sure we are using the operands defined by the ABI
89 ; CHECK ld3.4h { v0, v1, v2 }, [x0]
90 ; CHECK-NEXT ret
89 ; CHECK: ld3.4h { v0, v1, v2 }, [x0]
90 ; CHECK-NEXT: ret
9191 %tmp2 = call %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld3.v4i16.p0i16(i16* %A)
9292 ret %struct.__neon_int16x4x3_t %tmp2
9393 }
9595 define %struct.__neon_int16x4x4_t @ld4_4h(i16* %A) nounwind {
9696 ; CHECK-LABEL: ld4_4h
9797 ; Make sure we are using the operands defined by the ABI
98 ; CHECK ld4.4h { v0, v1, v2, v3 }, [x0]
99 ; CHECK-NEXT ret
98 ; CHECK: ld4.4h { v0, v1, v2, v3 }, [x0]
99 ; CHECK-NEXT: ret
100100 %tmp2 = call %struct.__neon_int16x4x4_t @llvm.aarch64.neon.ld4.v4i16.p0i16(i16* %A)
101101 ret %struct.__neon_int16x4x4_t %tmp2
102102 }
112112 define %struct.__neon_int16x8x2_t @ld2_8h(i16* %A) nounwind {
113113 ; CHECK-LABEL: ld2_8h
114114 ; Make sure we are using the operands defined by the ABI
115 ; CHECK ld2.8h { v0, v1 }, [x0]
116 ; CHECK-NEXT ret
115 ; CHECK: ld2.8h { v0, v1 }, [x0]
116 ; CHECK-NEXT: ret
117117 %tmp2 = call %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2.v8i16.p0i16(i16* %A)
118118 ret %struct.__neon_int16x8x2_t %tmp2
119119 }
121121 define %struct.__neon_int16x8x3_t @ld3_8h(i16* %A) nounwind {
122122 ; CHECK-LABEL: ld3_8h
123123 ; Make sure we are using the operands defined by the ABI
124 ; CHECK ld3.8h { v0, v1, v2 }, [x0]
125 ; CHECK-NEXT ret
124 ; CHECK: ld3.8h { v0, v1, v2 }, [x0]
125 ; CHECK-NEXT: ret
126126 %tmp2 = call %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3.v8i16.p0i16(i16* %A)
127127 ret %struct.__neon_int16x8x3_t %tmp2
128128 }
130130 define %struct.__neon_int16x8x4_t @ld4_8h(i16* %A) nounwind {
131131 ; CHECK-LABEL: ld4_8h
132132 ; Make sure we are using the operands defined by the ABI
133 ; CHECK ld4.8h { v0, v1, v2, v3 }, [x0]
134 ; CHECK-NEXT ret
133 ; CHECK: ld4.8h { v0, v1, v2, v3 }, [x0]
134 ; CHECK-NEXT: ret
135135 %tmp2 = call %struct.__neon_int16x8x4_t @llvm.aarch64.neon.ld4.v8i16.p0i16(i16* %A)
136136 ret %struct.__neon_int16x8x4_t %tmp2
137137 }
147147 define %struct.__neon_int32x2x2_t @ld2_2s(i32* %A) nounwind {
148148 ; CHECK-LABEL: ld2_2s
149149 ; Make sure we are using the operands defined by the ABI
150 ; CHECK ld2.2s { v0, v1 }, [x0]
151 ; CHECK-NEXT ret
150 ; CHECK: ld2.2s { v0, v1 }, [x0]
151 ; CHECK-NEXT: ret
152152 %tmp2 = call %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld2.v2i32.p0i32(i32* %A)
153153 ret %struct.__neon_int32x2x2_t %tmp2
154154 }
156156 define %struct.__neon_int32x2x3_t @ld3_2s(i32* %A) nounwind {
157157 ; CHECK-LABEL: ld3_2s
158158 ; Make sure we are using the operands defined by the ABI
159 ; CHECK ld3.2s { v0, v1, v2 }, [x0]
160 ; CHECK-NEXT ret
159 ; CHECK: ld3.2s { v0, v1, v2 }, [x0]
160 ; CHECK-NEXT: ret
161161 %tmp2 = call %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld3.v2i32.p0i32(i32* %A)
162162 ret %struct.__neon_int32x2x3_t %tmp2
163163 }
165165 define %struct.__neon_int32x2x4_t @ld4_2s(i32* %A) nounwind {
166166 ; CHECK-LABEL: ld4_2s
167167 ; Make sure we are using the operands defined by the ABI
168 ; CHECK ld4.2s { v0, v1, v2, v3 }, [x0]
169 ; CHECK-NEXT ret
168 ; CHECK: ld4.2s { v0, v1, v2, v3 }, [x0]
169 ; CHECK-NEXT: ret
170170 %tmp2 = call %struct.__neon_int32x2x4_t @llvm.aarch64.neon.ld4.v2i32.p0i32(i32* %A)
171171 ret %struct.__neon_int32x2x4_t %tmp2
172172 }
182182 define %struct.__neon_int32x4x2_t @ld2_4s(i32* %A) nounwind {
183183 ; CHECK-LABEL: ld2_4s
184184 ; Make sure we are using the operands defined by the ABI
185 ; CHECK ld2.4s { v0, v1 }, [x0]
186 ; CHECK-NEXT ret
185 ; CHECK: ld2.4s { v0, v1 }, [x0]
186 ; CHECK-NEXT: ret
187187 %tmp2 = call %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2.v4i32.p0i32(i32* %A)
188188 ret %struct.__neon_int32x4x2_t %tmp2
189189 }
191191 define %struct.__neon_int32x4x3_t @ld3_4s(i32* %A) nounwind {
192192 ; CHECK-LABEL: ld3_4s
193193 ; Make sure we are using the operands defined by the ABI
194 ; CHECK ld3.4s { v0, v1, v2 }, [x0]
195 ; CHECK-NEXT ret
194 ; CHECK: ld3.4s { v0, v1, v2 }, [x0]
195 ; CHECK-NEXT: ret
196196 %tmp2 = call %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3.v4i32.p0i32(i32* %A)
197197 ret %struct.__neon_int32x4x3_t %tmp2
198198 }
200200 define %struct.__neon_int32x4x4_t @ld4_4s(i32* %A) nounwind {
201201 ; CHECK-LABEL: ld4_4s
202202 ; Make sure we are using the operands defined by the ABI
203 ; CHECK ld4.4s { v0, v1, v2, v3 }, [x0]
204 ; CHECK-NEXT ret
203 ; CHECK: ld4.4s { v0, v1, v2, v3 }, [x0]
204 ; CHECK-NEXT: ret
205205 %tmp2 = call %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld4.v4i32.p0i32(i32* %A)
206206 ret %struct.__neon_int32x4x4_t %tmp2
207207 }
217217 define %struct.__neon_int64x2x2_t @ld2_2d(i64* %A) nounwind {
218218 ; CHECK-LABEL: ld2_2d
219219 ; Make sure we are using the operands defined by the ABI
220 ; CHECK ld2.2d { v0, v1 }, [x0]
221 ; CHECK-NEXT ret
220 ; CHECK: ld2.2d { v0, v1 }, [x0]
221 ; CHECK-NEXT: ret
222222 %tmp2 = call %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2.v2i64.p0i64(i64* %A)
223223 ret %struct.__neon_int64x2x2_t %tmp2
224224 }
226226 define %struct.__neon_int64x2x3_t @ld3_2d(i64* %A) nounwind {
227227 ; CHECK-LABEL: ld3_2d
228228 ; Make sure we are using the operands defined by the ABI
229 ; CHECK ld3.2d { v0, v1, v2 }, [x0]
230 ; CHECK-NEXT ret
229 ; CHECK: ld3.2d { v0, v1, v2 }, [x0]
230 ; CHECK-NEXT: ret
231231 %tmp2 = call %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3.v2i64.p0i64(i64* %A)
232232 ret %struct.__neon_int64x2x3_t %tmp2
233233 }
235235 define %struct.__neon_int64x2x4_t @ld4_2d(i64* %A) nounwind {
236236 ; CHECK-LABEL: ld4_2d
237237 ; Make sure we are using the operands defined by the ABI
238 ; CHECK ld4.2d { v0, v1, v2, v3 }, [x0]
239 ; CHECK-NEXT ret
238 ; CHECK: ld4.2d { v0, v1, v2, v3 }, [x0]
239 ; CHECK-NEXT: ret
240240 %tmp2 = call %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld4.v2i64.p0i64(i64* %A)
241241 ret %struct.__neon_int64x2x4_t %tmp2
242242 }
253253 define %struct.__neon_int64x1x2_t @ld2_1di64(i64* %A) nounwind {
254254 ; CHECK-LABEL: ld2_1di64
255255 ; Make sure we are using the operands defined by the ABI
256 ; CHECK ld1.1d { v0, v1 }, [x0]
257 ; CHECK-NEXT ret
256 ; CHECK: ld1.1d { v0, v1 }, [x0]
257 ; CHECK-NEXT: ret
258258 %tmp2 = call %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld2.v1i64.p0i64(i64* %A)
259259 ret %struct.__neon_int64x1x2_t %tmp2
260260 }
262262 define %struct.__neon_int64x1x3_t @ld3_1di64(i64* %A) nounwind {
263263 ; CHECK-LABEL: ld3_1di64
264264 ; Make sure we are using the operands defined by the ABI
265 ; CHECK ld1.1d { v0, v1, v2 }, [x0]
266 ; CHECK-NEXT ret
265 ; CHECK: ld1.1d { v0, v1, v2 }, [x0]
266 ; CHECK-NEXT: ret
267267 %tmp2 = call %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld3.v1i64.p0i64(i64* %A)
268268 ret %struct.__neon_int64x1x3_t %tmp2
269269 }
271271 define %struct.__neon_int64x1x4_t @ld4_1di64(i64* %A) nounwind {
272272 ; CHECK-LABEL: ld4_1di64
273273 ; Make sure we are using the operands defined by the ABI
274 ; CHECK ld1.1d { v0, v1, v2, v3 }, [x0]
275 ; CHECK-NEXT ret
274 ; CHECK: ld1.1d { v0, v1, v2, v3 }, [x0]
275 ; CHECK-NEXT: ret
276276 %tmp2 = call %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld4.v1i64.p0i64(i64* %A)
277277 ret %struct.__neon_int64x1x4_t %tmp2
278278 }
290290 define %struct.__neon_float64x1x2_t @ld2_1df64(double* %A) nounwind {
291291 ; CHECK-LABEL: ld2_1df64
292292 ; Make sure we are using the operands defined by the ABI
293 ; CHECK ld1.1d { v0, v1 }, [x0]
294 ; CHECK-NEXT ret
293 ; CHECK: ld1.1d { v0, v1 }, [x0]
294 ; CHECK-NEXT: ret
295295 %tmp2 = call %struct.__neon_float64x1x2_t @llvm.aarch64.neon.ld2.v1f64.p0f64(double* %A)
296296 ret %struct.__neon_float64x1x2_t %tmp2
297297 }
299299 define %struct.__neon_float64x1x3_t @ld3_1df64(double* %A) nounwind {
300300 ; CHECK-LABEL: ld3_1df64
301301 ; Make sure we are using the operands defined by the ABI
302 ; CHECK ld1.1d { v0, v1, v2 }, [x0]
303 ; CHECK-NEXT ret
302 ; CHECK: ld1.1d { v0, v1, v2 }, [x0]
303 ; CHECK-NEXT: ret
304304 %tmp2 = call %struct.__neon_float64x1x3_t @llvm.aarch64.neon.ld3.v1f64.p0f64(double* %A)
305305 ret %struct.__neon_float64x1x3_t %tmp2
306306 }
308308 define %struct.__neon_float64x1x4_t @ld4_1df64(double* %A) nounwind {
309309 ; CHECK-LABEL: ld4_1df64
310310 ; Make sure we are using the operands defined by the ABI
311 ; CHECK ld1.1d { v0, v1, v2, v3 }, [x0]
312 ; CHECK-NEXT ret
311 ; CHECK: ld1.1d { v0, v1, v2, v3 }, [x0]
312 ; CHECK-NEXT: ret
313313 %tmp2 = call %struct.__neon_float64x1x4_t @llvm.aarch64.neon.ld4.v1f64.p0f64(double* %A)
314314 ret %struct.__neon_float64x1x4_t %tmp2
315315 }
322322 define %struct.__neon_int8x16x2_t @ld2lane_16b(<16 x i8> %L1, <16 x i8> %L2, i8* %A) nounwind {
323323 ; Make sure we are using the operands defined by the ABI
324324 ; CHECK: ld2lane_16b
325 ; CHECK ld2.b { v0, v1 }[1], [x0]
326 ; CHECK-NEXT ret
325 ; CHECK: ld2.b { v0, v1 }[1], [x0]
326 ; CHECK-NEXT: ret
327327 %tmp2 = call %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, i64 1, i8* %A)
328328 ret %struct.__neon_int8x16x2_t %tmp2
329329 }
331331 define %struct.__neon_int8x16x3_t @ld3lane_16b(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, i8* %A) nounwind {
332332 ; Make sure we are using the operands defined by the ABI
333333 ; CHECK: ld3lane_16b
334 ; CHECK ld3.b { v0, v1, v2 }[1], [x0]
335 ; CHECK-NEXT ret
334 ; CHECK: ld3.b { v0, v1, v2 }[1], [x0]
335 ; CHECK-NEXT: ret
336336 %tmp2 = call %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, i64 1, i8* %A)
337337 ret %struct.__neon_int8x16x3_t %tmp2
338338 }
340340 define %struct.__neon_int8x16x4_t @ld4lane_16b(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, <16 x i8> %L4, i8* %A) nounwind {
341341 ; Make sure we are using the operands defined by the ABI
342342 ; CHECK: ld4lane_16b
343 ; CHECK ld4.b { v0, v1, v2, v3 }[1], [x0]
344 ; CHECK-NEXT ret
343 ; CHECK: ld4.b { v0, v1, v2, v3 }[1], [x0]
344 ; CHECK-NEXT: ret
345345 %tmp2 = call %struct.__neon_int8x16x4_t @llvm.aarch64.neon.ld4lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, <16 x i8> %L4, i64 1, i8* %A)
346346 ret %struct.__neon_int8x16x4_t %tmp2
347347 }
353353 define %struct.__neon_int16x8x2_t @ld2lane_8h(<8 x i16> %L1, <8 x i16> %L2, i16* %A) nounwind {
354354 ; Make sure we are using the operands defined by the ABI
355355 ; CHECK: ld2lane_8h
356 ; CHECK ld2.h { v0, v1 }[1], [x0]
357 ; CHECK-NEXT ret
356 ; CHECK: ld2.h { v0, v1 }[1], [x0]
357 ; CHECK-NEXT: ret
358358 %tmp2 = call %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, i64 1, i16* %A)
359359 ret %struct.__neon_int16x8x2_t %tmp2
360360 }
362362 define %struct.__neon_int16x8x3_t @ld3lane_8h(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, i16* %A) nounwind {
363363 ; Make sure we are using the operands defined by the ABI
364364 ; CHECK: ld3lane_8h
365 ; CHECK ld3.h { v0, v1, v3 }[1], [x0]
366 ; CHECK-NEXT ret
365 ; CHECK: ld3.h { v0, v1, v2 }[1], [x0]
366 ; CHECK-NEXT: ret
367367 %tmp2 = call %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, i64 1, i16* %A)
368368 ret %struct.__neon_int16x8x3_t %tmp2
369369 }
371371 define %struct.__neon_int16x8x4_t @ld4lane_8h(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, <8 x i16> %L4, i16* %A) nounwind {
372372 ; Make sure we are using the operands defined by the ABI
373373 ; CHECK: ld4lane_8h
374 ; CHECK ld4.h { v0, v1, v2, v3 }[1], [x0]
375 ; CHECK-NEXT ret
374 ; CHECK: ld4.h { v0, v1, v2, v3 }[1], [x0]
375 ; CHECK-NEXT: ret
376376 %tmp2 = call %struct.__neon_int16x8x4_t @llvm.aarch64.neon.ld4lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, <8 x i16> %L4, i64 1, i16* %A)
377377 ret %struct.__neon_int16x8x4_t %tmp2
378378 }
384384 define %struct.__neon_int32x4x2_t @ld2lane_4s(<4 x i32> %L1, <4 x i32> %L2, i32* %A) nounwind {
385385 ; Make sure we are using the operands defined by the ABI
386386 ; CHECK: ld2lane_4s
387 ; CHECK ld2.s { v0, v1 }[1], [x0]
388 ; CHECK-NEXT ret
387 ; CHECK: ld2.s { v0, v1 }[1], [x0]
388 ; CHECK-NEXT: ret
389389 %tmp2 = call %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, i64 1, i32* %A)
390390 ret %struct.__neon_int32x4x2_t %tmp2
391391 }
393393 define %struct.__neon_int32x4x3_t @ld3lane_4s(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, i32* %A) nounwind {
394394 ; Make sure we are using the operands defined by the ABI
395395 ; CHECK: ld3lane_4s
396 ; CHECK ld3.s { v0, v1, v2 }[1], [x0]
397 ; CHECK-NEXT ret
396 ; CHECK: ld3.s { v0, v1, v2 }[1], [x0]
397 ; CHECK-NEXT: ret
398398 %tmp2 = call %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, i64 1, i32* %A)
399399 ret %struct.__neon_int32x4x3_t %tmp2
400400 }
402402 define %struct.__neon_int32x4x4_t @ld4lane_4s(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, <4 x i32> %L4, i32* %A) nounwind {
403403 ; Make sure we are using the operands defined by the ABI
404404 ; CHECK: ld4lane_4s
405 ; CHECK ld4.s { v0, v1, v2, v3 }[1], [x0]
406 ; CHECK-NEXT ret
405 ; CHECK: ld4.s { v0, v1, v2, v3 }[1], [x0]
406 ; CHECK-NEXT: ret
407407 %tmp2 = call %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld4lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, <4 x i32> %L4, i64 1, i32* %A)
408408 ret %struct.__neon_int32x4x4_t %tmp2
409409 }
415415 define %struct.__neon_int64x2x2_t @ld2lane_2d(<2 x i64> %L1, <2 x i64> %L2, i64* %A) nounwind {
416416 ; Make sure we are using the operands defined by the ABI
417417 ; CHECK: ld2lane_2d
418 ; CHECK ld2.d { v0, v1 }[1], [x0]
419 ; CHECK-NEXT ret
418 ; CHECK: ld2.d { v0, v1 }[1], [x0]
419 ; CHECK-NEXT: ret
420420 %tmp2 = call %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, i64 1, i64* %A)
421421 ret %struct.__neon_int64x2x2_t %tmp2
422422 }
424424 define %struct.__neon_int64x2x3_t @ld3lane_2d(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, i64* %A) nounwind {
425425 ; Make sure we are using the operands defined by the ABI
426426 ; CHECK: ld3lane_2d
427 ; CHECK ld3.d { v0, v1, v3 }[1], [x0]
428 ; CHECK-NEXT ret
427 ; CHECK: ld3.d { v0, v1, v2 }[1], [x0]
428 ; CHECK-NEXT: ret
429429 %tmp2 = call %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, i64 1, i64* %A)
430430 ret %struct.__neon_int64x2x3_t %tmp2
431431 }
433433 define %struct.__neon_int64x2x4_t @ld4lane_2d(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, <2 x i64> %L4, i64* %A) nounwind {
434434 ; Make sure we are using the operands defined by the ABI
435435 ; CHECK: ld4lane_2d
436 ; CHECK ld4.d { v0, v1, v2, v3 }[1], [x0]
437 ; CHECK-NEXT ret
436 ; CHECK: ld4.d { v0, v1, v2, v3 }[1], [x0]
437 ; CHECK-NEXT: ret
438438 %tmp2 = call %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld4lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, <2 x i64> %L4, i64 1, i64* %A)
439439 ret %struct.__neon_int64x2x4_t %tmp2
440440 }
447447 ; CHECK: ld1r_8b
448448 ; Make sure we are using the operands defined by the ABI
449449 ; CHECK: ld1r.8b { v0 }, [x0]
450 ; CHECK-NEXT ret
450 ; CHECK-NEXT: ret
451451 %tmp1 = load i8, i8* %bar
452452 %tmp2 = insertelement <8 x i8> , i8 %tmp1, i32 0
453453 %tmp3 = insertelement <8 x i8> %tmp2, i8 %tmp1, i32 1
464464 ; CHECK: ld1r_16b
465465 ; Make sure we are using the operands defined by the ABI
466466 ; CHECK: ld1r.16b { v0 }, [x0]
467 ; CHECK-NEXT ret
467 ; CHECK-NEXT: ret
468468 %tmp1 = load i8, i8* %bar
469469 %tmp2 = insertelement <16 x i8> , i8 %tmp1, i32 0
470470 %tmp3 = insertelement <16 x i8> %tmp2, i8 %tmp1, i32 1
489489 ; CHECK: ld1r_4h
490490 ; Make sure we are using the operands defined by the ABI
491491 ; CHECK: ld1r.4h { v0 }, [x0]
492 ; CHECK-NEXT ret
492 ; CHECK-NEXT: ret
493493 %tmp1 = load i16, i16* %bar
494494 %tmp2 = insertelement <4 x i16> , i16 %tmp1, i32 0
495495 %tmp3 = insertelement <4 x i16> %tmp2, i16 %tmp1, i32 1
502502 ; CHECK: ld1r_8h
503503 ; Make sure we are using the operands defined by the ABI
504504 ; CHECK: ld1r.8h { v0 }, [x0]
505 ; CHECK-NEXT ret
505 ; CHECK-NEXT: ret
506506 %tmp1 = load i16, i16* %bar
507507 %tmp2 = insertelement <8 x i16> , i16 %tmp1, i32 0
508508 %tmp3 = insertelement <8 x i16> %tmp2, i16 %tmp1, i32 1
519519 ; CHECK: ld1r_2s
520520 ; Make sure we are using the operands defined by the ABI
521521 ; CHECK: ld1r.2s { v0 }, [x0]
522 ; CHECK-NEXT ret
522 ; CHECK-NEXT: ret
523523 %tmp1 = load i32, i32* %bar
524524 %tmp2 = insertelement <2 x i32> , i32 %tmp1, i32 0
525525 %tmp3 = insertelement <2 x i32> %tmp2, i32 %tmp1, i32 1
530530 ; CHECK: ld1r_4s
531531 ; Make sure we are using the operands defined by the ABI
532532 ; CHECK: ld1r.4s { v0 }, [x0]
533 ; CHECK-NEXT ret
533 ; CHECK-NEXT: ret
534534 %tmp1 = load i32, i32* %bar
535535 %tmp2 = insertelement <4 x i32> , i32 %tmp1, i32 0
536536 %tmp3 = insertelement <4 x i32> %tmp2, i32 %tmp1, i32 1
543543 ; CHECK: ld1r_2d
544544 ; Make sure we are using the operands defined by the ABI
545545 ; CHECK: ld1r.2d { v0 }, [x0]
546 ; CHECK-NEXT ret
546 ; CHECK-NEXT: ret
547547 %tmp1 = load i64, i64* %bar
548548 %tmp2 = insertelement <2 x i64> , i64 %tmp1, i32 0
549549 %tmp3 = insertelement <2 x i64> %tmp2, i64 %tmp1, i32 1
553553 define %struct.__neon_int8x8x2_t @ld2r_8b(i8* %A) nounwind {
554554 ; CHECK: ld2r_8b
555555 ; Make sure we are using the operands defined by the ABI
556 ; CHECK ld2r.8b { v0, v1 }, [x0]
557 ; CHECK-NEXT ret
556 ; CHECK: ld2r.8b { v0, v1 }, [x0]
557 ; CHECK-NEXT: ret
558558 %tmp2 = call %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2r.v8i8.p0i8(i8* %A)
559559 ret %struct.__neon_int8x8x2_t %tmp2
560560 }
562562 define %struct.__neon_int8x8x3_t @ld3r_8b(i8* %A) nounwind {
563563 ; CHECK: ld3r_8b
564564 ; Make sure we are using the operands defined by the ABI
565 ; CHECK ld3r.8b { v0, v1, v2 }, [x0]
566 ; CHECK-NEXT ret
565 ; CHECK: ld3r.8b { v0, v1, v2 }, [x0]
566 ; CHECK-NEXT: ret
567567 %tmp2 = call %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld3r.v8i8.p0i8(i8* %A)
568568 ret %struct.__neon_int8x8x3_t %tmp2
569569 }
571571 define %struct.__neon_int8x8x4_t @ld4r_8b(i8* %A) nounwind {
572572 ; CHECK: ld4r_8b
573573 ; Make sure we are using the operands defined by the ABI
574 ; CHECK ld4r.8b { v0, v1, v2, v3 }, [x0]
575 ; CHECK-NEXT ret
574 ; CHECK: ld4r.8b { v0, v1, v2, v3 }, [x0]
575 ; CHECK-NEXT: ret
576576 %tmp2 = call %struct.__neon_int8x8x4_t @llvm.aarch64.neon.ld4r.v8i8.p0i8(i8* %A)
577577 ret %struct.__neon_int8x8x4_t %tmp2
578578 }
584584 define %struct.__neon_int8x16x2_t @ld2r_16b(i8* %A) nounwind {
585585 ; CHECK: ld2r_16b
586586 ; Make sure we are using the operands defined by the ABI
587 ; CHECK ld2r.16b { v0, v1 }, [x0]
588 ; CHECK-NEXT ret
587 ; CHECK: ld2r.16b { v0, v1 }, [x0]
588 ; CHECK-NEXT: ret
589589 %tmp2 = call %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2r.v16i8.p0i8(i8* %A)
590590 ret %struct.__neon_int8x16x2_t %tmp2
591591 }
593593 define %struct.__neon_int8x16x3_t @ld3r_16b(i8* %A) nounwind {
594594 ; CHECK: ld3r_16b
595595 ; Make sure we are using the operands defined by the ABI
596 ; CHECK ld3r.16b { v0, v1, v2 }, [x0]
597 ; CHECK-NEXT ret
596 ; CHECK: ld3r.16b { v0, v1, v2 }, [x0]
597 ; CHECK-NEXT: ret
598598 %tmp2 = call %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3r.v16i8.p0i8(i8* %A)
599599 ret %struct.__neon_int8x16x3_t %tmp2
600600 }
602602 define %struct.__neon_int8x16x4_t @ld4r_16b(i8* %A) nounwind {
603603 ; CHECK: ld4r_16b
604604 ; Make sure we are using the operands defined by the ABI
605 ; CHECK ld4r.16b { v0, v1, v2, v3 }, [x0]
606 ; CHECK-NEXT ret
605 ; CHECK: ld4r.16b { v0, v1, v2, v3 }, [x0]
606 ; CHECK-NEXT: ret
607607 %tmp2 = call %struct.__neon_int8x16x4_t @llvm.aarch64.neon.ld4r.v16i8.p0i8(i8* %A)
608608 ret %struct.__neon_int8x16x4_t %tmp2
609609 }
615615 define %struct.__neon_int16x4x2_t @ld2r_4h(i16* %A) nounwind {
616616 ; CHECK: ld2r_4h
617617 ; Make sure we are using the operands defined by the ABI
618 ; CHECK ld2r.4h { v0, v1 }, [x0]
619 ; CHECK-NEXT ret
618 ; CHECK: ld2r.4h { v0, v1 }, [x0]
619 ; CHECK-NEXT: ret
620620 %tmp2 = call %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld2r.v4i16.p0i16(i16* %A)
621621 ret %struct.__neon_int16x4x2_t %tmp2
622622 }
624624 define %struct.__neon_int16x4x3_t @ld3r_4h(i16* %A) nounwind {
625625 ; CHECK: ld3r_4h
626626 ; Make sure we are using the operands defined by the ABI
627 ; CHECK ld3r.4h { v0, v1, v2 }, [x0]
628 ; CHECK-NEXT ret
627 ; CHECK: ld3r.4h { v0, v1, v2 }, [x0]
628 ; CHECK-NEXT: ret
629629 %tmp2 = call %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld3r.v4i16.p0i16(i16* %A)
630630 ret %struct.__neon_int16x4x3_t %tmp2
631631 }
633633 define %struct.__neon_int16x4x4_t @ld4r_4h(i16* %A) nounwind {
634634 ; CHECK: ld4r_4h
635635 ; Make sure we are using the operands defined by the ABI
636 ; CHECK ld4r.4h { v0, v1, v2, v3 }, [x0]
637 ; CHECK-NEXT ret
636 ; CHECK: ld4r.4h { v0, v1, v2, v3 }, [x0]
637 ; CHECK-NEXT: ret
638638 %tmp2 = call %struct.__neon_int16x4x4_t @llvm.aarch64.neon.ld4r.v4i16.p0i16(i16* %A)
639639 ret %struct.__neon_int16x4x4_t %tmp2
640640 }
646646 define %struct.__neon_int16x8x2_t @ld2r_8h(i16* %A) nounwind {
647647 ; CHECK: ld2r_8h
648648 ; Make sure we are using the operands defined by the ABI
649 ; CHECK ld2r.8h { v0, v1 }, [x0]
650 ; CHECK-NEXT ret
649 ; CHECK: ld2r.8h { v0, v1 }, [x0]
650 ; CHECK-NEXT: ret
651651 %tmp2 = call %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2r.v8i16.p0i16(i16* %A)
652652 ret %struct.__neon_int16x8x2_t %tmp2
653653 }
655655 define %struct.__neon_int16x8x3_t @ld3r_8h(i16* %A) nounwind {
656656 ; CHECK: ld3r_8h
657657 ; Make sure we are using the operands defined by the ABI
658 ; CHECK ld3r.8h { v0, v1, v2 }, [x0]
659 ; CHECK-NEXT ret
658 ; CHECK: ld3r.8h { v0, v1, v2 }, [x0]
659 ; CHECK-NEXT: ret
660660 %tmp2 = call %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3r.v8i16.p0i16(i16* %A)
661661 ret %struct.__neon_int16x8x3_t %tmp2
662662 }
664664 define %struct.__neon_int16x8x4_t @ld4r_8h(i16* %A) nounwind {
665665 ; CHECK: ld4r_8h
666666 ; Make sure we are using the operands defined by the ABI
667 ; CHECK ld4r.8h { v0, v1, v2, v3 }, [x0]
668 ; CHECK-NEXT ret
667 ; CHECK: ld4r.8h { v0, v1, v2, v3 }, [x0]
668 ; CHECK-NEXT: ret
669669 %tmp2 = call %struct.__neon_int16x8x4_t @llvm.aarch64.neon.ld4r.v8i16.p0i16(i16* %A)
670670 ret %struct.__neon_int16x8x4_t %tmp2
671671 }
677677 define %struct.__neon_int32x2x2_t @ld2r_2s(i32* %A) nounwind {
678678 ; CHECK: ld2r_2s
679679 ; Make sure we are using the operands defined by the ABI
680 ; CHECK ld2r.2s { v0, v1 }, [x0]
681 ; CHECK-NEXT ret
680 ; CHECK: ld2r.2s { v0, v1 }, [x0]
681 ; CHECK-NEXT: ret
682682 %tmp2 = call %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld2r.v2i32.p0i32(i32* %A)
683683 ret %struct.__neon_int32x2x2_t %tmp2
684684 }
686686 define %struct.__neon_int32x2x3_t @ld3r_2s(i32* %A) nounwind {
687687 ; CHECK: ld3r_2s
688688 ; Make sure we are using the operands defined by the ABI
689 ; CHECK ld3r.2s { v0, v1, v2 }, [x0]
690 ; CHECK-NEXT ret
689 ; CHECK: ld3r.2s { v0, v1, v2 }, [x0]
690 ; CHECK-NEXT: ret
691691 %tmp2 = call %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld3r.v2i32.p0i32(i32* %A)
692692 ret %struct.__neon_int32x2x3_t %tmp2
693693 }
695695 define %struct.__neon_int32x2x4_t @ld4r_2s(i32* %A) nounwind {
696696 ; CHECK: ld4r_2s
697697 ; Make sure we are using the operands defined by the ABI
698 ; CHECK ld4r.2s { v0, v1, v2, v3 }, [x0]
699 ; CHECK-NEXT ret
698 ; CHECK: ld4r.2s { v0, v1, v2, v3 }, [x0]
699 ; CHECK-NEXT: ret
700700 %tmp2 = call %struct.__neon_int32x2x4_t @llvm.aarch64.neon.ld4r.v2i32.p0i32(i32* %A)
701701 ret %struct.__neon_int32x2x4_t %tmp2
702702 }
708708 define %struct.__neon_int32x4x2_t @ld2r_4s(i32* %A) nounwind {
709709 ; CHECK: ld2r_4s
710710 ; Make sure we are using the operands defined by the ABI
711 ; CHECK ld2r.4s { v0, v1 }, [x0]
712 ; CHECK-NEXT ret
711 ; CHECK: ld2r.4s { v0, v1 }, [x0]
712 ; CHECK-NEXT: ret
713713 %tmp2 = call %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2r.v4i32.p0i32(i32* %A)
714714 ret %struct.__neon_int32x4x2_t %tmp2
715715 }
717717 define %struct.__neon_int32x4x3_t @ld3r_4s(i32* %A) nounwind {
718718 ; CHECK: ld3r_4s
719719 ; Make sure we are using the operands defined by the ABI
720 ; CHECK ld3r.4s { v0, v1, v2 }, [x0]
721 ; CHECK-NEXT ret
720 ; CHECK: ld3r.4s { v0, v1, v2 }, [x0]
721 ; CHECK-NEXT: ret
722722 %tmp2 = call %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3r.v4i32.p0i32(i32* %A)
723723 ret %struct.__neon_int32x4x3_t %tmp2
724724 }
726726 define %struct.__neon_int32x4x4_t @ld4r_4s(i32* %A) nounwind {
727727 ; CHECK: ld4r_4s
728728 ; Make sure we are using the operands defined by the ABI
729 ; CHECK ld4r.4s { v0, v1, v2, v3 }, [x0]
730 ; CHECK-NEXT ret
729 ; CHECK: ld4r.4s { v0, v1, v2, v3 }, [x0]
730 ; CHECK-NEXT: ret
731731 %tmp2 = call %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld4r.v4i32.p0i32(i32* %A)
732732 ret %struct.__neon_int32x4x4_t %tmp2
733733 }
739739 define %struct.__neon_int64x1x2_t @ld2r_1d(i64* %A) nounwind {
740740 ; CHECK: ld2r_1d
741741 ; Make sure we are using the operands defined by the ABI
742 ; CHECK ld2r.1d { v0, v1 }, [x0]
743 ; CHECK-NEXT ret
742 ; CHECK: ld2r.1d { v0, v1 }, [x0]
743 ; CHECK-NEXT: ret
744744 %tmp2 = call %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld2r.v1i64.p0i64(i64* %A)
745745 ret %struct.__neon_int64x1x2_t %tmp2
746746 }
748748 define %struct.__neon_int64x1x3_t @ld3r_1d(i64* %A) nounwind {
749749 ; CHECK: ld3r_1d
750750 ; Make sure we are using the operands defined by the ABI
751 ; CHECK ld3r.1d { v0, v1, v2 }, [x0]
752 ; CHECK-NEXT ret
751 ; CHECK: ld3r.1d { v0, v1, v2 }, [x0]
752 ; CHECK-NEXT: ret
753753 %tmp2 = call %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld3r.v1i64.p0i64(i64* %A)
754754 ret %struct.__neon_int64x1x3_t %tmp2
755755 }
757757 define %struct.__neon_int64x1x4_t @ld4r_1d(i64* %A) nounwind {
758758 ; CHECK: ld4r_1d
759759 ; Make sure we are using the operands defined by the ABI
760 ; CHECK ld4r.1d { v0, v1, v2, v3 }, [x0]
761 ; CHECK-NEXT ret
760 ; CHECK: ld4r.1d { v0, v1, v2, v3 }, [x0]
761 ; CHECK-NEXT: ret
762762 %tmp2 = call %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld4r.v1i64.p0i64(i64* %A)
763763 ret %struct.__neon_int64x1x4_t %tmp2
764764 }
770770 define %struct.__neon_int64x2x2_t @ld2r_2d(i64* %A) nounwind {
771771 ; CHECK: ld2r_2d
772772 ; Make sure we are using the operands defined by the ABI
773 ; CHECK ld2r.2d { v0, v1 }, [x0]
774 ; CHECK-NEXT ret
773 ; CHECK: ld2r.2d { v0, v1 }, [x0]
774 ; CHECK-NEXT: ret
775775 %tmp2 = call %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2r.v2i64.p0i64(i64* %A)
776776 ret %struct.__neon_int64x2x2_t %tmp2
777777 }
779779 define %struct.__neon_int64x2x3_t @ld3r_2d(i64* %A) nounwind {
780780 ; CHECK: ld3r_2d
781781 ; Make sure we are using the operands defined by the ABI
782 ; CHECK ld3r.2d { v0, v1, v2 }, [x0]
783 ; CHECK-NEXT ret
782 ; CHECK: ld3r.2d { v0, v1, v2 }, [x0]
783 ; CHECK-NEXT: ret
784784 %tmp2 = call %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3r.v2i64.p0i64(i64* %A)
785785 ret %struct.__neon_int64x2x3_t %tmp2
786786 }
788788 define %struct.__neon_int64x2x4_t @ld4r_2d(i64* %A) nounwind {
789789 ; CHECK: ld4r_2d
790790 ; Make sure we are using the operands defined by the ABI
791 ; CHECK ld4r.2d { v0, v1, v2, v3 }, [x0]
792 ; CHECK-NEXT ret
791 ; CHECK: ld4r.2d { v0, v1, v2, v3 }, [x0]
792 ; CHECK-NEXT: ret
793793 %tmp2 = call %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld4r.v2i64.p0i64(i64* %A)
794794 ret %struct.__neon_int64x2x4_t %tmp2
795795 }
802802 ; CHECK-LABEL: ld1_16b
803803 ; Make sure we are using the operands defined by the ABI
804804 ; CHECK: ld1.b { v0 }[0], [x0]
805 ; CHECK-NEXT ret
805 ; CHECK-NEXT: ret
806806 %tmp1 = load i8, i8* %bar
807807 %tmp2 = insertelement <16 x i8> %V, i8 %tmp1, i32 0
808808 ret <16 x i8> %tmp2
812812 ; CHECK-LABEL: ld1_8h
813813 ; Make sure we are using the operands defined by the ABI
814814 ; CHECK: ld1.h { v0 }[0], [x0]
815 ; CHECK-NEXT ret
815 ; CHECK-NEXT: ret
816816 %tmp1 = load i16, i16* %bar
817817 %tmp2 = insertelement <8 x i16> %V, i16 %tmp1, i32 0
818818 ret <8 x i16> %tmp2
822822 ; CHECK-LABEL: ld1_4s
823823 ; Make sure we are using the operands defined by the ABI
824824 ; CHECK: ld1.s { v0 }[0], [x0]
825 ; CHECK-NEXT ret
825 ; CHECK-NEXT: ret
826826 %tmp1 = load i32, i32* %bar
827827 %tmp2 = insertelement <4 x i32> %V, i32 %tmp1, i32 0
828828 ret <4 x i32> %tmp2
832832 ; CHECK-LABEL: ld1_4s_float:
833833 ; Make sure we are using the operands defined by the ABI
834834 ; CHECK: ld1.s { v0 }[0], [x0]
835 ; CHECK-NEXT ret
835 ; CHECK-NEXT: ret
836836 %tmp1 = load float, float* %bar
837837 %tmp2 = insertelement <4 x float> %V, float %tmp1, i32 0
838838 ret <4 x float> %tmp2
842842 ; CHECK-LABEL: ld1_2d
843843 ; Make sure we are using the operands defined by the ABI
844844 ; CHECK: ld1.d { v0 }[0], [x0]
845 ; CHECK-NEXT ret
845 ; CHECK-NEXT: ret
846846 %tmp1 = load i64, i64* %bar
847847 %tmp2 = insertelement <2 x i64> %V, i64 %tmp1, i32 0
848848 ret <2 x i64> %tmp2
852852 ; CHECK-LABEL: ld1_2d_double:
853853 ; Make sure we are using the operands defined by the ABI
854854 ; CHECK: ld1.d { v0 }[0], [x0]
855 ; CHECK-NEXT ret
855 ; CHECK-NEXT: ret
856856 %tmp1 = load double, double* %bar
857857 %tmp2 = insertelement <2 x double> %V, double %tmp1, i32 0
858858 ret <2 x double> %tmp2
871871 ; CHECK-LABEL: ld1_8b
872872 ; Make sure we are using the operands defined by the ABI
873873 ; CHECK: ld1.b { v0 }[0], [x0]
874 ; CHECK-NEXT ret
874 ; CHECK-NEXT: ret
875875 %tmp1 = load i8, i8* %bar
876876 %tmp2 = insertelement <8 x i8> %V, i8 %tmp1, i32 0
877877 ret <8 x i8> %tmp2
881881 ; CHECK-LABEL: ld1_4h
882882 ; Make sure we are using the operands defined by the ABI
883883 ; CHECK: ld1.h { v0 }[0], [x0]
884 ; CHECK-NEXT ret
884 ; CHECK-NEXT: ret
885885 %tmp1 = load i16, i16* %bar
886886 %tmp2 = insertelement <4 x i16> %V, i16 %tmp1, i32 0
887887 ret <4 x i16> %tmp2
891891 ; CHECK-LABEL: ld1_2s:
892892 ; Make sure we are using the operands defined by the ABI
893893 ; CHECK: ld1.s { v0 }[0], [x0]
894 ; CHECK-NEXT ret
894 ; CHECK-NEXT: ret
895895 %tmp1 = load i32, i32* %bar
896896 %tmp2 = insertelement <2 x i32> %V, i32 %tmp1, i32 0
897897 ret <2 x i32> %tmp2
901901 ; CHECK-LABEL: ld1_2s_float:
902902 ; Make sure we are using the operands defined by the ABI
903903 ; CHECK: ld1.s { v0 }[0], [x0]
904 ; CHECK-NEXT ret
904 ; CHECK-NEXT: ret
905905 %tmp1 = load float, float* %bar
906906 %tmp2 = insertelement <2 x float> %V, float %tmp1, i32 0
907907 ret <2 x float> %tmp2
944944 ; CHECK-LABEL: ld1r_4s_float
945945 ; Make sure we are using the operands defined by the ABI
946946 ; CHECK: ld1r.4s { v0 }, [x0]
947 ; CHECK-NEXT ret
947 ; CHECK-NEXT: ret
948948 %tmp = load float, float* %x, align 4
949949 %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
950950 %tmp2 = insertelement <4 x float> %tmp1, float %tmp, i32 1
958958 ; CHECK-LABEL: ld1r_2s_float
959959 ; Make sure we are using the operands defined by the ABI
960960 ; CHECK: ld1r.2s { v0 }, [x0]
961 ; CHECK-NEXT ret
961 ; CHECK-NEXT: ret
962962 %tmp = load float, float* %x, align 4
963963 %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
964964 %tmp2 = insertelement <2 x float> %tmp1, float %tmp, i32 1
970970 ; CHECK-LABEL: ld1r_2d_double
971971 ; Make sure we are using the operands defined by the ABI
972972 ; CHECK: ld1r.2d { v0 }, [x0]
973 ; CHECK-NEXT ret
973 ; CHECK-NEXT: ret
974974 %tmp = load double, double* %x, align 4
975975 %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
976976 %tmp2 = insertelement <2 x double> %tmp1, double %tmp, i32 1
982982 ; CHECK-LABEL: ld1r_1d_double
983983 ; Make sure we are using the operands defined by the ABI
984984 ; CHECK: ldr d0, [x0]
985 ; CHECK-NEXT ret
985 ; CHECK-NEXT: ret
986986 %tmp = load double, double* %x, align 4
987987 %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
988988 ret <1 x double> %tmp1
993993 ; CHECK-LABEL: ld1r_4s_float_shuff
994994 ; Make sure we are using the operands defined by the ABI
995995 ; CHECK: ld1r.4s { v0 }, [x0]
996 ; CHECK-NEXT ret
996 ; CHECK-NEXT: ret
997997 %tmp = load float, float* %x, align 4
998998 %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
999999 %lane = shufflevector <4 x float> %tmp1, <4 x float> undef, <4 x i32> zeroinitializer
10051005 ; CHECK-LABEL: ld1r_2s_float_shuff
10061006 ; Make sure we are using the operands defined by the ABI
10071007 ; CHECK: ld1r.2s { v0 }, [x0]
1008 ; CHECK-NEXT ret
1008 ; CHECK-NEXT: ret
10091009 %tmp = load float, float* %x, align 4
10101010 %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
10111011 %lane = shufflevector <2 x float> %tmp1, <2 x float> undef, <2 x i32> zeroinitializer
10171017 ; CHECK-LABEL: ld1r_2d_double_shuff
10181018 ; Make sure we are using the operands defined by the ABI
10191019 ; CHECK: ld1r.2d { v0 }, [x0]
1020 ; CHECK-NEXT ret
1020 ; CHECK-NEXT: ret
10211021 %tmp = load double, double* %x, align 4
10221022 %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
10231023 %lane = shufflevector <2 x double> %tmp1, <2 x double> undef, <2 x i32> zeroinitializer
10291029 ; CHECK-LABEL: ld1r_1d_double_shuff
10301030 ; Make sure we are using the operands defined by the ABI
10311031 ; CHECK: ldr d0, [x0]
1032 ; CHECK-NEXT ret
1032 ; CHECK-NEXT: ret
10331033 %tmp = load double, double* %x, align 4
10341034 %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
10351035 %lane = shufflevector <1 x double> %tmp1, <1 x double> undef, <1 x i32> zeroinitializer
88 ; RUN: llc < %s -mtriple=arm64-linux-gnu -mcpu=cortex-a57 -enable-misched -verify-misched -debug-only=misched -o - 2>&1 > /dev/null | FileCheck %s
99 ; CHECK: ********** MI Scheduling **********
1010 ; CHECK: main:BB#2
11 ; CHECK LDR
12 ; CHECK Latency : 4
11 ; CHECK: LDR
12 ; CHECK: Latency : 4
1313 ; CHECK: *** Final schedule for BB#2 ***
1414 ; CHECK: LDR
1515 ; CHECK: LDR
373373
374374 define void @st2_8b(<8 x i8> %A, <8 x i8> %B, i8* %P) nounwind {
375375 ; CHECK-LABEL: st2_8b
376 ; CHECK st2.8b
376 ; CHECK: st2.8b
377377 call void @llvm.aarch64.neon.st2.v8i8.p0i8(<8 x i8> %A, <8 x i8> %B, i8* %P)
378378 ret void
379379 }
380380
381381 define void @st3_8b(<8 x i8> %A, <8 x i8> %B, <8 x i8> %C, i8* %P) nounwind {
382382 ; CHECK-LABEL: st3_8b
383 ; CHECK st3.8b
383 ; CHECK: st3.8b
384384 call void @llvm.aarch64.neon.st3.v8i8.p0i8(<8 x i8> %A, <8 x i8> %B, <8 x i8> %C, i8* %P)
385385 ret void
386386 }
387387
388388 define void @st4_8b(<8 x i8> %A, <8 x i8> %B, <8 x i8> %C, <8 x i8> %D, i8* %P) nounwind {
389389 ; CHECK-LABEL: st4_8b
390 ; CHECK st4.8b
390 ; CHECK: st4.8b
391391 call void @llvm.aarch64.neon.st4.v8i8.p0i8(<8 x i8> %A, <8 x i8> %B, <8 x i8> %C, <8 x i8> %D, i8* %P)
392392 ret void
393393 }
398398
399399 define void @st2_16b(<16 x i8> %A, <16 x i8> %B, i8* %P) nounwind {
400400 ; CHECK-LABEL: st2_16b
401 ; CHECK st2.16b
401 ; CHECK: st2.16b
402402 call void @llvm.aarch64.neon.st2.v16i8.p0i8(<16 x i8> %A, <16 x i8> %B, i8* %P)
403403 ret void
404404 }
405405
406406 define void @st3_16b(<16 x i8> %A, <16 x i8> %B, <16 x i8> %C, i8* %P) nounwind {
407407 ; CHECK-LABEL: st3_16b
408 ; CHECK st3.16b
408 ; CHECK: st3.16b
409409 call void @llvm.aarch64.neon.st3.v16i8.p0i8(<16 x i8> %A, <16 x i8> %B, <16 x i8> %C, i8* %P)
410410 ret void
411411 }
412412
413413 define void @st4_16b(<16 x i8> %A, <16 x i8> %B, <16 x i8> %C, <16 x i8> %D, i8* %P) nounwind {
414414 ; CHECK-LABEL: st4_16b
415 ; CHECK st4.16b
415 ; CHECK: st4.16b
416416 call void @llvm.aarch64.neon.st4.v16i8.p0i8(<16 x i8> %A, <16 x i8> %B, <16 x i8> %C, <16 x i8> %D, i8* %P)
417417 ret void
418418 }
423423
424424 define void @st2_4h(<4 x i16> %A, <4 x i16> %B, i16* %P) nounwind {
425425 ; CHECK-LABEL: st2_4h
426 ; CHECK st2.4h
426 ; CHECK: st2.4h
427427 call void @llvm.aarch64.neon.st2.v4i16.p0i16(<4 x i16> %A, <4 x i16> %B, i16* %P)
428428 ret void
429429 }
430430
431431 define void @st3_4h(<4 x i16> %A, <4 x i16> %B, <4 x i16> %C, i16* %P) nounwind {
432432 ; CHECK-LABEL: st3_4h
433 ; CHECK st3.4h
433 ; CHECK: st3.4h
434434 call void @llvm.aarch64.neon.st3.v4i16.p0i16(<4 x i16> %A, <4 x i16> %B, <4 x i16> %C, i16* %P)
435435 ret void
436436 }
437437
438438 define void @st4_4h(<4 x i16> %A, <4 x i16> %B, <4 x i16> %C, <4 x i16> %D, i16* %P) nounwind {
439439 ; CHECK-LABEL: st4_4h
440 ; CHECK st4.4h
440 ; CHECK: st4.4h
441441 call void @llvm.aarch64.neon.st4.v4i16.p0i16(<4 x i16> %A, <4 x i16> %B, <4 x i16> %C, <4 x i16> %D, i16* %P)
442442 ret void
443443 }
448448
449449 define void @st2_8h(<8 x i16> %A, <8 x i16> %B, i16* %P) nounwind {
450450 ; CHECK-LABEL: st2_8h
451 ; CHECK st2.8h
451 ; CHECK: st2.8h
452452 call void @llvm.aarch64.neon.st2.v8i16.p0i16(<8 x i16> %A, <8 x i16> %B, i16* %P)
453453 ret void
454454 }
455455
456456 define void @st3_8h(<8 x i16> %A, <8 x i16> %B, <8 x i16> %C, i16* %P) nounwind {
457457 ; CHECK-LABEL: st3_8h
458 ; CHECK st3.8h
458 ; CHECK: st3.8h
459459 call void @llvm.aarch64.neon.st3.v8i16.p0i16(<8 x i16> %A, <8 x i16> %B, <8 x i16> %C, i16* %P)
460460 ret void
461461 }
462462
463463 define void @st4_8h(<8 x i16> %A, <8 x i16> %B, <8 x i16> %C, <8 x i16> %D, i16* %P) nounwind {
464464 ; CHECK-LABEL: st4_8h
465 ; CHECK st4.8h
465 ; CHECK: st4.8h
466466 call void @llvm.aarch64.neon.st4.v8i16.p0i16(<8 x i16> %A, <8 x i16> %B, <8 x i16> %C, <8 x i16> %D, i16* %P)
467467 ret void
468468 }
473473
474474 define void @st2_2s(<2 x i32> %A, <2 x i32> %B, i32* %P) nounwind {
475475 ; CHECK-LABEL: st2_2s
476 ; CHECK st2.2s
476 ; CHECK: st2.2s
477477 call void @llvm.aarch64.neon.st2.v2i32.p0i32(<2 x i32> %A, <2 x i32> %B, i32* %P)
478478 ret void
479479 }
480480
481481 define void @st3_2s(<2 x i32> %A, <2 x i32> %B, <2 x i32> %C, i32* %P) nounwind {
482482 ; CHECK-LABEL: st3_2s
483 ; CHECK st3.2s
483 ; CHECK: st3.2s
484484 call void @llvm.aarch64.neon.st3.v2i32.p0i32(<2 x i32> %A, <2 x i32> %B, <2 x i32> %C, i32* %P)
485485 ret void
486486 }
487487
488488 define void @st4_2s(<2 x i32> %A, <2 x i32> %B, <2 x i32> %C, <2 x i32> %D, i32* %P) nounwind {
489489 ; CHECK-LABEL: st4_2s
490 ; CHECK st4.2s
490 ; CHECK: st4.2s
491491 call void @llvm.aarch64.neon.st4.v2i32.p0i32(<2 x i32> %A, <2 x i32> %B, <2 x i32> %C, <2 x i32> %D, i32* %P)
492492 ret void
493493 }
498498
499499 define void @st2_4s(<4 x i32> %A, <4 x i32> %B, i32* %P) nounwind {
500500 ; CHECK-LABEL: st2_4s
501 ; CHECK st2.4s
501 ; CHECK: st2.4s
502502 call void @llvm.aarch64.neon.st2.v4i32.p0i32(<4 x i32> %A, <4 x i32> %B, i32* %P)
503503 ret void
504504 }
505505
506506 define void @st3_4s(<4 x i32> %A, <4 x i32> %B, <4 x i32> %C, i32* %P) nounwind {
507507 ; CHECK-LABEL: st3_4s
508 ; CHECK st3.4s
508 ; CHECK: st3.4s
509509 call void @llvm.aarch64.neon.st3.v4i32.p0i32(<4 x i32> %A, <4 x i32> %B, <4 x i32> %C, i32* %P)
510510 ret void
511511 }
512512
513513 define void @st4_4s(<4 x i32> %A, <4 x i32> %B, <4 x i32> %C, <4 x i32> %D, i32* %P) nounwind {
514514 ; CHECK-LABEL: st4_4s
515 ; CHECK st4.4s
515 ; CHECK: st4.4s
516516 call void @llvm.aarch64.neon.st4.v4i32.p0i32(<4 x i32> %A, <4 x i32> %B, <4 x i32> %C, <4 x i32> %D, i32* %P)
517517 ret void
518518 }
521521 declare void @llvm.aarch64.neon.st3.v4i32.p0i32(<4 x i32>, <4 x i32>, <4 x i32>, i32*) nounwind readonly
522522 declare void @llvm.aarch64.neon.st4.v4i32.p0i32(<4 x i32>, <4 x i32>, <4 x i32>, <4 x i32>, i32*) nounwind readonly
523523
524 ; If there's only one element, st2/3/4 don't make much sense, stick to st1.
524525 define void @st2_1d(<1 x i64> %A, <1 x i64> %B, i64* %P) nounwind {
525526 ; CHECK-LABEL: st2_1d
526 ; CHECK st1.2d
527 ; CHECK: st1.1d
527528 call void @llvm.aarch64.neon.st2.v1i64.p0i64(<1 x i64> %A, <1 x i64> %B, i64* %P)
528529 ret void
529530 }
530531
531532 define void @st3_1d(<1 x i64> %A, <1 x i64> %B, <1 x i64> %C, i64* %P) nounwind {
532533 ; CHECK-LABEL: st3_1d
533 ; CHECK st1.3d
534 ; CHECK: st1.1d
534535 call void @llvm.aarch64.neon.st3.v1i64.p0i64(<1 x i64> %A, <1 x i64> %B, <1 x i64> %C, i64* %P)
535536 ret void
536537 }
537538
538539 define void @st4_1d(<1 x i64> %A, <1 x i64> %B, <1 x i64> %C, <1 x i64> %D, i64* %P) nounwind {
539540 ; CHECK-LABEL: st4_1d
540 ; CHECK st1.4d
541 ; CHECK: st1.1d
541542 call void @llvm.aarch64.neon.st4.v1i64.p0i64(<1 x i64> %A, <1 x i64> %B, <1 x i64> %C, <1 x i64> %D, i64* %P)
542543 ret void
543544 }
548549
549550 define void @st2_2d(<2 x i64> %A, <2 x i64> %B, i64* %P) nounwind {
550551 ; CHECK-LABEL: st2_2d
551 ; CHECK st2.2d
552 ; CHECK: st2.2d
552553 call void @llvm.aarch64.neon.st2.v2i64.p0i64(<2 x i64> %A, <2 x i64> %B, i64* %P)
553554 ret void
554555 }
555556
556557 define void @st3_2d(<2 x i64> %A, <2 x i64> %B, <2 x i64> %C, i64* %P) nounwind {
557558 ; CHECK-LABEL: st3_2d
558 ; CHECK st2.3d
559 ; CHECK: st3.2d
559560 call void @llvm.aarch64.neon.st3.v2i64.p0i64(<2 x i64> %A, <2 x i64> %B, <2 x i64> %C, i64* %P)
560561 ret void
561562 }
562563
563564 define void @st4_2d(<2 x i64> %A, <2 x i64> %B, <2 x i64> %C, <2 x i64> %D, i64* %P) nounwind {
564565 ; CHECK-LABEL: st4_2d
565 ; CHECK st2.4d
566 ; CHECK: st4.2d
566567 call void @llvm.aarch64.neon.st4.v2i64.p0i64(<2 x i64> %A, <2 x i64> %B, <2 x i64> %C, <2 x i64> %D, i64* %P)
567568 ret void
568569 }
1111 define <2 x i64> @increment_by_one(<2 x i64> %x) nounwind {
1212 %result = add <2 x i64> %x,
1313 ret <2 x i64> %result
14 ; CHECK vaddudm 2, 2, 3
14 ; CHECK: vaddudm 2, 2, 3
1515 }
1616
1717 define <2 x i64> @increment_by_val(<2 x i64> %x, i64 %val) nounwind {
4646 define <2 x i64> @decrement_by_one(<2 x i64> %x) nounwind {
4747 %result = sub <2 x i64> %x,
4848 ret <2 x i64> %result
49 ; CHECK vsubudm 2, 2, 3
49 ; CHECK: vsubudm 2, 2, 3
5050 }
5151
5252 define <2 x i64> @decrement_by_val(<2 x i64> %x, i64 %val) nounwind {
5454 %tmpvec2 = insertelement <2 x i64> %tmpvec, i64 %val, i32 1
5555 %result = sub <2 x i64> %x, %tmpvec2
5656 ret <2 x i64> %result
57 ; CHECK vsubudm 2, 2, 3
57 ; CHECK: vsubudm 2, 2, 3
5858 }
5959
6060
9393
9494 ; PR22685
9595 ; CHECK: mov00
96 ; CHECK vmovss
96 ; CHECK: vmovss
9797 define <8 x float> @mov00_8f32(float* %ptr) {
9898 %val = load float, float* %ptr
9999 %vec = insertelement <8 x float> zeroinitializer, float %val, i32 0
6666 ; CHECK: @f5_as1
6767 %idx = getelementptr inbounds [8 x i8], [8 x i8] addrspace(1)* @.str_as1, i64 0, i64 %x
6868 ; CHECK: sub i16
69 ; CHECK icmp ult i16
69 ; CHECK: icmp ult i16
7070 ; CHECK: trap
7171 %1 = load i8, i8 addrspace(1)* %idx, align 4
7272 ret void
16301630
16311631 # rdar://10798451
16321632 0xe7 0xf9 0x32 0x1d
1633 # CHECK vld2.8 {d17[], d19[]}, [r7:16], r2
1633 # CHECK: vld2.8 {d17[], d19[]}, [r7:16], r2
16341634 0xe7 0xf9 0x3d 0x1d
1635 # CHECK vld2.8 {d17[], d19[]}, [r7:16]!
1635 # CHECK: vld2.8 {d17[], d19[]}, [r7:16]!
16361636 0xe7 0xf9 0x3f 0x1d
1637 # CHECK vld2.8 {d17[], d19[]}, [r7:16]
1637 # CHECK: vld2.8 {d17[], d19[]}, [r7:16]
16381638
16391639 # rdar://11034702
16401640 0x04 0xf9 0x0d 0x87
917917 ret i1 %cmp
918918 ; CHECK-LABEL: @nonnull_deref_as_arg
919919 ; CHECK: icmp
920 ; CHECK ret
920 ; CHECK: ret
921921 }
922922
923923 declare nonnull i32* @returns_nonnull_helper()