test/CodeGen/ARM64/ld1.ll

   1 ; RUN: llc < %s -march=arm64 -arm64-neon-syntax=apple -verify-machineinstrs | FileCheck %s
   2
   3 %struct.__neon_int8x8x2_t = type { <8 x i8>,  <8 x i8> }
   4 %struct.__neon_int8x8x3_t = type { <8 x i8>,  <8 x i8>,  <8 x i8> }
   5 %struct.__neon_int8x8x4_t = type { <8 x i8>,  <8 x i8>, <8 x i8>,  <8 x i8> }
   6
   7 define %struct.__neon_int8x8x2_t @ld2_8b(i8* %A) nounwind {
   8 ; CHECK: ld2_8b
   9 ; Make sure we are loading into the results defined by the ABI (i.e., v0, v1)
  10 ; and from the argument of the function also defined by ABI (i.e., x0)
  11 ; CHECK ld2.8b { v0, v1 }, [x0]
  12 ; CHECK-NEXT ret
  13         %tmp2 = call %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld2.v8i8.p0i8(i8* %A)
  14         ret %struct.__neon_int8x8x2_t  %tmp2
  15 }
  16
  17 define %struct.__neon_int8x8x3_t @ld3_8b(i8* %A) nounwind {
  18 ; CHECK: ld3_8b
  19 ; Make sure we are using the operands defined by the ABI
  20 ; CHECK ld3.8b { v0, v1, v2 }, [x0]
  21 ; CHECK-NEXT ret
  22         %tmp2 = call %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld3.v8i8.p0i8(i8* %A)
  23         ret %struct.__neon_int8x8x3_t  %tmp2
  24 }
  25
  26 define %struct.__neon_int8x8x4_t @ld4_8b(i8* %A) nounwind {
  27 ; CHECK: ld4_8b
  28 ; Make sure we are using the operands defined by the ABI
  29 ; CHECK ld4.8b { v0, v1, v2, v3 }, [x0]
  30 ; CHECK-NEXT ret
  31         %tmp2 = call %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld4.v8i8.p0i8(i8* %A)
  32         ret %struct.__neon_int8x8x4_t  %tmp2
  33 }
  34
  35 declare %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld2.v8i8.p0i8(i8*) nounwind readonly
  36 declare %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld3.v8i8.p0i8(i8*) nounwind readonly
  37 declare %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld4.v8i8.p0i8(i8*) nounwind readonly
  38
  39 %struct.__neon_int8x16x2_t = type { <16 x i8>,  <16 x i8> }
  40 %struct.__neon_int8x16x3_t = type { <16 x i8>,  <16 x i8>,  <16 x i8> }
  41 %struct.__neon_int8x16x4_t = type { <16 x i8>,  <16 x i8>, <16 x i8>,  <16 x i8> }
  42
  43 define %struct.__neon_int8x16x2_t @ld2_16b(i8* %A) nounwind {
  44 ; CHECK: ld2_16b
  45 ; Make sure we are using the operands defined by the ABI
  46 ; CHECK ld2.16b { v0, v1 }, [x0]
  47 ; CHECK-NEXT ret
  48   %tmp2 = call %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2.v16i8.p0i8(i8* %A)
  49   ret %struct.__neon_int8x16x2_t  %tmp2
  50 }
  51
  52 define %struct.__neon_int8x16x3_t @ld3_16b(i8* %A) nounwind {
  53 ; CHECK: ld3_16b
  54 ; Make sure we are using the operands defined by the ABI
  55 ; CHECK ld3.16b { v0, v1, v2 }, [x0]
  56 ; CHECK-NEXT ret
  57   %tmp2 = call %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3.v16i8.p0i8(i8* %A)
  58   ret %struct.__neon_int8x16x3_t  %tmp2
  59 }
  60
  61 define %struct.__neon_int8x16x4_t @ld4_16b(i8* %A) nounwind {
  62 ; CHECK: ld4_16b
  63 ; Make sure we are using the operands defined by the ABI
  64 ; CHECK ld4.16b { v0, v1, v2, v3 }, [x0]
  65 ; CHECK-NEXT ret
  66   %tmp2 = call %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4.v16i8.p0i8(i8* %A)
  67   ret %struct.__neon_int8x16x4_t  %tmp2
  68 }
  69
  70 declare %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2.v16i8.p0i8(i8*) nounwind readonly
  71 declare %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3.v16i8.p0i8(i8*) nounwind readonly
  72 declare %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4.v16i8.p0i8(i8*) nounwind readonly
  73
  74 %struct.__neon_int16x4x2_t = type { <4 x i16>,  <4 x i16> }
  75 %struct.__neon_int16x4x3_t = type { <4 x i16>,  <4 x i16>,  <4 x i16> }
  76 %struct.__neon_int16x4x4_t = type { <4 x i16>,  <4 x i16>, <4 x i16>,  <4 x i16> }
  77
  78 define %struct.__neon_int16x4x2_t @ld2_4h(i16* %A) nounwind {
  79 ; CHECK: ld2_4h
  80 ; Make sure we are using the operands defined by the ABI
  81 ; CHECK ld2.4h { v0, v1 }, [x0]
  82 ; CHECK-NEXT ret
  83         %tmp2 = call %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld2.v4i16.p0i16(i16* %A)
  84         ret %struct.__neon_int16x4x2_t  %tmp2
  85 }
  86
  87 define %struct.__neon_int16x4x3_t @ld3_4h(i16* %A) nounwind {
  88 ; CHECK: ld3_4h
  89 ; Make sure we are using the operands defined by the ABI
  90 ; CHECK ld3.4h { v0, v1, v2 }, [x0]
  91 ; CHECK-NEXT ret
  92         %tmp2 = call %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld3.v4i16.p0i16(i16* %A)
  93         ret %struct.__neon_int16x4x3_t  %tmp2
  94 }
  95
  96 define %struct.__neon_int16x4x4_t @ld4_4h(i16* %A) nounwind {
  97 ; CHECK: ld4_4h
  98 ; Make sure we are using the operands defined by the ABI
  99 ; CHECK ld4.4h { v0, v1, v2, v3 }, [x0]
 100 ; CHECK-NEXT ret
 101         %tmp2 = call %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld4.v4i16.p0i16(i16* %A)
 102         ret %struct.__neon_int16x4x4_t  %tmp2
 103 }
 104
 105 declare %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld2.v4i16.p0i16(i16*) nounwind readonly
 106 declare %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld3.v4i16.p0i16(i16*) nounwind readonly
 107 declare %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld4.v4i16.p0i16(i16*) nounwind readonly
 108
 109 %struct.__neon_int16x8x2_t = type { <8 x i16>,  <8 x i16> }
 110 %struct.__neon_int16x8x3_t = type { <8 x i16>,  <8 x i16>,  <8 x i16> }
 111 %struct.__neon_int16x8x4_t = type { <8 x i16>,  <8 x i16>, <8 x i16>,  <8 x i16> }
 112
 113 define %struct.__neon_int16x8x2_t @ld2_8h(i16* %A) nounwind {
 114 ; CHECK: ld2_8h
 115 ; Make sure we are using the operands defined by the ABI
 116 ; CHECK ld2.8h { v0, v1 }, [x0]
 117 ; CHECK-NEXT ret
 118   %tmp2 = call %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2.v8i16.p0i16(i16* %A)
 119   ret %struct.__neon_int16x8x2_t  %tmp2
 120 }
 121
 122 define %struct.__neon_int16x8x3_t @ld3_8h(i16* %A) nounwind {
 123 ; CHECK: ld3_8h
 124 ; Make sure we are using the operands defined by the ABI
 125 ; CHECK ld3.8h { v0, v1, v2 }, [x0]
 126 ; CHECK-NEXT ret
 127   %tmp2 = call %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3.v8i16.p0i16(i16* %A)
 128   ret %struct.__neon_int16x8x3_t %tmp2
 129 }
 130
 131 define %struct.__neon_int16x8x4_t @ld4_8h(i16* %A) nounwind {
 132 ; CHECK: ld4_8h
 133 ; Make sure we are using the operands defined by the ABI
 134 ; CHECK ld4.8h { v0, v1, v2, v3 }, [x0]
 135 ; CHECK-NEXT ret
 136   %tmp2 = call %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4.v8i16.p0i16(i16* %A)
 137   ret %struct.__neon_int16x8x4_t  %tmp2
 138 }
 139
 140 declare %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2.v8i16.p0i16(i16*) nounwind readonly
 141 declare %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3.v8i16.p0i16(i16*) nounwind readonly
 142 declare %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4.v8i16.p0i16(i16*) nounwind readonly
 143
 144 %struct.__neon_int32x2x2_t = type { <2 x i32>,  <2 x i32> }
 145 %struct.__neon_int32x2x3_t = type { <2 x i32>,  <2 x i32>,  <2 x i32> }
 146 %struct.__neon_int32x2x4_t = type { <2 x i32>,  <2 x i32>, <2 x i32>,  <2 x i32> }
 147
 148 define %struct.__neon_int32x2x2_t @ld2_2s(i32* %A) nounwind {
 149 ; CHECK: ld2_2s
 150 ; Make sure we are using the operands defined by the ABI
 151 ; CHECK ld2.2s { v0, v1 }, [x0]
 152 ; CHECK-NEXT ret
 153         %tmp2 = call %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld2.v2i32.p0i32(i32* %A)
 154         ret %struct.__neon_int32x2x2_t  %tmp2
 155 }
 156
 157 define %struct.__neon_int32x2x3_t @ld3_2s(i32* %A) nounwind {
 158 ; CHECK: ld3_2s
 159 ; Make sure we are using the operands defined by the ABI
 160 ; CHECK ld3.2s { v0, v1, v2 }, [x0]
 161 ; CHECK-NEXT ret
 162         %tmp2 = call %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld3.v2i32.p0i32(i32* %A)
 163         ret %struct.__neon_int32x2x3_t  %tmp2
 164 }
 165
 166 define %struct.__neon_int32x2x4_t @ld4_2s(i32* %A) nounwind {
 167 ; CHECK: ld4_2s
 168 ; Make sure we are using the operands defined by the ABI
 169 ; CHECK ld4.2s { v0, v1, v2, v3 }, [x0]
 170 ; CHECK-NEXT ret
 171         %tmp2 = call %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld4.v2i32.p0i32(i32* %A)
 172         ret %struct.__neon_int32x2x4_t  %tmp2
 173 }
 174
 175 declare %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld2.v2i32.p0i32(i32*) nounwind readonly
 176 declare %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld3.v2i32.p0i32(i32*) nounwind readonly
 177 declare %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld4.v2i32.p0i32(i32*) nounwind readonly
 178
 179 %struct.__neon_int32x4x2_t = type { <4 x i32>,  <4 x i32> }
 180 %struct.__neon_int32x4x3_t = type { <4 x i32>,  <4 x i32>,  <4 x i32> }
 181 %struct.__neon_int32x4x4_t = type { <4 x i32>,  <4 x i32>, <4 x i32>,  <4 x i32> }
 182
 183 define %struct.__neon_int32x4x2_t @ld2_4s(i32* %A) nounwind {
 184 ; CHECK: ld2_4s
 185 ; Make sure we are using the operands defined by the ABI
 186 ; CHECK ld2.4s { v0, v1 }, [x0]
 187 ; CHECK-NEXT ret
 188         %tmp2 = call %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2.v4i32.p0i32(i32* %A)
 189         ret %struct.__neon_int32x4x2_t  %tmp2
 190 }
 191
 192 define %struct.__neon_int32x4x3_t @ld3_4s(i32* %A) nounwind {
 193 ; CHECK: ld3_4s
 194 ; Make sure we are using the operands defined by the ABI
 195 ; CHECK ld3.4s { v0, v1, v2 }, [x0]
 196 ; CHECK-NEXT ret
 197         %tmp2 = call %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3.v4i32.p0i32(i32* %A)
 198         ret %struct.__neon_int32x4x3_t  %tmp2
 199 }
 200
 201 define %struct.__neon_int32x4x4_t @ld4_4s(i32* %A) nounwind {
 202 ; CHECK: ld4_4s
 203 ; Make sure we are using the operands defined by the ABI
 204 ; CHECK ld4.4s { v0, v1, v2, v3 }, [x0]
 205 ; CHECK-NEXT ret
 206         %tmp2 = call %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4.v4i32.p0i32(i32* %A)
 207         ret %struct.__neon_int32x4x4_t  %tmp2
 208 }
 209
 210 declare %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2.v4i32.p0i32(i32*) nounwind readonly
 211 declare %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3.v4i32.p0i32(i32*) nounwind readonly
 212 declare %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4.v4i32.p0i32(i32*) nounwind readonly
 213
 214 %struct.__neon_int64x2x2_t = type { <2 x i64>,  <2 x i64> }
 215 %struct.__neon_int64x2x3_t = type { <2 x i64>,  <2 x i64>,  <2 x i64> }
 216 %struct.__neon_int64x2x4_t = type { <2 x i64>,  <2 x i64>, <2 x i64>,  <2 x i64> }
 217
 218 define %struct.__neon_int64x2x2_t @ld2_2d(i64* %A) nounwind {
 219 ; CHECK: ld2_2d
 220 ; Make sure we are using the operands defined by the ABI
 221 ; CHECK ld2.2d { v0, v1 }, [x0]
 222 ; CHECK-NEXT ret
 223         %tmp2 = call %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2.v2i64.p0i64(i64* %A)
 224         ret %struct.__neon_int64x2x2_t  %tmp2
 225 }
 226
 227 define %struct.__neon_int64x2x3_t @ld3_2d(i64* %A) nounwind {
 228 ; CHECK: ld3_2d
 229 ; Make sure we are using the operands defined by the ABI
 230 ; CHECK ld3.2d { v0, v1, v2 }, [x0]
 231 ; CHECK-NEXT ret
 232         %tmp2 = call %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3.v2i64.p0i64(i64* %A)
 233         ret %struct.__neon_int64x2x3_t  %tmp2
 234 }
 235
 236 define %struct.__neon_int64x2x4_t @ld4_2d(i64* %A) nounwind {
 237 ; CHECK: ld4_2d
 238 ; Make sure we are using the operands defined by the ABI
 239 ; CHECK ld4.2d { v0, v1, v2, v3 }, [x0]
 240 ; CHECK-NEXT ret
 241         %tmp2 = call %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4.v2i64.p0i64(i64* %A)
 242         ret %struct.__neon_int64x2x4_t  %tmp2
 243 }
 244
 245 declare %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2.v2i64.p0i64(i64*) nounwind readonly
 246 declare %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3.v2i64.p0i64(i64*) nounwind readonly
 247 declare %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4.v2i64.p0i64(i64*) nounwind readonly
 248
 249 %struct.__neon_int64x1x2_t = type { <1 x i64>,  <1 x i64> }
 250 %struct.__neon_int64x1x3_t = type { <1 x i64>,  <1 x i64>, <1 x i64> }
 251 %struct.__neon_int64x1x4_t = type { <1 x i64>,  <1 x i64>, <1 x i64>, <1 x i64> }
 252
 253
 254 define %struct.__neon_int64x1x2_t @ld2_1di64(i64* %A) nounwind {
 255 ; CHECK: ld2_1di64
 256 ; Make sure we are using the operands defined by the ABI
 257 ; CHECK ld1.1d { v0, v1 }, [x0]
 258 ; CHECK-NEXT ret
 259         %tmp2 = call %struct.__neon_int64x1x2_t @llvm.arm64.neon.ld2.v1i64.p0i64(i64* %A)
 260         ret %struct.__neon_int64x1x2_t  %tmp2
 261 }
 262
 263 define %struct.__neon_int64x1x3_t @ld3_1di64(i64* %A) nounwind {
 264 ; CHECK: ld3_1di64
 265 ; Make sure we are using the operands defined by the ABI
 266 ; CHECK ld1.1d { v0, v1, v2 }, [x0]
 267 ; CHECK-NEXT ret
 268         %tmp2 = call %struct.__neon_int64x1x3_t @llvm.arm64.neon.ld3.v1i64.p0i64(i64* %A)
 269         ret %struct.__neon_int64x1x3_t  %tmp2
 270 }
 271
 272 define %struct.__neon_int64x1x4_t @ld4_1di64(i64* %A) nounwind {
 273 ; CHECK: ld4_1di64
 274 ; Make sure we are using the operands defined by the ABI
 275 ; CHECK ld1.1d { v0, v1, v2, v3 }, [x0]
 276 ; CHECK-NEXT ret
 277         %tmp2 = call %struct.__neon_int64x1x4_t @llvm.arm64.neon.ld4.v1i64.p0i64(i64* %A)
 278         ret %struct.__neon_int64x1x4_t  %tmp2
 279 }
 280
 281
 282 declare %struct.__neon_int64x1x2_t @llvm.arm64.neon.ld2.v1i64.p0i64(i64*) nounwind readonly
 283 declare %struct.__neon_int64x1x3_t @llvm.arm64.neon.ld3.v1i64.p0i64(i64*) nounwind readonly
 284 declare %struct.__neon_int64x1x4_t @llvm.arm64.neon.ld4.v1i64.p0i64(i64*) nounwind readonly
 285
 286 %struct.__neon_float64x1x2_t = type { <1 x double>,  <1 x double> }
 287 %struct.__neon_float64x1x3_t = type { <1 x double>,  <1 x double>, <1 x double> }
 288 %struct.__neon_float64x1x4_t = type { <1 x double>,  <1 x double>, <1 x double>, <1 x double> }
 289
 290
 291 define %struct.__neon_float64x1x2_t @ld2_1df64(double* %A) nounwind {
 292 ; CHECK: ld2_1df64
 293 ; Make sure we are using the operands defined by the ABI
 294 ; CHECK ld1.1d { v0, v1 }, [x0]
 295 ; CHECK-NEXT ret
 296         %tmp2 = call %struct.__neon_float64x1x2_t @llvm.arm64.neon.ld2.v1f64.p0f64(double* %A)
 297         ret %struct.__neon_float64x1x2_t  %tmp2
 298 }
 299
 300 define %struct.__neon_float64x1x3_t @ld3_1df64(double* %A) nounwind {
 301 ; CHECK: ld3_1df64
 302 ; Make sure we are using the operands defined by the ABI
 303 ; CHECK ld1.1d { v0, v1, v2 }, [x0]
 304 ; CHECK-NEXT ret
 305         %tmp2 = call %struct.__neon_float64x1x3_t @llvm.arm64.neon.ld3.v1f64.p0f64(double* %A)
 306         ret %struct.__neon_float64x1x3_t  %tmp2
 307 }
 308
 309 define %struct.__neon_float64x1x4_t @ld4_1df64(double* %A) nounwind {
 310 ; CHECK: ld4_1df64
 311 ; Make sure we are using the operands defined by the ABI
 312 ; CHECK ld1.1d { v0, v1, v2, v3 }, [x0]
 313 ; CHECK-NEXT ret
 314         %tmp2 = call %struct.__neon_float64x1x4_t @llvm.arm64.neon.ld4.v1f64.p0f64(double* %A)
 315         ret %struct.__neon_float64x1x4_t  %tmp2
 316 }
 317
 318 declare %struct.__neon_float64x1x2_t @llvm.arm64.neon.ld2.v1f64.p0f64(double*) nounwind readonly
 319 declare %struct.__neon_float64x1x3_t @llvm.arm64.neon.ld3.v1f64.p0f64(double*) nounwind readonly
 320 declare %struct.__neon_float64x1x4_t @llvm.arm64.neon.ld4.v1f64.p0f64(double*) nounwind readonly
 321
 322
 323 define %struct.__neon_int8x16x2_t @ld2lane_16b(<16 x i8> %L1, <16 x i8> %L2, i8* %A) nounwind {
 324 ; Make sure we are using the operands defined by the ABI
 325 ; CHECK: ld2lane_16b
 326 ; CHECK ld2.b { v0, v1 }[1], [x0]
 327 ; CHECK-NEXT ret
 328         %tmp2 = call %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, i64 1, i8* %A)
 329         ret %struct.__neon_int8x16x2_t  %tmp2
 330 }
 331
 332 define %struct.__neon_int8x16x3_t @ld3lane_16b(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, i8* %A) nounwind {
 333 ; Make sure we are using the operands defined by the ABI
 334 ; CHECK: ld3lane_16b
 335 ; CHECK ld3.b { v0, v1, v2 }[1], [x0]
 336 ; CHECK-NEXT ret
 337         %tmp2 = call %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, i64 1, i8* %A)
 338         ret %struct.__neon_int8x16x3_t  %tmp2
 339 }
 340
 341 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 {
 342 ; Make sure we are using the operands defined by the ABI
 343 ; CHECK: ld4lane_16b
 344 ; CHECK ld4.b { v0, v1, v2, v3 }[1], [x0]
 345 ; CHECK-NEXT ret
 346         %tmp2 = call %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4lane.v16i8.p0i8(<16 x i8> %L1, <16 x i8> %L2, <16 x i8> %L3, <16 x i8> %L4, i64 1, i8* %A)
 347         ret %struct.__neon_int8x16x4_t  %tmp2
 348 }
 349
 350 declare %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2lane.v16i8.p0i8(<16 x i8>, <16 x i8>, i64, i8*) nounwind readonly
 351 declare %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3lane.v16i8.p0i8(<16 x i8>, <16 x i8>, <16 x i8>, i64, i8*) nounwind readonly
 352 declare %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4lane.v16i8.p0i8(<16 x i8>, <16 x i8>, <16 x i8>, <16 x i8>, i64, i8*) nounwind readonly
 353
 354 define %struct.__neon_int16x8x2_t @ld2lane_8h(<8 x i16> %L1, <8 x i16> %L2, i16* %A) nounwind {
 355 ; Make sure we are using the operands defined by the ABI
 356 ; CHECK: ld2lane_8h
 357 ; CHECK ld2.h { v0, v1 }[1], [x0]
 358 ; CHECK-NEXT ret
 359         %tmp2 = call %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, i64 1, i16* %A)
 360         ret %struct.__neon_int16x8x2_t  %tmp2
 361 }
 362
 363 define %struct.__neon_int16x8x3_t @ld3lane_8h(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, i16* %A) nounwind {
 364 ; Make sure we are using the operands defined by the ABI
 365 ; CHECK: ld3lane_8h
 366 ; CHECK ld3.h { v0, v1, v3 }[1], [x0]
 367 ; CHECK-NEXT ret
 368         %tmp2 = call %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, i64 1, i16* %A)
 369         ret %struct.__neon_int16x8x3_t  %tmp2
 370 }
 371
 372 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 {
 373 ; Make sure we are using the operands defined by the ABI
 374 ; CHECK: ld4lane_8h
 375 ; CHECK ld4.h { v0, v1, v2, v3 }[1], [x0]
 376 ; CHECK-NEXT ret
 377         %tmp2 = call %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4lane.v8i16.p0i16(<8 x i16> %L1, <8 x i16> %L2, <8 x i16> %L3, <8 x i16> %L4, i64 1, i16* %A)
 378         ret %struct.__neon_int16x8x4_t  %tmp2
 379 }
 380
 381 declare %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2lane.v8i16.p0i16(<8 x i16>, <8 x i16>, i64, i16*) nounwind readonly
 382 declare %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3lane.v8i16.p0i16(<8 x i16>, <8 x i16>, <8 x i16>, i64, i16*) nounwind readonly
 383 declare %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4lane.v8i16.p0i16(<8 x i16>, <8 x i16>, <8 x i16>, <8 x i16>, i64, i16*) nounwind readonly
 384
 385 define %struct.__neon_int32x4x2_t @ld2lane_4s(<4 x i32> %L1, <4 x i32> %L2, i32* %A) nounwind {
 386 ; Make sure we are using the operands defined by the ABI
 387 ; CHECK: ld2lane_4s
 388 ; CHECK ld2.s { v0, v1 }[1], [x0]
 389 ; CHECK-NEXT ret
 390         %tmp2 = call %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, i64 1, i32* %A)
 391         ret %struct.__neon_int32x4x2_t  %tmp2
 392 }
 393
 394 define %struct.__neon_int32x4x3_t @ld3lane_4s(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, i32* %A) nounwind {
 395 ; Make sure we are using the operands defined by the ABI
 396 ; CHECK: ld3lane_4s
 397 ; CHECK ld3.s { v0, v1, v2 }[1], [x0]
 398 ; CHECK-NEXT ret
 399         %tmp2 = call %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, i64 1, i32* %A)
 400         ret %struct.__neon_int32x4x3_t  %tmp2
 401 }
 402
 403 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 {
 404 ; Make sure we are using the operands defined by the ABI
 405 ; CHECK: ld4lane_4s
 406 ; CHECK ld4.s { v0, v1, v2, v3 }[1], [x0]
 407 ; CHECK-NEXT ret
 408         %tmp2 = call %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4lane.v4i32.p0i32(<4 x i32> %L1, <4 x i32> %L2, <4 x i32> %L3, <4 x i32> %L4, i64 1, i32* %A)
 409         ret %struct.__neon_int32x4x4_t  %tmp2
 410 }
 411
 412 declare %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2lane.v4i32.p0i32(<4 x i32>, <4 x i32>, i64, i32*) nounwind readonly
 413 declare %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3lane.v4i32.p0i32(<4 x i32>, <4 x i32>, <4 x i32>, i64, i32*) nounwind readonly
 414 declare %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4lane.v4i32.p0i32(<4 x i32>, <4 x i32>, <4 x i32>, <4 x i32>, i64, i32*) nounwind readonly
 415
 416 define %struct.__neon_int64x2x2_t @ld2lane_2d(<2 x i64> %L1, <2 x i64> %L2, i64* %A) nounwind {
 417 ; Make sure we are using the operands defined by the ABI
 418 ; CHECK: ld2lane_2d
 419 ; CHECK ld2.d { v0, v1 }[1], [x0]
 420 ; CHECK-NEXT ret
 421         %tmp2 = call %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, i64 1, i64* %A)
 422         ret %struct.__neon_int64x2x2_t  %tmp2
 423 }
 424
 425 define %struct.__neon_int64x2x3_t @ld3lane_2d(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, i64* %A) nounwind {
 426 ; Make sure we are using the operands defined by the ABI
 427 ; CHECK: ld3lane_2d
 428 ; CHECK ld3.d { v0, v1, v3 }[1], [x0]
 429 ; CHECK-NEXT ret
 430         %tmp2 = call %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, i64 1, i64* %A)
 431         ret %struct.__neon_int64x2x3_t  %tmp2
 432 }
 433
 434 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 {
 435 ; Make sure we are using the operands defined by the ABI
 436 ; CHECK: ld4lane_2d
 437 ; CHECK ld4.d { v0, v1, v2, v3 }[1], [x0]
 438 ; CHECK-NEXT ret
 439         %tmp2 = call %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4lane.v2i64.p0i64(<2 x i64> %L1, <2 x i64> %L2, <2 x i64> %L3, <2 x i64> %L4, i64 1, i64* %A)
 440         ret %struct.__neon_int64x2x4_t  %tmp2
 441 }
 442
 443 declare %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2lane.v2i64.p0i64(<2 x i64>, <2 x i64>, i64, i64*) nounwind readonly
 444 declare %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3lane.v2i64.p0i64(<2 x i64>, <2 x i64>, <2 x i64>, i64, i64*) nounwind readonly
 445 declare %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4lane.v2i64.p0i64(<2 x i64>, <2 x i64>, <2 x i64>, <2 x i64>, i64, i64*) nounwind readonly
 446
 447 define <8 x i8> @ld1r_8b(i8* %bar) {
 448 ; CHECK: ld1r_8b
 449 ; Make sure we are using the operands defined by the ABI
 450 ; CHECK: ld1r.8b { v0 }, [x0]
 451 ; CHECK-NEXT ret
 452   %tmp1 = load i8* %bar
 453   %tmp2 = insertelement <8 x i8> <i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef>, i8 %tmp1, i32 0
 454   %tmp3 = insertelement <8 x i8> %tmp2, i8 %tmp1, i32 1
 455   %tmp4 = insertelement <8 x i8> %tmp3, i8 %tmp1, i32 2
 456   %tmp5 = insertelement <8 x i8> %tmp4, i8 %tmp1, i32 3
 457   %tmp6 = insertelement <8 x i8> %tmp5, i8 %tmp1, i32 4
 458   %tmp7 = insertelement <8 x i8> %tmp6, i8 %tmp1, i32 5
 459   %tmp8 = insertelement <8 x i8> %tmp7, i8 %tmp1, i32 6
 460   %tmp9 = insertelement <8 x i8> %tmp8, i8 %tmp1, i32 7
 461   ret <8 x i8> %tmp9
 462 }
 463
 464 define <16 x i8> @ld1r_16b(i8* %bar) {
 465 ; CHECK: ld1r_16b
 466 ; Make sure we are using the operands defined by the ABI
 467 ; CHECK: ld1r.16b { v0 }, [x0]
 468 ; CHECK-NEXT ret
 469   %tmp1 = load i8* %bar
 470   %tmp2 = insertelement <16 x i8> <i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef, i8 undef>, i8 %tmp1, i32 0
 471   %tmp3 = insertelement <16 x i8> %tmp2, i8 %tmp1, i32 1
 472   %tmp4 = insertelement <16 x i8> %tmp3, i8 %tmp1, i32 2
 473   %tmp5 = insertelement <16 x i8> %tmp4, i8 %tmp1, i32 3
 474   %tmp6 = insertelement <16 x i8> %tmp5, i8 %tmp1, i32 4
 475   %tmp7 = insertelement <16 x i8> %tmp6, i8 %tmp1, i32 5
 476   %tmp8 = insertelement <16 x i8> %tmp7, i8 %tmp1, i32 6
 477   %tmp9 = insertelement <16 x i8> %tmp8, i8 %tmp1, i32 7
 478   %tmp10 = insertelement <16 x i8> %tmp9, i8 %tmp1, i32 8
 479   %tmp11 = insertelement <16 x i8> %tmp10, i8 %tmp1, i32 9
 480   %tmp12 = insertelement <16 x i8> %tmp11, i8 %tmp1, i32 10
 481   %tmp13 = insertelement <16 x i8> %tmp12, i8 %tmp1, i32 11
 482   %tmp14 = insertelement <16 x i8> %tmp13, i8 %tmp1, i32 12
 483   %tmp15 = insertelement <16 x i8> %tmp14, i8 %tmp1, i32 13
 484   %tmp16 = insertelement <16 x i8> %tmp15, i8 %tmp1, i32 14
 485   %tmp17 = insertelement <16 x i8> %tmp16, i8 %tmp1, i32 15
 486   ret <16 x i8> %tmp17
 487 }
 488
 489 define <4 x i16> @ld1r_4h(i16* %bar) {
 490 ; CHECK: ld1r_4h
 491 ; Make sure we are using the operands defined by the ABI
 492 ; CHECK: ld1r.4h { v0 }, [x0]
 493 ; CHECK-NEXT ret
 494   %tmp1 = load i16* %bar
 495   %tmp2 = insertelement <4 x i16> <i16 undef, i16 undef, i16 undef, i16 undef>, i16 %tmp1, i32 0
 496   %tmp3 = insertelement <4 x i16> %tmp2, i16 %tmp1, i32 1
 497   %tmp4 = insertelement <4 x i16> %tmp3, i16 %tmp1, i32 2
 498   %tmp5 = insertelement <4 x i16> %tmp4, i16 %tmp1, i32 3
 499   ret <4 x i16> %tmp5
 500 }
 501
 502 define <8 x i16> @ld1r_8h(i16* %bar) {
 503 ; CHECK: ld1r_8h
 504 ; Make sure we are using the operands defined by the ABI
 505 ; CHECK: ld1r.8h { v0 }, [x0]
 506 ; CHECK-NEXT ret
 507   %tmp1 = load i16* %bar
 508   %tmp2 = insertelement <8 x i16> <i16 undef, i16 undef, i16 undef, i16 undef, i16 undef, i16 undef, i16 undef, i16 undef>, i16 %tmp1, i32 0
 509   %tmp3 = insertelement <8 x i16> %tmp2, i16 %tmp1, i32 1
 510   %tmp4 = insertelement <8 x i16> %tmp3, i16 %tmp1, i32 2
 511   %tmp5 = insertelement <8 x i16> %tmp4, i16 %tmp1, i32 3
 512   %tmp6 = insertelement <8 x i16> %tmp5, i16 %tmp1, i32 4
 513   %tmp7 = insertelement <8 x i16> %tmp6, i16 %tmp1, i32 5
 514   %tmp8 = insertelement <8 x i16> %tmp7, i16 %tmp1, i32 6
 515   %tmp9 = insertelement <8 x i16> %tmp8, i16 %tmp1, i32 7
 516   ret <8 x i16> %tmp9
 517 }
 518
 519 define <2 x i32> @ld1r_2s(i32* %bar) {
 520 ; CHECK: ld1r_2s
 521 ; Make sure we are using the operands defined by the ABI
 522 ; CHECK: ld1r.2s { v0 }, [x0]
 523 ; CHECK-NEXT ret
 524   %tmp1 = load i32* %bar
 525   %tmp2 = insertelement <2 x i32> <i32 undef, i32 undef>, i32 %tmp1, i32 0
 526   %tmp3 = insertelement <2 x i32> %tmp2, i32 %tmp1, i32 1
 527   ret <2 x i32> %tmp3
 528 }
 529
 530 define <4 x i32> @ld1r_4s(i32* %bar) {
 531 ; CHECK: ld1r_4s
 532 ; Make sure we are using the operands defined by the ABI
 533 ; CHECK: ld1r.4s { v0 }, [x0]
 534 ; CHECK-NEXT ret
 535   %tmp1 = load i32* %bar
 536   %tmp2 = insertelement <4 x i32> <i32 undef, i32 undef, i32 undef, i32 undef>, i32 %tmp1, i32 0
 537   %tmp3 = insertelement <4 x i32> %tmp2, i32 %tmp1, i32 1
 538   %tmp4 = insertelement <4 x i32> %tmp3, i32 %tmp1, i32 2
 539   %tmp5 = insertelement <4 x i32> %tmp4, i32 %tmp1, i32 3
 540   ret <4 x i32> %tmp5
 541 }
 542
 543 define <2 x i64> @ld1r_2d(i64* %bar) {
 544 ; CHECK: ld1r_2d
 545 ; Make sure we are using the operands defined by the ABI
 546 ; CHECK: ld1r.2d { v0 }, [x0]
 547 ; CHECK-NEXT ret
 548   %tmp1 = load i64* %bar
 549   %tmp2 = insertelement <2 x i64> <i64 undef, i64 undef>, i64 %tmp1, i32 0
 550   %tmp3 = insertelement <2 x i64> %tmp2, i64 %tmp1, i32 1
 551   ret <2 x i64> %tmp3
 552 }
 553
 554 define %struct.__neon_int8x8x2_t @ld2r_8b(i8* %A) nounwind {
 555 ; CHECK: ld2r_8b
 556 ; Make sure we are using the operands defined by the ABI
 557 ; CHECK ld2r.8b { v0, v1 }, [x0]
 558 ; CHECK-NEXT ret
 559         %tmp2 = call %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld2r.v8i8.p0i8(i8* %A)
 560         ret %struct.__neon_int8x8x2_t  %tmp2
 561 }
 562
 563 define %struct.__neon_int8x8x3_t @ld3r_8b(i8* %A) nounwind {
 564 ; CHECK: ld3r_8b
 565 ; Make sure we are using the operands defined by the ABI
 566 ; CHECK ld3r.8b { v0, v1, v2 }, [x0]
 567 ; CHECK-NEXT ret
 568         %tmp2 = call %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld3r.v8i8.p0i8(i8* %A)
 569         ret %struct.__neon_int8x8x3_t  %tmp2
 570 }
 571
 572 define %struct.__neon_int8x8x4_t @ld4r_8b(i8* %A) nounwind {
 573 ; CHECK: ld4r_8b
 574 ; Make sure we are using the operands defined by the ABI
 575 ; CHECK ld4r.8b { v0, v1, v2, v3 }, [x0]
 576 ; CHECK-NEXT ret
 577         %tmp2 = call %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld4r.v8i8.p0i8(i8* %A)
 578         ret %struct.__neon_int8x8x4_t  %tmp2
 579 }
 580
 581 declare %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld2r.v8i8.p0i8(i8*) nounwind readonly
 582 declare %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld3r.v8i8.p0i8(i8*) nounwind readonly
 583 declare %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld4r.v8i8.p0i8(i8*) nounwind readonly
 584
 585 define %struct.__neon_int8x16x2_t @ld2r_16b(i8* %A) nounwind {
 586 ; CHECK: ld2r_16b
 587 ; Make sure we are using the operands defined by the ABI
 588 ; CHECK ld2r.16b { v0, v1 }, [x0]
 589 ; CHECK-NEXT ret
 590         %tmp2 = call %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2r.v16i8.p0i8(i8* %A)
 591         ret %struct.__neon_int8x16x2_t  %tmp2
 592 }
 593
 594 define %struct.__neon_int8x16x3_t @ld3r_16b(i8* %A) nounwind {
 595 ; CHECK: ld3r_16b
 596 ; Make sure we are using the operands defined by the ABI
 597 ; CHECK ld3r.16b { v0, v1, v2 }, [x0]
 598 ; CHECK-NEXT ret
 599         %tmp2 = call %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3r.v16i8.p0i8(i8* %A)
 600         ret %struct.__neon_int8x16x3_t  %tmp2
 601 }
 602
 603 define %struct.__neon_int8x16x4_t @ld4r_16b(i8* %A) nounwind {
 604 ; CHECK: ld4r_16b
 605 ; Make sure we are using the operands defined by the ABI
 606 ; CHECK ld4r.16b { v0, v1, v2, v3 }, [x0]
 607 ; CHECK-NEXT ret
 608         %tmp2 = call %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4r.v16i8.p0i8(i8* %A)
 609         ret %struct.__neon_int8x16x4_t  %tmp2
 610 }
 611
 612 declare %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld2r.v16i8.p0i8(i8*) nounwind readonly
 613 declare %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld3r.v16i8.p0i8(i8*) nounwind readonly
 614 declare %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld4r.v16i8.p0i8(i8*) nounwind readonly
 615
 616 define %struct.__neon_int16x4x2_t @ld2r_4h(i16* %A) nounwind {
 617 ; CHECK: ld2r_4h
 618 ; Make sure we are using the operands defined by the ABI
 619 ; CHECK ld2r.4h { v0, v1 }, [x0]
 620 ; CHECK-NEXT ret
 621         %tmp2 = call %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld2r.v4i16.p0i16(i16* %A)
 622         ret %struct.__neon_int16x4x2_t  %tmp2
 623 }
 624
 625 define %struct.__neon_int16x4x3_t @ld3r_4h(i16* %A) nounwind {
 626 ; CHECK: ld3r_4h
 627 ; Make sure we are using the operands defined by the ABI
 628 ; CHECK ld3r.4h { v0, v1, v2 }, [x0]
 629 ; CHECK-NEXT ret
 630         %tmp2 = call %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld3r.v4i16.p0i16(i16* %A)
 631         ret %struct.__neon_int16x4x3_t  %tmp2
 632 }
 633
 634 define %struct.__neon_int16x4x4_t @ld4r_4h(i16* %A) nounwind {
 635 ; CHECK: ld4r_4h
 636 ; Make sure we are using the operands defined by the ABI
 637 ; CHECK ld4r.4h { v0, v1, v2, v3 }, [x0]
 638 ; CHECK-NEXT ret
 639         %tmp2 = call %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld4r.v4i16.p0i16(i16* %A)
 640         ret %struct.__neon_int16x4x4_t  %tmp2
 641 }
 642
 643 declare %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld2r.v4i16.p0i16(i16*) nounwind readonly
 644 declare %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld3r.v4i16.p0i16(i16*) nounwind readonly
 645 declare %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld4r.v4i16.p0i16(i16*) nounwind readonly
 646
 647 define %struct.__neon_int16x8x2_t @ld2r_8h(i16* %A) nounwind {
 648 ; CHECK: ld2r_8h
 649 ; Make sure we are using the operands defined by the ABI
 650 ; CHECK ld2r.8h { v0, v1 }, [x0]
 651 ; CHECK-NEXT ret
 652   %tmp2 = call %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2r.v8i16.p0i16(i16* %A)
 653   ret %struct.__neon_int16x8x2_t  %tmp2
 654 }
 655
 656 define %struct.__neon_int16x8x3_t @ld3r_8h(i16* %A) nounwind {
 657 ; CHECK: ld3r_8h
 658 ; Make sure we are using the operands defined by the ABI
 659 ; CHECK ld3r.8h { v0, v1, v2 }, [x0]
 660 ; CHECK-NEXT ret
 661   %tmp2 = call %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3r.v8i16.p0i16(i16* %A)
 662   ret %struct.__neon_int16x8x3_t  %tmp2
 663 }
 664
 665 define %struct.__neon_int16x8x4_t @ld4r_8h(i16* %A) nounwind {
 666 ; CHECK: ld4r_8h
 667 ; Make sure we are using the operands defined by the ABI
 668 ; CHECK ld4r.8h { v0, v1, v2, v3 }, [x0]
 669 ; CHECK-NEXT ret
 670   %tmp2 = call %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4r.v8i16.p0i16(i16* %A)
 671   ret %struct.__neon_int16x8x4_t  %tmp2
 672 }
 673
 674 declare %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld2r.v8i16.p0i16(i16*) nounwind readonly
 675 declare %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld3r.v8i16.p0i16(i16*) nounwind readonly
 676 declare %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld4r.v8i16.p0i16(i16*) nounwind readonly
 677
 678 define %struct.__neon_int32x2x2_t @ld2r_2s(i32* %A) nounwind {
 679 ; CHECK: ld2r_2s
 680 ; Make sure we are using the operands defined by the ABI
 681 ; CHECK ld2r.2s { v0, v1 }, [x0]
 682 ; CHECK-NEXT ret
 683         %tmp2 = call %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld2r.v2i32.p0i32(i32* %A)
 684         ret %struct.__neon_int32x2x2_t  %tmp2
 685 }
 686
 687 define %struct.__neon_int32x2x3_t @ld3r_2s(i32* %A) nounwind {
 688 ; CHECK: ld3r_2s
 689 ; Make sure we are using the operands defined by the ABI
 690 ; CHECK ld3r.2s { v0, v1, v2 }, [x0]
 691 ; CHECK-NEXT ret
 692         %tmp2 = call %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld3r.v2i32.p0i32(i32* %A)
 693         ret %struct.__neon_int32x2x3_t  %tmp2
 694 }
 695
 696 define %struct.__neon_int32x2x4_t @ld4r_2s(i32* %A) nounwind {
 697 ; CHECK: ld4r_2s
 698 ; Make sure we are using the operands defined by the ABI
 699 ; CHECK ld4r.2s { v0, v1, v2, v3 }, [x0]
 700 ; CHECK-NEXT ret
 701         %tmp2 = call %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld4r.v2i32.p0i32(i32* %A)
 702         ret %struct.__neon_int32x2x4_t  %tmp2
 703 }
 704
 705 declare %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld2r.v2i32.p0i32(i32*) nounwind readonly
 706 declare %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld3r.v2i32.p0i32(i32*) nounwind readonly
 707 declare %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld4r.v2i32.p0i32(i32*) nounwind readonly
 708
 709 define %struct.__neon_int32x4x2_t @ld2r_4s(i32* %A) nounwind {
 710 ; CHECK: ld2r_4s
 711 ; Make sure we are using the operands defined by the ABI
 712 ; CHECK ld2r.4s { v0, v1 }, [x0]
 713 ; CHECK-NEXT ret
 714         %tmp2 = call %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2r.v4i32.p0i32(i32* %A)
 715         ret %struct.__neon_int32x4x2_t  %tmp2
 716 }
 717
 718 define %struct.__neon_int32x4x3_t @ld3r_4s(i32* %A) nounwind {
 719 ; CHECK: ld3r_4s
 720 ; Make sure we are using the operands defined by the ABI
 721 ; CHECK ld3r.4s { v0, v1, v2 }, [x0]
 722 ; CHECK-NEXT ret
 723         %tmp2 = call %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3r.v4i32.p0i32(i32* %A)
 724         ret %struct.__neon_int32x4x3_t  %tmp2
 725 }
 726
 727 define %struct.__neon_int32x4x4_t @ld4r_4s(i32* %A) nounwind {
 728 ; CHECK: ld4r_4s
 729 ; Make sure we are using the operands defined by the ABI
 730 ; CHECK ld4r.4s { v0, v1, v2, v3 }, [x0]
 731 ; CHECK-NEXT ret
 732         %tmp2 = call %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4r.v4i32.p0i32(i32* %A)
 733         ret %struct.__neon_int32x4x4_t  %tmp2
 734 }
 735
 736 declare %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld2r.v4i32.p0i32(i32*) nounwind readonly
 737 declare %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld3r.v4i32.p0i32(i32*) nounwind readonly
 738 declare %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld4r.v4i32.p0i32(i32*) nounwind readonly
 739
 740 define %struct.__neon_int64x2x2_t @ld2r_2d(i64* %A) nounwind {
 741 ; CHECK: ld2r_2d
 742 ; Make sure we are using the operands defined by the ABI
 743 ; CHECK ld2r.2d { v0, v1 }, [x0]
 744 ; CHECK-NEXT ret
 745         %tmp2 = call %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2r.v2i64.p0i64(i64* %A)
 746         ret %struct.__neon_int64x2x2_t  %tmp2
 747 }
 748
 749 define %struct.__neon_int64x2x3_t @ld3r_2d(i64* %A) nounwind {
 750 ; CHECK: ld3r_2d
 751 ; Make sure we are using the operands defined by the ABI
 752 ; CHECK ld3r.2d { v0, v1, v2 }, [x0]
 753 ; CHECK-NEXT ret
 754         %tmp2 = call %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3r.v2i64.p0i64(i64* %A)
 755         ret %struct.__neon_int64x2x3_t  %tmp2
 756 }
 757
 758 define %struct.__neon_int64x2x4_t @ld4r_2d(i64* %A) nounwind {
 759 ; CHECK: ld4r_2d
 760 ; Make sure we are using the operands defined by the ABI
 761 ; CHECK ld4r.2d { v0, v1, v2, v3 }, [x0]
 762 ; CHECK-NEXT ret
 763         %tmp2 = call %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4r.v2i64.p0i64(i64* %A)
 764         ret %struct.__neon_int64x2x4_t  %tmp2
 765 }
 766
 767 declare %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld2r.v2i64.p0i64(i64*) nounwind readonly
 768 declare %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld3r.v2i64.p0i64(i64*) nounwind readonly
 769 declare %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld4r.v2i64.p0i64(i64*) nounwind readonly
 770
 771 define <16 x i8> @ld1_16b(<16 x i8> %V, i8* %bar) {
 772 ; CHECK: ld1_16b
 773 ; Make sure we are using the operands defined by the ABI
 774 ; CHECK: ld1.b { v0 }[0], [x0]
 775 ; CHECK-NEXT ret
 776   %tmp1 = load i8* %bar
 777   %tmp2 = insertelement <16 x i8> %V, i8 %tmp1, i32 0
 778   ret <16 x i8> %tmp2
 779 }
 780
 781 define <8 x i16> @ld1_8h(<8 x i16> %V, i16* %bar) {
 782 ; CHECK: ld1_8h
 783 ; Make sure we are using the operands defined by the ABI
 784 ; CHECK: ld1.h { v0 }[0], [x0]
 785 ; CHECK-NEXT ret
 786   %tmp1 = load i16* %bar
 787   %tmp2 = insertelement <8 x i16> %V, i16 %tmp1, i32 0
 788   ret <8 x i16> %tmp2
 789 }
 790
 791 define <4 x i32> @ld1_4s(<4 x i32> %V, i32* %bar) {
 792 ; CHECK: ld1_4s
 793 ; Make sure we are using the operands defined by the ABI
 794 ; CHECK: ld1.s { v0 }[0], [x0]
 795 ; CHECK-NEXT ret
 796   %tmp1 = load i32* %bar
 797   %tmp2 = insertelement <4 x i32> %V, i32 %tmp1, i32 0
 798   ret <4 x i32> %tmp2
 799 }
 800
 801 define <2 x i64> @ld1_2d(<2 x i64> %V, i64* %bar) {
 802 ; CHECK: ld1_2d
 803 ; Make sure we are using the operands defined by the ABI
 804 ; CHECK: ld1.d { v0 }[0], [x0]
 805 ; CHECK-NEXT ret
 806   %tmp1 = load i64* %bar
 807   %tmp2 = insertelement <2 x i64> %V, i64 %tmp1, i32 0
 808   ret <2 x i64> %tmp2
 809 }
 810
 811 define <1 x i64> @ld1_1d(<1 x i64>* %p) {
 812 ; CHECK: ld1_1d
 813 ; Make sure we are using the operands defined by the ABI
 814 ; CHECK: ldr [[REG:d[0-9]+]], [x0]
 815 ; CHECK-NEXT: ret
 816   %tmp = load <1 x i64>* %p, align 8
 817   ret <1 x i64> %tmp
 818 }
 819
 820
 821 ; Add rdar://13098923 test case: vld1_dup_u32 doesn't generate ld1r.2s
 822 define void @ld1r_2s_from_dup(i8* nocapture %a, i8* nocapture %b, i16* nocapture %diff) nounwind ssp {
 823 entry:
 824 ; CHECK: ld1r_2s_from_dup
 825 ; CHECK: ld1r.2s { [[ARG1:v[0-9]+]] }, [x0]
 826 ; CHECK-NEXT: ld1r.2s { [[ARG2:v[0-9]+]] }, [x1]
 827 ; CHECK-NEXT: usubl.8h v[[RESREGNUM:[0-9]+]], [[ARG1]], [[ARG2]]
 828 ; CHECK-NEXT: str d[[RESREGNUM]], [x2]
 829 ; CHECK-NEXT: ret
 830   %tmp = bitcast i8* %a to i32*
 831   %tmp1 = load i32* %tmp, align 4
 832   %tmp2 = insertelement <2 x i32> undef, i32 %tmp1, i32 0
 833   %lane = shufflevector <2 x i32> %tmp2, <2 x i32> undef, <2 x i32> zeroinitializer
 834   %tmp3 = bitcast <2 x i32> %lane to <8 x i8>
 835   %tmp4 = bitcast i8* %b to i32*
 836   %tmp5 = load i32* %tmp4, align 4
 837   %tmp6 = insertelement <2 x i32> undef, i32 %tmp5, i32 0
 838   %lane1 = shufflevector <2 x i32> %tmp6, <2 x i32> undef, <2 x i32> zeroinitializer
 839   %tmp7 = bitcast <2 x i32> %lane1 to <8 x i8>
 840   %vmovl.i.i = zext <8 x i8> %tmp3 to <8 x i16>
 841   %vmovl.i4.i = zext <8 x i8> %tmp7 to <8 x i16>
 842   %sub.i = sub <8 x i16> %vmovl.i.i, %vmovl.i4.i
 843   %tmp8 = bitcast <8 x i16> %sub.i to <2 x i64>
 844   %shuffle.i = shufflevector <2 x i64> %tmp8, <2 x i64> undef, <1 x i32> zeroinitializer
 845   %tmp9 = bitcast <1 x i64> %shuffle.i to <4 x i16>
 846   %tmp10 = bitcast i16* %diff to <4 x i16>*
 847   store <4 x i16> %tmp9, <4 x i16>* %tmp10, align 8
 848   ret void
 849 }
 850
 851 ; Tests for rdar://11947069: vld1_dup_* and vld1q_dup_* code gen is suboptimal
 852 define <4 x float> @ld1r_4s_float(float* nocapture %x) {
 853 entry:
 854 ; CHECK: ld1r_4s_float
 855 ; Make sure we are using the operands defined by the ABI
 856 ; CHECK: ld1r.4s { v0 }, [x0]
 857 ; CHECK-NEXT ret
 858   %tmp = load float* %x, align 4
 859   %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
 860   %tmp2 = insertelement <4 x float> %tmp1, float %tmp, i32 1
 861   %tmp3 = insertelement <4 x float> %tmp2, float %tmp, i32 2
 862   %tmp4 = insertelement <4 x float> %tmp3, float %tmp, i32 3
 863   ret <4 x float> %tmp4
 864 }
 865
 866 define <2 x float> @ld1r_2s_float(float* nocapture %x) {
 867 entry:
 868 ; CHECK: ld1r_2s_float
 869 ; Make sure we are using the operands defined by the ABI
 870 ; CHECK: ld1r.2s { v0 }, [x0]
 871 ; CHECK-NEXT ret
 872   %tmp = load float* %x, align 4
 873   %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
 874   %tmp2 = insertelement <2 x float> %tmp1, float %tmp, i32 1
 875   ret <2 x float> %tmp2
 876 }
 877
 878 define <2 x double> @ld1r_2d_double(double* nocapture %x) {
 879 entry:
 880 ; CHECK: ld1r_2d_double
 881 ; Make sure we are using the operands defined by the ABI
 882 ; CHECK: ld1r.2d { v0 }, [x0]
 883 ; CHECK-NEXT ret
 884   %tmp = load double* %x, align 4
 885   %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
 886   %tmp2 = insertelement <2 x double> %tmp1, double %tmp, i32 1
 887   ret <2 x double> %tmp2
 888 }
 889
 890 define <1 x double> @ld1r_1d_double(double* nocapture %x) {
 891 entry:
 892 ; CHECK: ld1r_1d_double
 893 ; Make sure we are using the operands defined by the ABI
 894 ; CHECK: ldr d0, [x0]
 895 ; CHECK-NEXT ret
 896   %tmp = load double* %x, align 4
 897   %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
 898   ret <1 x double> %tmp1
 899 }
 900
 901 define <4 x float> @ld1r_4s_float_shuff(float* nocapture %x) {
 902 entry:
 903 ; CHECK: ld1r_4s_float_shuff
 904 ; Make sure we are using the operands defined by the ABI
 905 ; CHECK: ld1r.4s { v0 }, [x0]
 906 ; CHECK-NEXT ret
 907   %tmp = load float* %x, align 4
 908   %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
 909   %lane = shufflevector <4 x float> %tmp1, <4 x float> undef, <4 x i32> zeroinitializer
 910   ret <4 x float> %lane
 911 }
 912
 913 define <2 x float> @ld1r_2s_float_shuff(float* nocapture %x) {
 914 entry:
 915 ; CHECK: ld1r_2s_float_shuff
 916 ; Make sure we are using the operands defined by the ABI
 917 ; CHECK: ld1r.2s { v0 }, [x0]
 918 ; CHECK-NEXT ret
 919   %tmp = load float* %x, align 4
 920   %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
 921   %lane = shufflevector <2 x float> %tmp1, <2 x float> undef, <2 x i32> zeroinitializer
 922   ret <2 x float> %lane
 923 }
 924
 925 define <2 x double> @ld1r_2d_double_shuff(double* nocapture %x) {
 926 entry:
 927 ; CHECK: ld1r_2d_double_shuff
 928 ; Make sure we are using the operands defined by the ABI
 929 ; CHECK: ld1r.2d { v0 }, [x0]
 930 ; CHECK-NEXT ret
 931   %tmp = load double* %x, align 4
 932   %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
 933   %lane = shufflevector <2 x double> %tmp1, <2 x double> undef, <2 x i32> zeroinitializer
 934   ret <2 x double> %lane
 935 }
 936
 937 define <1 x double> @ld1r_1d_double_shuff(double* nocapture %x) {
 938 entry:
 939 ; CHECK: ld1r_1d_double_shuff
 940 ; Make sure we are using the operands defined by the ABI
 941 ; CHECK: ldr d0, [x0]
 942 ; CHECK-NEXT ret
 943   %tmp = load double* %x, align 4
 944   %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
 945   %lane = shufflevector <1 x double> %tmp1, <1 x double> undef, <1 x i32> zeroinitializer
 946   ret <1 x double> %lane
 947 }
 948
 949 %struct.__neon_float32x2x2_t = type { <2 x float>,  <2 x float> }
 950 %struct.__neon_float32x2x3_t = type { <2 x float>,  <2 x float>,  <2 x float> }
 951 %struct.__neon_float32x2x4_t = type { <2 x float>,  <2 x float>, <2 x float>,  <2 x float> }
 952
 953 declare %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld1x2.v8i8.p0i8(i8*) nounwind readonly
 954 declare %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld1x2.v4i16.p0i16(i16*) nounwind readonly
 955 declare %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld1x2.v2i32.p0i32(i32*) nounwind readonly
 956 declare %struct.__neon_float32x2x2_t @llvm.arm64.neon.ld1x2.v2f32.p0f32(float*) nounwind readonly
 957 declare %struct.__neon_int64x1x2_t @llvm.arm64.neon.ld1x2.v1i64.p0i64(i64*) nounwind readonly
 958 declare %struct.__neon_float64x1x2_t @llvm.arm64.neon.ld1x2.v1f64.p0f64(double*) nounwind readonly
 959
 960 define %struct.__neon_int8x8x2_t @ld1_x2_v8i8(i8* %addr) {
 961 ; CHECK-LABEL: ld1_x2_v8i8:
 962 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 963   %val = call %struct.__neon_int8x8x2_t @llvm.arm64.neon.ld1x2.v8i8.p0i8(i8* %addr)
 964   ret %struct.__neon_int8x8x2_t %val
 965 }
 966
 967 define %struct.__neon_int16x4x2_t @ld1_x2_v4i16(i16* %addr) {
 968 ; CHECK-LABEL: ld1_x2_v4i16:
 969 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 970   %val = call %struct.__neon_int16x4x2_t @llvm.arm64.neon.ld1x2.v4i16.p0i16(i16* %addr)
 971   ret %struct.__neon_int16x4x2_t %val
 972 }
 973
 974 define %struct.__neon_int32x2x2_t @ld1_x2_v2i32(i32* %addr) {
 975 ; CHECK-LABEL: ld1_x2_v2i32:
 976 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 977   %val = call %struct.__neon_int32x2x2_t @llvm.arm64.neon.ld1x2.v2i32.p0i32(i32* %addr)
 978   ret %struct.__neon_int32x2x2_t %val
 979 }
 980
 981 define %struct.__neon_float32x2x2_t @ld1_x2_v2f32(float* %addr) {
 982 ; CHECK-LABEL: ld1_x2_v2f32:
 983 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 984   %val = call %struct.__neon_float32x2x2_t @llvm.arm64.neon.ld1x2.v2f32.p0f32(float* %addr)
 985   ret %struct.__neon_float32x2x2_t %val
 986 }
 987
 988 define %struct.__neon_int64x1x2_t @ld1_x2_v1i64(i64* %addr) {
 989 ; CHECK-LABEL: ld1_x2_v1i64:
 990 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 991   %val = call %struct.__neon_int64x1x2_t @llvm.arm64.neon.ld1x2.v1i64.p0i64(i64* %addr)
 992   ret %struct.__neon_int64x1x2_t %val
 993 }
 994
 995 define %struct.__neon_float64x1x2_t @ld1_x2_v1f64(double* %addr) {
 996 ; CHECK-LABEL: ld1_x2_v1f64:
 997 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
 998   %val = call %struct.__neon_float64x1x2_t @llvm.arm64.neon.ld1x2.v1f64.p0f64(double* %addr)
 999   ret %struct.__neon_float64x1x2_t %val
1000 }
1001
1002
1003 %struct.__neon_float32x4x2_t = type { <4 x float>,  <4 x float> }
1004 %struct.__neon_float32x4x3_t = type { <4 x float>,  <4 x float>,  <4 x float> }
1005 %struct.__neon_float32x4x4_t = type { <4 x float>,  <4 x float>, <4 x float>,  <4 x float> }
1006
1007 %struct.__neon_float64x2x2_t = type { <2 x double>,  <2 x double> }
1008 %struct.__neon_float64x2x3_t = type { <2 x double>,  <2 x double>,  <2 x double> }
1009 %struct.__neon_float64x2x4_t = type { <2 x double>,  <2 x double>, <2 x double>,  <2 x double> }
1010
1011 declare %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld1x2.v16i8.p0i8(i8*) nounwind readonly
1012 declare %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld1x2.v8i16.p0i16(i16*) nounwind readonly
1013 declare %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld1x2.v4i32.p0i32(i32*) nounwind readonly
1014 declare %struct.__neon_float32x4x2_t @llvm.arm64.neon.ld1x2.v4f32.p0f32(float*) nounwind readonly
1015 declare %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld1x2.v2i64.p0i64(i64*) nounwind readonly
1016 declare %struct.__neon_float64x2x2_t @llvm.arm64.neon.ld1x2.v2f64.p0f64(double*) nounwind readonly
1017
1018 define %struct.__neon_int8x16x2_t @ld1_x2_v16i8(i8* %addr) {
1019 ; CHECK-LABEL: ld1_x2_v16i8:
1020 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1021   %val = call %struct.__neon_int8x16x2_t @llvm.arm64.neon.ld1x2.v16i8.p0i8(i8* %addr)
1022   ret %struct.__neon_int8x16x2_t %val
1023 }
1024
1025 define %struct.__neon_int16x8x2_t @ld1_x2_v8i16(i16* %addr) {
1026 ; CHECK-LABEL: ld1_x2_v8i16:
1027 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1028   %val = call %struct.__neon_int16x8x2_t @llvm.arm64.neon.ld1x2.v8i16.p0i16(i16* %addr)
1029   ret %struct.__neon_int16x8x2_t %val
1030 }
1031
1032 define %struct.__neon_int32x4x2_t @ld1_x2_v4i32(i32* %addr) {
1033 ; CHECK-LABEL: ld1_x2_v4i32:
1034 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1035   %val = call %struct.__neon_int32x4x2_t @llvm.arm64.neon.ld1x2.v4i32.p0i32(i32* %addr)
1036   ret %struct.__neon_int32x4x2_t %val
1037 }
1038
1039 define %struct.__neon_float32x4x2_t @ld1_x2_v4f32(float* %addr) {
1040 ; CHECK-LABEL: ld1_x2_v4f32:
1041 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1042   %val = call %struct.__neon_float32x4x2_t @llvm.arm64.neon.ld1x2.v4f32.p0f32(float* %addr)
1043   ret %struct.__neon_float32x4x2_t %val
1044 }
1045
1046 define %struct.__neon_int64x2x2_t @ld1_x2_v2i64(i64* %addr) {
1047 ; CHECK-LABEL: ld1_x2_v2i64:
1048 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1049   %val = call %struct.__neon_int64x2x2_t @llvm.arm64.neon.ld1x2.v2i64.p0i64(i64* %addr)
1050   ret %struct.__neon_int64x2x2_t %val
1051 }
1052
1053 define %struct.__neon_float64x2x2_t @ld1_x2_v2f64(double* %addr) {
1054 ; CHECK-LABEL: ld1_x2_v2f64:
1055 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1056   %val = call %struct.__neon_float64x2x2_t @llvm.arm64.neon.ld1x2.v2f64.p0f64(double* %addr)
1057   ret %struct.__neon_float64x2x2_t %val
1058 }
1059
1060 declare %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld1x3.v8i8.p0i8(i8*) nounwind readonly
1061 declare %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld1x3.v4i16.p0i16(i16*) nounwind readonly
1062 declare %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld1x3.v2i32.p0i32(i32*) nounwind readonly
1063 declare %struct.__neon_float32x2x3_t @llvm.arm64.neon.ld1x3.v2f32.p0f32(float*) nounwind readonly
1064 declare %struct.__neon_int64x1x3_t @llvm.arm64.neon.ld1x3.v1i64.p0i64(i64*) nounwind readonly
1065 declare %struct.__neon_float64x1x3_t @llvm.arm64.neon.ld1x3.v1f64.p0f64(double*) nounwind readonly
1066
1067 define %struct.__neon_int8x8x3_t @ld1_x3_v8i8(i8* %addr) {
1068 ; CHECK-LABEL: ld1_x3_v8i8:
1069 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1070   %val = call %struct.__neon_int8x8x3_t @llvm.arm64.neon.ld1x3.v8i8.p0i8(i8* %addr)
1071   ret %struct.__neon_int8x8x3_t %val
1072 }
1073
1074 define %struct.__neon_int16x4x3_t @ld1_x3_v4i16(i16* %addr) {
1075 ; CHECK-LABEL: ld1_x3_v4i16:
1076 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1077   %val = call %struct.__neon_int16x4x3_t @llvm.arm64.neon.ld1x3.v4i16.p0i16(i16* %addr)
1078   ret %struct.__neon_int16x4x3_t %val
1079 }
1080
1081 define %struct.__neon_int32x2x3_t @ld1_x3_v2i32(i32* %addr) {
1082 ; CHECK-LABEL: ld1_x3_v2i32:
1083 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1084   %val = call %struct.__neon_int32x2x3_t @llvm.arm64.neon.ld1x3.v2i32.p0i32(i32* %addr)
1085   ret %struct.__neon_int32x2x3_t %val
1086 }
1087
1088 define %struct.__neon_float32x2x3_t @ld1_x3_v2f32(float* %addr) {
1089 ; CHECK-LABEL: ld1_x3_v2f32:
1090 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1091   %val = call %struct.__neon_float32x2x3_t @llvm.arm64.neon.ld1x3.v2f32.p0f32(float* %addr)
1092   ret %struct.__neon_float32x2x3_t %val
1093 }
1094
1095 define %struct.__neon_int64x1x3_t @ld1_x3_v1i64(i64* %addr) {
1096 ; CHECK-LABEL: ld1_x3_v1i64:
1097 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1098   %val = call %struct.__neon_int64x1x3_t @llvm.arm64.neon.ld1x3.v1i64.p0i64(i64* %addr)
1099   ret %struct.__neon_int64x1x3_t %val
1100 }
1101
1102 define %struct.__neon_float64x1x3_t @ld1_x3_v1f64(double* %addr) {
1103 ; CHECK-LABEL: ld1_x3_v1f64:
1104 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1105   %val = call %struct.__neon_float64x1x3_t @llvm.arm64.neon.ld1x3.v1f64.p0f64(double* %addr)
1106   ret %struct.__neon_float64x1x3_t %val
1107 }
1108
1109 declare %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld1x3.v16i8.p0i8(i8*) nounwind readonly
1110 declare %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld1x3.v8i16.p0i16(i16*) nounwind readonly
1111 declare %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld1x3.v4i32.p0i32(i32*) nounwind readonly
1112 declare %struct.__neon_float32x4x3_t @llvm.arm64.neon.ld1x3.v4f32.p0f32(float*) nounwind readonly
1113 declare %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld1x3.v2i64.p0i64(i64*) nounwind readonly
1114 declare %struct.__neon_float64x2x3_t @llvm.arm64.neon.ld1x3.v2f64.p0f64(double*) nounwind readonly
1115
1116 define %struct.__neon_int8x16x3_t @ld1_x3_v16i8(i8* %addr) {
1117 ; CHECK-LABEL: ld1_x3_v16i8:
1118 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1119   %val = call %struct.__neon_int8x16x3_t @llvm.arm64.neon.ld1x3.v16i8.p0i8(i8* %addr)
1120   ret %struct.__neon_int8x16x3_t %val
1121 }
1122
1123 define %struct.__neon_int16x8x3_t @ld1_x3_v8i16(i16* %addr) {
1124 ; CHECK-LABEL: ld1_x3_v8i16:
1125 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1126   %val = call %struct.__neon_int16x8x3_t @llvm.arm64.neon.ld1x3.v8i16.p0i16(i16* %addr)
1127   ret %struct.__neon_int16x8x3_t %val
1128 }
1129
1130 define %struct.__neon_int32x4x3_t @ld1_x3_v4i32(i32* %addr) {
1131 ; CHECK-LABEL: ld1_x3_v4i32:
1132 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1133   %val = call %struct.__neon_int32x4x3_t @llvm.arm64.neon.ld1x3.v4i32.p0i32(i32* %addr)
1134   ret %struct.__neon_int32x4x3_t %val
1135 }
1136
1137 define %struct.__neon_float32x4x3_t @ld1_x3_v4f32(float* %addr) {
1138 ; CHECK-LABEL: ld1_x3_v4f32:
1139 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1140   %val = call %struct.__neon_float32x4x3_t @llvm.arm64.neon.ld1x3.v4f32.p0f32(float* %addr)
1141   ret %struct.__neon_float32x4x3_t %val
1142 }
1143
1144 define %struct.__neon_int64x2x3_t @ld1_x3_v2i64(i64* %addr) {
1145 ; CHECK-LABEL: ld1_x3_v2i64:
1146 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1147   %val = call %struct.__neon_int64x2x3_t @llvm.arm64.neon.ld1x3.v2i64.p0i64(i64* %addr)
1148   ret %struct.__neon_int64x2x3_t %val
1149 }
1150
1151 define %struct.__neon_float64x2x3_t @ld1_x3_v2f64(double* %addr) {
1152 ; CHECK-LABEL: ld1_x3_v2f64:
1153 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1154   %val = call %struct.__neon_float64x2x3_t @llvm.arm64.neon.ld1x3.v2f64.p0f64(double* %addr)
1155   ret %struct.__neon_float64x2x3_t %val
1156 }
1157
1158 declare %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld1x4.v8i8.p0i8(i8*) nounwind readonly
1159 declare %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld1x4.v4i16.p0i16(i16*) nounwind readonly
1160 declare %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld1x4.v2i32.p0i32(i32*) nounwind readonly
1161 declare %struct.__neon_float32x2x4_t @llvm.arm64.neon.ld1x4.v2f32.p0f32(float*) nounwind readonly
1162 declare %struct.__neon_int64x1x4_t @llvm.arm64.neon.ld1x4.v1i64.p0i64(i64*) nounwind readonly
1163 declare %struct.__neon_float64x1x4_t @llvm.arm64.neon.ld1x4.v1f64.p0f64(double*) nounwind readonly
1164
1165 define %struct.__neon_int8x8x4_t @ld1_x4_v8i8(i8* %addr) {
1166 ; CHECK-LABEL: ld1_x4_v8i8:
1167 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1168   %val = call %struct.__neon_int8x8x4_t @llvm.arm64.neon.ld1x4.v8i8.p0i8(i8* %addr)
1169   ret %struct.__neon_int8x8x4_t %val
1170 }
1171
1172 define %struct.__neon_int16x4x4_t @ld1_x4_v4i16(i16* %addr) {
1173 ; CHECK-LABEL: ld1_x4_v4i16:
1174 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1175   %val = call %struct.__neon_int16x4x4_t @llvm.arm64.neon.ld1x4.v4i16.p0i16(i16* %addr)
1176   ret %struct.__neon_int16x4x4_t %val
1177 }
1178
1179 define %struct.__neon_int32x2x4_t @ld1_x4_v2i32(i32* %addr) {
1180 ; CHECK-LABEL: ld1_x4_v2i32:
1181 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1182   %val = call %struct.__neon_int32x2x4_t @llvm.arm64.neon.ld1x4.v2i32.p0i32(i32* %addr)
1183   ret %struct.__neon_int32x2x4_t %val
1184 }
1185
1186 define %struct.__neon_float32x2x4_t @ld1_x4_v2f32(float* %addr) {
1187 ; CHECK-LABEL: ld1_x4_v2f32:
1188 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1189   %val = call %struct.__neon_float32x2x4_t @llvm.arm64.neon.ld1x4.v2f32.p0f32(float* %addr)
1190   ret %struct.__neon_float32x2x4_t %val
1191 }
1192
1193 define %struct.__neon_int64x1x4_t @ld1_x4_v1i64(i64* %addr) {
1194 ; CHECK-LABEL: ld1_x4_v1i64:
1195 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1196   %val = call %struct.__neon_int64x1x4_t @llvm.arm64.neon.ld1x4.v1i64.p0i64(i64* %addr)
1197   ret %struct.__neon_int64x1x4_t %val
1198 }
1199
1200 define %struct.__neon_float64x1x4_t @ld1_x4_v1f64(double* %addr) {
1201 ; CHECK-LABEL: ld1_x4_v1f64:
1202 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1203   %val = call %struct.__neon_float64x1x4_t @llvm.arm64.neon.ld1x4.v1f64.p0f64(double* %addr)
1204   ret %struct.__neon_float64x1x4_t %val
1205 }
1206
1207 declare %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld1x4.v16i8.p0i8(i8*) nounwind readonly
1208 declare %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld1x4.v8i16.p0i16(i16*) nounwind readonly
1209 declare %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld1x4.v4i32.p0i32(i32*) nounwind readonly
1210 declare %struct.__neon_float32x4x4_t @llvm.arm64.neon.ld1x4.v4f32.p0f32(float*) nounwind readonly
1211 declare %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld1x4.v2i64.p0i64(i64*) nounwind readonly
1212 declare %struct.__neon_float64x2x4_t @llvm.arm64.neon.ld1x4.v2f64.p0f64(double*) nounwind readonly
1213
1214 define %struct.__neon_int8x16x4_t @ld1_x4_v16i8(i8* %addr) {
1215 ; CHECK-LABEL: ld1_x4_v16i8:
1216 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1217   %val = call %struct.__neon_int8x16x4_t @llvm.arm64.neon.ld1x4.v16i8.p0i8(i8* %addr)
1218   ret %struct.__neon_int8x16x4_t %val
1219 }
1220
1221 define %struct.__neon_int16x8x4_t @ld1_x4_v8i16(i16* %addr) {
1222 ; CHECK-LABEL: ld1_x4_v8i16:
1223 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1224   %val = call %struct.__neon_int16x8x4_t @llvm.arm64.neon.ld1x4.v8i16.p0i16(i16* %addr)
1225   ret %struct.__neon_int16x8x4_t %val
1226 }
1227
1228 define %struct.__neon_int32x4x4_t @ld1_x4_v4i32(i32* %addr) {
1229 ; CHECK-LABEL: ld1_x4_v4i32:
1230 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1231   %val = call %struct.__neon_int32x4x4_t @llvm.arm64.neon.ld1x4.v4i32.p0i32(i32* %addr)
1232   ret %struct.__neon_int32x4x4_t %val
1233 }
1234
1235 define %struct.__neon_float32x4x4_t @ld1_x4_v4f32(float* %addr) {
1236 ; CHECK-LABEL: ld1_x4_v4f32:
1237 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1238   %val = call %struct.__neon_float32x4x4_t @llvm.arm64.neon.ld1x4.v4f32.p0f32(float* %addr)
1239   ret %struct.__neon_float32x4x4_t %val
1240 }
1241
1242 define %struct.__neon_int64x2x4_t @ld1_x4_v2i64(i64* %addr) {
1243 ; CHECK-LABEL: ld1_x4_v2i64:
1244 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1245   %val = call %struct.__neon_int64x2x4_t @llvm.arm64.neon.ld1x4.v2i64.p0i64(i64* %addr)
1246   ret %struct.__neon_int64x2x4_t %val
1247 }
1248
1249 define %struct.__neon_float64x2x4_t @ld1_x4_v2f64(double* %addr) {
1250 ; CHECK-LABEL: ld1_x4_v2f64:
1251 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1252   %val = call %struct.__neon_float64x2x4_t @llvm.arm64.neon.ld1x4.v2f64.p0f64(double* %addr)
1253   ret %struct.__neon_float64x2x4_t %val
1254 }