test/CodeGen/AArch64/arm64-ld1.ll

   1 ; RUN: llc < %s -march=arm64 -aarch64-neon-syntax=apple -verify-machineinstrs -asm-verbose=false | 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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v8i8.p0i8(i8* %A)
  32         ret %struct.__neon_int8x8x4_t  %tmp2
  33 }
  34
  35 declare %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2.v8i8.p0i8(i8*) nounwind readonly
  36 declare %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld3.v8i8.p0i8(i8*) nounwind readonly
  37 declare %struct.__neon_int8x8x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v16i8.p0i8(i8* %A)
  67   ret %struct.__neon_int8x16x4_t  %tmp2
  68 }
  69
  70 declare %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2.v16i8.p0i8(i8*) nounwind readonly
  71 declare %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3.v16i8.p0i8(i8*) nounwind readonly
  72 declare %struct.__neon_int8x16x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v4i16.p0i16(i16* %A)
 102         ret %struct.__neon_int16x4x4_t  %tmp2
 103 }
 104
 105 declare %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld2.v4i16.p0i16(i16*) nounwind readonly
 106 declare %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld3.v4i16.p0i16(i16*) nounwind readonly
 107 declare %struct.__neon_int16x4x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v8i16.p0i16(i16* %A)
 137   ret %struct.__neon_int16x8x4_t  %tmp2
 138 }
 139
 140 declare %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2.v8i16.p0i16(i16*) nounwind readonly
 141 declare %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3.v8i16.p0i16(i16*) nounwind readonly
 142 declare %struct.__neon_int16x8x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v2i32.p0i32(i32* %A)
 172         ret %struct.__neon_int32x2x4_t  %tmp2
 173 }
 174
 175 declare %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld2.v2i32.p0i32(i32*) nounwind readonly
 176 declare %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld3.v2i32.p0i32(i32*) nounwind readonly
 177 declare %struct.__neon_int32x2x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v4i32.p0i32(i32* %A)
 207         ret %struct.__neon_int32x4x4_t  %tmp2
 208 }
 209
 210 declare %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2.v4i32.p0i32(i32*) nounwind readonly
 211 declare %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3.v4i32.p0i32(i32*) nounwind readonly
 212 declare %struct.__neon_int32x4x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v2i64.p0i64(i64* %A)
 242         ret %struct.__neon_int64x2x4_t  %tmp2
 243 }
 244
 245 declare %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2.v2i64.p0i64(i64*) nounwind readonly
 246 declare %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3.v2i64.p0i64(i64*) nounwind readonly
 247 declare %struct.__neon_int64x2x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v1i64.p0i64(i64* %A)
 278         ret %struct.__neon_int64x1x4_t  %tmp2
 279 }
 280
 281
 282 declare %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld2.v1i64.p0i64(i64*) nounwind readonly
 283 declare %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld3.v1i64.p0i64(i64*) nounwind readonly
 284 declare %struct.__neon_int64x1x4_t @llvm.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.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-LABEL: 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.aarch64.neon.ld4.v1f64.p0f64(double* %A)
 315         ret %struct.__neon_float64x1x4_t  %tmp2
 316 }
 317
 318 declare %struct.__neon_float64x1x2_t @llvm.aarch64.neon.ld2.v1f64.p0f64(double*) nounwind readonly
 319 declare %struct.__neon_float64x1x3_t @llvm.aarch64.neon.ld3.v1f64.p0f64(double*) nounwind readonly
 320 declare %struct.__neon_float64x1x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.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)
 347         ret %struct.__neon_int8x16x4_t  %tmp2
 348 }
 349
 350 declare %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2lane.v16i8.p0i8(<16 x i8>, <16 x i8>, i64, i8*) nounwind readonly
 351 declare %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3lane.v16i8.p0i8(<16 x i8>, <16 x i8>, <16 x i8>, i64, i8*) nounwind readonly
 352 declare %struct.__neon_int8x16x4_t @llvm.aarch64.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.aarch64.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, v2 }[1], [x0]
 367 ; CHECK-NEXT: ret
 368         %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)
 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.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)
 378         ret %struct.__neon_int16x8x4_t  %tmp2
 379 }
 380
 381 declare %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2lane.v8i16.p0i16(<8 x i16>, <8 x i16>, i64, i16*) nounwind readonly
 382 declare %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3lane.v8i16.p0i16(<8 x i16>, <8 x i16>, <8 x i16>, i64, i16*) nounwind readonly
 383 declare %struct.__neon_int16x8x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.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)
 409         ret %struct.__neon_int32x4x4_t  %tmp2
 410 }
 411
 412 declare %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2lane.v4i32.p0i32(<4 x i32>, <4 x i32>, i64, i32*) nounwind readonly
 413 declare %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3lane.v4i32.p0i32(<4 x i32>, <4 x i32>, <4 x i32>, i64, i32*) nounwind readonly
 414 declare %struct.__neon_int32x4x4_t @llvm.aarch64.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.aarch64.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, v2 }[1], [x0]
 429 ; CHECK-NEXT: ret
 430         %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)
 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.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)
 440         ret %struct.__neon_int64x2x4_t  %tmp2
 441 }
 442
 443 declare %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2lane.v2i64.p0i64(<2 x i64>, <2 x i64>, i64, i64*) nounwind readonly
 444 declare %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3lane.v2i64.p0i64(<2 x i64>, <2 x i64>, <2 x i64>, i64, i64*) nounwind readonly
 445 declare %struct.__neon_int64x2x4_t @llvm.aarch64.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, 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, 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, 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, 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, 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, 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, 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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v8i8.p0i8(i8* %A)
 578         ret %struct.__neon_int8x8x4_t  %tmp2
 579 }
 580
 581 declare %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2r.v8i8.p0i8(i8*) nounwind readonly
 582 declare %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld3r.v8i8.p0i8(i8*) nounwind readonly
 583 declare %struct.__neon_int8x8x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v16i8.p0i8(i8* %A)
 609         ret %struct.__neon_int8x16x4_t  %tmp2
 610 }
 611
 612 declare %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld2r.v16i8.p0i8(i8*) nounwind readonly
 613 declare %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld3r.v16i8.p0i8(i8*) nounwind readonly
 614 declare %struct.__neon_int8x16x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v4i16.p0i16(i16* %A)
 640         ret %struct.__neon_int16x4x4_t  %tmp2
 641 }
 642
 643 declare %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld2r.v4i16.p0i16(i16*) nounwind readonly
 644 declare %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld3r.v4i16.p0i16(i16*) nounwind readonly
 645 declare %struct.__neon_int16x4x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v8i16.p0i16(i16* %A)
 671   ret %struct.__neon_int16x8x4_t  %tmp2
 672 }
 673
 674 declare %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld2r.v8i16.p0i16(i16*) nounwind readonly
 675 declare %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld3r.v8i16.p0i16(i16*) nounwind readonly
 676 declare %struct.__neon_int16x8x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v2i32.p0i32(i32* %A)
 702         ret %struct.__neon_int32x2x4_t  %tmp2
 703 }
 704
 705 declare %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld2r.v2i32.p0i32(i32*) nounwind readonly
 706 declare %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld3r.v2i32.p0i32(i32*) nounwind readonly
 707 declare %struct.__neon_int32x2x4_t @llvm.aarch64.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.aarch64.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.aarch64.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.aarch64.neon.ld4r.v4i32.p0i32(i32* %A)
 733         ret %struct.__neon_int32x4x4_t  %tmp2
 734 }
 735
 736 declare %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld2r.v4i32.p0i32(i32*) nounwind readonly
 737 declare %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld3r.v4i32.p0i32(i32*) nounwind readonly
 738 declare %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld4r.v4i32.p0i32(i32*) nounwind readonly
 739
 740 define %struct.__neon_int64x1x2_t @ld2r_1d(i64* %A) nounwind {
 741 ; CHECK: ld2r_1d
 742 ; Make sure we are using the operands defined by the ABI
 743 ; CHECK: ld2r.1d { v0, v1 }, [x0]
 744 ; CHECK-NEXT: ret
 745         %tmp2 = call %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld2r.v1i64.p0i64(i64* %A)
 746         ret %struct.__neon_int64x1x2_t  %tmp2
 747 }
 748
 749 define %struct.__neon_int64x1x3_t @ld3r_1d(i64* %A) nounwind {
 750 ; CHECK: ld3r_1d
 751 ; Make sure we are using the operands defined by the ABI
 752 ; CHECK: ld3r.1d { v0, v1, v2 }, [x0]
 753 ; CHECK-NEXT: ret
 754         %tmp2 = call %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld3r.v1i64.p0i64(i64* %A)
 755         ret %struct.__neon_int64x1x3_t  %tmp2
 756 }
 757
 758 define %struct.__neon_int64x1x4_t @ld4r_1d(i64* %A) nounwind {
 759 ; CHECK: ld4r_1d
 760 ; Make sure we are using the operands defined by the ABI
 761 ; CHECK: ld4r.1d { v0, v1, v2, v3 }, [x0]
 762 ; CHECK-NEXT: ret
 763         %tmp2 = call %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld4r.v1i64.p0i64(i64* %A)
 764         ret %struct.__neon_int64x1x4_t  %tmp2
 765 }
 766
 767 declare %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld2r.v1i64.p0i64(i64*) nounwind readonly
 768 declare %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld3r.v1i64.p0i64(i64*) nounwind readonly
 769 declare %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld4r.v1i64.p0i64(i64*) nounwind readonly
 770
 771 define %struct.__neon_int64x2x2_t @ld2r_2d(i64* %A) nounwind {
 772 ; CHECK: ld2r_2d
 773 ; Make sure we are using the operands defined by the ABI
 774 ; CHECK: ld2r.2d { v0, v1 }, [x0]
 775 ; CHECK-NEXT: ret
 776         %tmp2 = call %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2r.v2i64.p0i64(i64* %A)
 777         ret %struct.__neon_int64x2x2_t  %tmp2
 778 }
 779
 780 define %struct.__neon_int64x2x3_t @ld3r_2d(i64* %A) nounwind {
 781 ; CHECK: ld3r_2d
 782 ; Make sure we are using the operands defined by the ABI
 783 ; CHECK: ld3r.2d { v0, v1, v2 }, [x0]
 784 ; CHECK-NEXT: ret
 785         %tmp2 = call %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3r.v2i64.p0i64(i64* %A)
 786         ret %struct.__neon_int64x2x3_t  %tmp2
 787 }
 788
 789 define %struct.__neon_int64x2x4_t @ld4r_2d(i64* %A) nounwind {
 790 ; CHECK: ld4r_2d
 791 ; Make sure we are using the operands defined by the ABI
 792 ; CHECK: ld4r.2d { v0, v1, v2, v3 }, [x0]
 793 ; CHECK-NEXT: ret
 794         %tmp2 = call %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld4r.v2i64.p0i64(i64* %A)
 795         ret %struct.__neon_int64x2x4_t  %tmp2
 796 }
 797
 798 declare %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld2r.v2i64.p0i64(i64*) nounwind readonly
 799 declare %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld3r.v2i64.p0i64(i64*) nounwind readonly
 800 declare %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld4r.v2i64.p0i64(i64*) nounwind readonly
 801
 802 define <16 x i8> @ld1_16b(<16 x i8> %V, i8* %bar) {
 803 ; CHECK-LABEL: ld1_16b
 804 ; Make sure we are using the operands defined by the ABI
 805 ; CHECK: ld1.b { v0 }[0], [x0]
 806 ; CHECK-NEXT: ret
 807   %tmp1 = load i8, i8* %bar
 808   %tmp2 = insertelement <16 x i8> %V, i8 %tmp1, i32 0
 809   ret <16 x i8> %tmp2
 810 }
 811
 812 define <8 x i16> @ld1_8h(<8 x i16> %V, i16* %bar) {
 813 ; CHECK-LABEL: ld1_8h
 814 ; Make sure we are using the operands defined by the ABI
 815 ; CHECK: ld1.h { v0 }[0], [x0]
 816 ; CHECK-NEXT: ret
 817   %tmp1 = load i16, i16* %bar
 818   %tmp2 = insertelement <8 x i16> %V, i16 %tmp1, i32 0
 819   ret <8 x i16> %tmp2
 820 }
 821
 822 define <4 x i32> @ld1_4s(<4 x i32> %V, i32* %bar) {
 823 ; CHECK-LABEL: ld1_4s
 824 ; Make sure we are using the operands defined by the ABI
 825 ; CHECK: ld1.s { v0 }[0], [x0]
 826 ; CHECK-NEXT: ret
 827   %tmp1 = load i32, i32* %bar
 828   %tmp2 = insertelement <4 x i32> %V, i32 %tmp1, i32 0
 829   ret <4 x i32> %tmp2
 830 }
 831
 832 define <4 x float> @ld1_4s_float(<4 x float> %V, float* %bar) {
 833 ; CHECK-LABEL: ld1_4s_float:
 834 ; Make sure we are using the operands defined by the ABI
 835 ; CHECK: ld1.s { v0 }[0], [x0]
 836 ; CHECK-NEXT: ret
 837   %tmp1 = load float, float* %bar
 838   %tmp2 = insertelement <4 x float> %V, float %tmp1, i32 0
 839   ret <4 x float> %tmp2
 840 }
 841
 842 define <2 x i64> @ld1_2d(<2 x i64> %V, i64* %bar) {
 843 ; CHECK-LABEL: ld1_2d
 844 ; Make sure we are using the operands defined by the ABI
 845 ; CHECK: ld1.d { v0 }[0], [x0]
 846 ; CHECK-NEXT: ret
 847   %tmp1 = load i64, i64* %bar
 848   %tmp2 = insertelement <2 x i64> %V, i64 %tmp1, i32 0
 849   ret <2 x i64> %tmp2
 850 }
 851
 852 define <2 x double> @ld1_2d_double(<2 x double> %V, double* %bar) {
 853 ; CHECK-LABEL: ld1_2d_double:
 854 ; Make sure we are using the operands defined by the ABI
 855 ; CHECK: ld1.d { v0 }[0], [x0]
 856 ; CHECK-NEXT: ret
 857   %tmp1 = load double, double* %bar
 858   %tmp2 = insertelement <2 x double> %V, double %tmp1, i32 0
 859   ret <2 x double> %tmp2
 860 }
 861
 862 define <1 x i64> @ld1_1d(<1 x i64>* %p) {
 863 ; CHECK-LABEL: ld1_1d
 864 ; Make sure we are using the operands defined by the ABI
 865 ; CHECK: ldr [[REG:d[0-9]+]], [x0]
 866 ; CHECK-NEXT: ret
 867   %tmp = load <1 x i64>, <1 x i64>* %p, align 8
 868   ret <1 x i64> %tmp
 869 }
 870
 871 define <8 x i8> @ld1_8b(<8 x i8> %V, i8* %bar) {
 872 ; CHECK-LABEL: ld1_8b
 873 ; Make sure we are using the operands defined by the ABI
 874 ; CHECK: ld1.b { v0 }[0], [x0]
 875 ; CHECK-NEXT: ret
 876   %tmp1 = load i8, i8* %bar
 877   %tmp2 = insertelement <8 x i8> %V, i8 %tmp1, i32 0
 878   ret <8 x i8> %tmp2
 879 }
 880
 881 define <4 x i16> @ld1_4h(<4 x i16> %V, i16* %bar) {
 882 ; CHECK-LABEL: ld1_4h
 883 ; Make sure we are using the operands defined by the ABI
 884 ; CHECK: ld1.h { v0 }[0], [x0]
 885 ; CHECK-NEXT: ret
 886   %tmp1 = load i16, i16* %bar
 887   %tmp2 = insertelement <4 x i16> %V, i16 %tmp1, i32 0
 888   ret <4 x i16> %tmp2
 889 }
 890
 891 define <2 x i32> @ld1_2s(<2 x i32> %V, i32* %bar) {
 892 ; CHECK-LABEL: ld1_2s:
 893 ; Make sure we are using the operands defined by the ABI
 894 ; CHECK: ld1.s { v0 }[0], [x0]
 895 ; CHECK-NEXT: ret
 896   %tmp1 = load i32, i32* %bar
 897   %tmp2 = insertelement <2 x i32> %V, i32 %tmp1, i32 0
 898   ret <2 x i32> %tmp2
 899 }
 900
 901 define <2 x float> @ld1_2s_float(<2 x float> %V, float* %bar) {
 902 ; CHECK-LABEL: ld1_2s_float:
 903 ; Make sure we are using the operands defined by the ABI
 904 ; CHECK: ld1.s { v0 }[0], [x0]
 905 ; CHECK-NEXT: ret
 906   %tmp1 = load float, float* %bar
 907   %tmp2 = insertelement <2 x float> %V, float %tmp1, i32 0
 908   ret <2 x float> %tmp2
 909 }
 910
 911
 912 ; Add rdar://13098923 test case: vld1_dup_u32 doesn't generate ld1r.2s
 913 define void @ld1r_2s_from_dup(i8* nocapture %a, i8* nocapture %b, i16* nocapture %diff) nounwind ssp {
 914 entry:
 915 ; CHECK: ld1r_2s_from_dup
 916 ; CHECK: ld1r.2s { [[ARG1:v[0-9]+]] }, [x0]
 917 ; CHECK-NEXT: ld1r.2s { [[ARG2:v[0-9]+]] }, [x1]
 918 ; CHECK-NEXT: usubl.8h v[[RESREGNUM:[0-9]+]], [[ARG1]], [[ARG2]]
 919 ; CHECK-NEXT: str d[[RESREGNUM]], [x2]
 920 ; CHECK-NEXT: ret
 921   %tmp = bitcast i8* %a to i32*
 922   %tmp1 = load i32, i32* %tmp, align 4
 923   %tmp2 = insertelement <2 x i32> undef, i32 %tmp1, i32 0
 924   %lane = shufflevector <2 x i32> %tmp2, <2 x i32> undef, <2 x i32> zeroinitializer
 925   %tmp3 = bitcast <2 x i32> %lane to <8 x i8>
 926   %tmp4 = bitcast i8* %b to i32*
 927   %tmp5 = load i32, i32* %tmp4, align 4
 928   %tmp6 = insertelement <2 x i32> undef, i32 %tmp5, i32 0
 929   %lane1 = shufflevector <2 x i32> %tmp6, <2 x i32> undef, <2 x i32> zeroinitializer
 930   %tmp7 = bitcast <2 x i32> %lane1 to <8 x i8>
 931   %vmovl.i.i = zext <8 x i8> %tmp3 to <8 x i16>
 932   %vmovl.i4.i = zext <8 x i8> %tmp7 to <8 x i16>
 933   %sub.i = sub <8 x i16> %vmovl.i.i, %vmovl.i4.i
 934   %tmp8 = bitcast <8 x i16> %sub.i to <2 x i64>
 935   %shuffle.i = shufflevector <2 x i64> %tmp8, <2 x i64> undef, <1 x i32> zeroinitializer
 936   %tmp9 = bitcast <1 x i64> %shuffle.i to <4 x i16>
 937   %tmp10 = bitcast i16* %diff to <4 x i16>*
 938   store <4 x i16> %tmp9, <4 x i16>* %tmp10, align 8
 939   ret void
 940 }
 941
 942 ; Tests for rdar://11947069: vld1_dup_* and vld1q_dup_* code gen is suboptimal
 943 define <4 x float> @ld1r_4s_float(float* nocapture %x) {
 944 entry:
 945 ; CHECK-LABEL: ld1r_4s_float
 946 ; Make sure we are using the operands defined by the ABI
 947 ; CHECK: ld1r.4s { v0 }, [x0]
 948 ; CHECK-NEXT: ret
 949   %tmp = load float, float* %x, align 4
 950   %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
 951   %tmp2 = insertelement <4 x float> %tmp1, float %tmp, i32 1
 952   %tmp3 = insertelement <4 x float> %tmp2, float %tmp, i32 2
 953   %tmp4 = insertelement <4 x float> %tmp3, float %tmp, i32 3
 954   ret <4 x float> %tmp4
 955 }
 956
 957 define <2 x float> @ld1r_2s_float(float* nocapture %x) {
 958 entry:
 959 ; CHECK-LABEL: ld1r_2s_float
 960 ; Make sure we are using the operands defined by the ABI
 961 ; CHECK: ld1r.2s { v0 }, [x0]
 962 ; CHECK-NEXT: ret
 963   %tmp = load float, float* %x, align 4
 964   %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
 965   %tmp2 = insertelement <2 x float> %tmp1, float %tmp, i32 1
 966   ret <2 x float> %tmp2
 967 }
 968
 969 define <2 x double> @ld1r_2d_double(double* nocapture %x) {
 970 entry:
 971 ; CHECK-LABEL: ld1r_2d_double
 972 ; Make sure we are using the operands defined by the ABI
 973 ; CHECK: ld1r.2d { v0 }, [x0]
 974 ; CHECK-NEXT: ret
 975   %tmp = load double, double* %x, align 4
 976   %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
 977   %tmp2 = insertelement <2 x double> %tmp1, double %tmp, i32 1
 978   ret <2 x double> %tmp2
 979 }
 980
 981 define <1 x double> @ld1r_1d_double(double* nocapture %x) {
 982 entry:
 983 ; CHECK-LABEL: ld1r_1d_double
 984 ; Make sure we are using the operands defined by the ABI
 985 ; CHECK: ldr d0, [x0]
 986 ; CHECK-NEXT: ret
 987   %tmp = load double, double* %x, align 4
 988   %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
 989   ret <1 x double> %tmp1
 990 }
 991
 992 define <4 x float> @ld1r_4s_float_shuff(float* nocapture %x) {
 993 entry:
 994 ; CHECK-LABEL: ld1r_4s_float_shuff
 995 ; Make sure we are using the operands defined by the ABI
 996 ; CHECK: ld1r.4s { v0 }, [x0]
 997 ; CHECK-NEXT: ret
 998   %tmp = load float, float* %x, align 4
 999   %tmp1 = insertelement <4 x float> undef, float %tmp, i32 0
1000   %lane = shufflevector <4 x float> %tmp1, <4 x float> undef, <4 x i32> zeroinitializer
1001   ret <4 x float> %lane
1002 }
1003
1004 define <2 x float> @ld1r_2s_float_shuff(float* nocapture %x) {
1005 entry:
1006 ; CHECK-LABEL: ld1r_2s_float_shuff
1007 ; Make sure we are using the operands defined by the ABI
1008 ; CHECK: ld1r.2s { v0 }, [x0]
1009 ; CHECK-NEXT: ret
1010   %tmp = load float, float* %x, align 4
1011   %tmp1 = insertelement <2 x float> undef, float %tmp, i32 0
1012   %lane = shufflevector <2 x float> %tmp1, <2 x float> undef, <2 x i32> zeroinitializer
1013   ret <2 x float> %lane
1014 }
1015
1016 define <2 x double> @ld1r_2d_double_shuff(double* nocapture %x) {
1017 entry:
1018 ; CHECK-LABEL: ld1r_2d_double_shuff
1019 ; Make sure we are using the operands defined by the ABI
1020 ; CHECK: ld1r.2d { v0 }, [x0]
1021 ; CHECK-NEXT: ret
1022   %tmp = load double, double* %x, align 4
1023   %tmp1 = insertelement <2 x double> undef, double %tmp, i32 0
1024   %lane = shufflevector <2 x double> %tmp1, <2 x double> undef, <2 x i32> zeroinitializer
1025   ret <2 x double> %lane
1026 }
1027
1028 define <1 x double> @ld1r_1d_double_shuff(double* nocapture %x) {
1029 entry:
1030 ; CHECK-LABEL: ld1r_1d_double_shuff
1031 ; Make sure we are using the operands defined by the ABI
1032 ; CHECK: ldr d0, [x0]
1033 ; CHECK-NEXT: ret
1034   %tmp = load double, double* %x, align 4
1035   %tmp1 = insertelement <1 x double> undef, double %tmp, i32 0
1036   %lane = shufflevector <1 x double> %tmp1, <1 x double> undef, <1 x i32> zeroinitializer
1037   ret <1 x double> %lane
1038 }
1039
1040 %struct.__neon_float32x2x2_t = type { <2 x float>,  <2 x float> }
1041 %struct.__neon_float32x2x3_t = type { <2 x float>,  <2 x float>,  <2 x float> }
1042 %struct.__neon_float32x2x4_t = type { <2 x float>,  <2 x float>, <2 x float>,  <2 x float> }
1043
1044 declare %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld1x2.v8i8.p0i8(i8*) nounwind readonly
1045 declare %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld1x2.v4i16.p0i16(i16*) nounwind readonly
1046 declare %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld1x2.v2i32.p0i32(i32*) nounwind readonly
1047 declare %struct.__neon_float32x2x2_t @llvm.aarch64.neon.ld1x2.v2f32.p0f32(float*) nounwind readonly
1048 declare %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld1x2.v1i64.p0i64(i64*) nounwind readonly
1049 declare %struct.__neon_float64x1x2_t @llvm.aarch64.neon.ld1x2.v1f64.p0f64(double*) nounwind readonly
1050
1051 define %struct.__neon_int8x8x2_t @ld1_x2_v8i8(i8* %addr) {
1052 ; CHECK-LABEL: ld1_x2_v8i8:
1053 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1054   %val = call %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld1x2.v8i8.p0i8(i8* %addr)
1055   ret %struct.__neon_int8x8x2_t %val
1056 }
1057
1058 define %struct.__neon_int16x4x2_t @ld1_x2_v4i16(i16* %addr) {
1059 ; CHECK-LABEL: ld1_x2_v4i16:
1060 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1061   %val = call %struct.__neon_int16x4x2_t @llvm.aarch64.neon.ld1x2.v4i16.p0i16(i16* %addr)
1062   ret %struct.__neon_int16x4x2_t %val
1063 }
1064
1065 define %struct.__neon_int32x2x2_t @ld1_x2_v2i32(i32* %addr) {
1066 ; CHECK-LABEL: ld1_x2_v2i32:
1067 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1068   %val = call %struct.__neon_int32x2x2_t @llvm.aarch64.neon.ld1x2.v2i32.p0i32(i32* %addr)
1069   ret %struct.__neon_int32x2x2_t %val
1070 }
1071
1072 define %struct.__neon_float32x2x2_t @ld1_x2_v2f32(float* %addr) {
1073 ; CHECK-LABEL: ld1_x2_v2f32:
1074 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1075   %val = call %struct.__neon_float32x2x2_t @llvm.aarch64.neon.ld1x2.v2f32.p0f32(float* %addr)
1076   ret %struct.__neon_float32x2x2_t %val
1077 }
1078
1079 define %struct.__neon_int64x1x2_t @ld1_x2_v1i64(i64* %addr) {
1080 ; CHECK-LABEL: ld1_x2_v1i64:
1081 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1082   %val = call %struct.__neon_int64x1x2_t @llvm.aarch64.neon.ld1x2.v1i64.p0i64(i64* %addr)
1083   ret %struct.__neon_int64x1x2_t %val
1084 }
1085
1086 define %struct.__neon_float64x1x2_t @ld1_x2_v1f64(double* %addr) {
1087 ; CHECK-LABEL: ld1_x2_v1f64:
1088 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1089   %val = call %struct.__neon_float64x1x2_t @llvm.aarch64.neon.ld1x2.v1f64.p0f64(double* %addr)
1090   ret %struct.__neon_float64x1x2_t %val
1091 }
1092
1093
1094 %struct.__neon_float32x4x2_t = type { <4 x float>,  <4 x float> }
1095 %struct.__neon_float32x4x3_t = type { <4 x float>,  <4 x float>,  <4 x float> }
1096 %struct.__neon_float32x4x4_t = type { <4 x float>,  <4 x float>, <4 x float>,  <4 x float> }
1097
1098 %struct.__neon_float64x2x2_t = type { <2 x double>,  <2 x double> }
1099 %struct.__neon_float64x2x3_t = type { <2 x double>,  <2 x double>,  <2 x double> }
1100 %struct.__neon_float64x2x4_t = type { <2 x double>,  <2 x double>, <2 x double>,  <2 x double> }
1101
1102 declare %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld1x2.v16i8.p0i8(i8*) nounwind readonly
1103 declare %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld1x2.v8i16.p0i16(i16*) nounwind readonly
1104 declare %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld1x2.v4i32.p0i32(i32*) nounwind readonly
1105 declare %struct.__neon_float32x4x2_t @llvm.aarch64.neon.ld1x2.v4f32.p0f32(float*) nounwind readonly
1106 declare %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld1x2.v2i64.p0i64(i64*) nounwind readonly
1107 declare %struct.__neon_float64x2x2_t @llvm.aarch64.neon.ld1x2.v2f64.p0f64(double*) nounwind readonly
1108
1109 define %struct.__neon_int8x16x2_t @ld1_x2_v16i8(i8* %addr) {
1110 ; CHECK-LABEL: ld1_x2_v16i8:
1111 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1112   %val = call %struct.__neon_int8x16x2_t @llvm.aarch64.neon.ld1x2.v16i8.p0i8(i8* %addr)
1113   ret %struct.__neon_int8x16x2_t %val
1114 }
1115
1116 define %struct.__neon_int16x8x2_t @ld1_x2_v8i16(i16* %addr) {
1117 ; CHECK-LABEL: ld1_x2_v8i16:
1118 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1119   %val = call %struct.__neon_int16x8x2_t @llvm.aarch64.neon.ld1x2.v8i16.p0i16(i16* %addr)
1120   ret %struct.__neon_int16x8x2_t %val
1121 }
1122
1123 define %struct.__neon_int32x4x2_t @ld1_x2_v4i32(i32* %addr) {
1124 ; CHECK-LABEL: ld1_x2_v4i32:
1125 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1126   %val = call %struct.__neon_int32x4x2_t @llvm.aarch64.neon.ld1x2.v4i32.p0i32(i32* %addr)
1127   ret %struct.__neon_int32x4x2_t %val
1128 }
1129
1130 define %struct.__neon_float32x4x2_t @ld1_x2_v4f32(float* %addr) {
1131 ; CHECK-LABEL: ld1_x2_v4f32:
1132 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1133   %val = call %struct.__neon_float32x4x2_t @llvm.aarch64.neon.ld1x2.v4f32.p0f32(float* %addr)
1134   ret %struct.__neon_float32x4x2_t %val
1135 }
1136
1137 define %struct.__neon_int64x2x2_t @ld1_x2_v2i64(i64* %addr) {
1138 ; CHECK-LABEL: ld1_x2_v2i64:
1139 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1140   %val = call %struct.__neon_int64x2x2_t @llvm.aarch64.neon.ld1x2.v2i64.p0i64(i64* %addr)
1141   ret %struct.__neon_int64x2x2_t %val
1142 }
1143
1144 define %struct.__neon_float64x2x2_t @ld1_x2_v2f64(double* %addr) {
1145 ; CHECK-LABEL: ld1_x2_v2f64:
1146 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1147   %val = call %struct.__neon_float64x2x2_t @llvm.aarch64.neon.ld1x2.v2f64.p0f64(double* %addr)
1148   ret %struct.__neon_float64x2x2_t %val
1149 }
1150
1151 declare %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld1x3.v8i8.p0i8(i8*) nounwind readonly
1152 declare %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld1x3.v4i16.p0i16(i16*) nounwind readonly
1153 declare %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld1x3.v2i32.p0i32(i32*) nounwind readonly
1154 declare %struct.__neon_float32x2x3_t @llvm.aarch64.neon.ld1x3.v2f32.p0f32(float*) nounwind readonly
1155 declare %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld1x3.v1i64.p0i64(i64*) nounwind readonly
1156 declare %struct.__neon_float64x1x3_t @llvm.aarch64.neon.ld1x3.v1f64.p0f64(double*) nounwind readonly
1157
1158 define %struct.__neon_int8x8x3_t @ld1_x3_v8i8(i8* %addr) {
1159 ; CHECK-LABEL: ld1_x3_v8i8:
1160 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1161   %val = call %struct.__neon_int8x8x3_t @llvm.aarch64.neon.ld1x3.v8i8.p0i8(i8* %addr)
1162   ret %struct.__neon_int8x8x3_t %val
1163 }
1164
1165 define %struct.__neon_int16x4x3_t @ld1_x3_v4i16(i16* %addr) {
1166 ; CHECK-LABEL: ld1_x3_v4i16:
1167 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1168   %val = call %struct.__neon_int16x4x3_t @llvm.aarch64.neon.ld1x3.v4i16.p0i16(i16* %addr)
1169   ret %struct.__neon_int16x4x3_t %val
1170 }
1171
1172 define %struct.__neon_int32x2x3_t @ld1_x3_v2i32(i32* %addr) {
1173 ; CHECK-LABEL: ld1_x3_v2i32:
1174 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1175   %val = call %struct.__neon_int32x2x3_t @llvm.aarch64.neon.ld1x3.v2i32.p0i32(i32* %addr)
1176   ret %struct.__neon_int32x2x3_t %val
1177 }
1178
1179 define %struct.__neon_float32x2x3_t @ld1_x3_v2f32(float* %addr) {
1180 ; CHECK-LABEL: ld1_x3_v2f32:
1181 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1182   %val = call %struct.__neon_float32x2x3_t @llvm.aarch64.neon.ld1x3.v2f32.p0f32(float* %addr)
1183   ret %struct.__neon_float32x2x3_t %val
1184 }
1185
1186 define %struct.__neon_int64x1x3_t @ld1_x3_v1i64(i64* %addr) {
1187 ; CHECK-LABEL: ld1_x3_v1i64:
1188 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1189   %val = call %struct.__neon_int64x1x3_t @llvm.aarch64.neon.ld1x3.v1i64.p0i64(i64* %addr)
1190   ret %struct.__neon_int64x1x3_t %val
1191 }
1192
1193 define %struct.__neon_float64x1x3_t @ld1_x3_v1f64(double* %addr) {
1194 ; CHECK-LABEL: ld1_x3_v1f64:
1195 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1196   %val = call %struct.__neon_float64x1x3_t @llvm.aarch64.neon.ld1x3.v1f64.p0f64(double* %addr)
1197   ret %struct.__neon_float64x1x3_t %val
1198 }
1199
1200 declare %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld1x3.v16i8.p0i8(i8*) nounwind readonly
1201 declare %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld1x3.v8i16.p0i16(i16*) nounwind readonly
1202 declare %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld1x3.v4i32.p0i32(i32*) nounwind readonly
1203 declare %struct.__neon_float32x4x3_t @llvm.aarch64.neon.ld1x3.v4f32.p0f32(float*) nounwind readonly
1204 declare %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld1x3.v2i64.p0i64(i64*) nounwind readonly
1205 declare %struct.__neon_float64x2x3_t @llvm.aarch64.neon.ld1x3.v2f64.p0f64(double*) nounwind readonly
1206
1207 define %struct.__neon_int8x16x3_t @ld1_x3_v16i8(i8* %addr) {
1208 ; CHECK-LABEL: ld1_x3_v16i8:
1209 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1210   %val = call %struct.__neon_int8x16x3_t @llvm.aarch64.neon.ld1x3.v16i8.p0i8(i8* %addr)
1211   ret %struct.__neon_int8x16x3_t %val
1212 }
1213
1214 define %struct.__neon_int16x8x3_t @ld1_x3_v8i16(i16* %addr) {
1215 ; CHECK-LABEL: ld1_x3_v8i16:
1216 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1217   %val = call %struct.__neon_int16x8x3_t @llvm.aarch64.neon.ld1x3.v8i16.p0i16(i16* %addr)
1218   ret %struct.__neon_int16x8x3_t %val
1219 }
1220
1221 define %struct.__neon_int32x4x3_t @ld1_x3_v4i32(i32* %addr) {
1222 ; CHECK-LABEL: ld1_x3_v4i32:
1223 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1224   %val = call %struct.__neon_int32x4x3_t @llvm.aarch64.neon.ld1x3.v4i32.p0i32(i32* %addr)
1225   ret %struct.__neon_int32x4x3_t %val
1226 }
1227
1228 define %struct.__neon_float32x4x3_t @ld1_x3_v4f32(float* %addr) {
1229 ; CHECK-LABEL: ld1_x3_v4f32:
1230 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1231   %val = call %struct.__neon_float32x4x3_t @llvm.aarch64.neon.ld1x3.v4f32.p0f32(float* %addr)
1232   ret %struct.__neon_float32x4x3_t %val
1233 }
1234
1235 define %struct.__neon_int64x2x3_t @ld1_x3_v2i64(i64* %addr) {
1236 ; CHECK-LABEL: ld1_x3_v2i64:
1237 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1238   %val = call %struct.__neon_int64x2x3_t @llvm.aarch64.neon.ld1x3.v2i64.p0i64(i64* %addr)
1239   ret %struct.__neon_int64x2x3_t %val
1240 }
1241
1242 define %struct.__neon_float64x2x3_t @ld1_x3_v2f64(double* %addr) {
1243 ; CHECK-LABEL: ld1_x3_v2f64:
1244 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1245   %val = call %struct.__neon_float64x2x3_t @llvm.aarch64.neon.ld1x3.v2f64.p0f64(double* %addr)
1246   ret %struct.__neon_float64x2x3_t %val
1247 }
1248
1249 declare %struct.__neon_int8x8x4_t @llvm.aarch64.neon.ld1x4.v8i8.p0i8(i8*) nounwind readonly
1250 declare %struct.__neon_int16x4x4_t @llvm.aarch64.neon.ld1x4.v4i16.p0i16(i16*) nounwind readonly
1251 declare %struct.__neon_int32x2x4_t @llvm.aarch64.neon.ld1x4.v2i32.p0i32(i32*) nounwind readonly
1252 declare %struct.__neon_float32x2x4_t @llvm.aarch64.neon.ld1x4.v2f32.p0f32(float*) nounwind readonly
1253 declare %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld1x4.v1i64.p0i64(i64*) nounwind readonly
1254 declare %struct.__neon_float64x1x4_t @llvm.aarch64.neon.ld1x4.v1f64.p0f64(double*) nounwind readonly
1255
1256 define %struct.__neon_int8x8x4_t @ld1_x4_v8i8(i8* %addr) {
1257 ; CHECK-LABEL: ld1_x4_v8i8:
1258 ; CHECK: ld1.8b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1259   %val = call %struct.__neon_int8x8x4_t @llvm.aarch64.neon.ld1x4.v8i8.p0i8(i8* %addr)
1260   ret %struct.__neon_int8x8x4_t %val
1261 }
1262
1263 define %struct.__neon_int16x4x4_t @ld1_x4_v4i16(i16* %addr) {
1264 ; CHECK-LABEL: ld1_x4_v4i16:
1265 ; CHECK: ld1.4h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1266   %val = call %struct.__neon_int16x4x4_t @llvm.aarch64.neon.ld1x4.v4i16.p0i16(i16* %addr)
1267   ret %struct.__neon_int16x4x4_t %val
1268 }
1269
1270 define %struct.__neon_int32x2x4_t @ld1_x4_v2i32(i32* %addr) {
1271 ; CHECK-LABEL: ld1_x4_v2i32:
1272 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1273   %val = call %struct.__neon_int32x2x4_t @llvm.aarch64.neon.ld1x4.v2i32.p0i32(i32* %addr)
1274   ret %struct.__neon_int32x2x4_t %val
1275 }
1276
1277 define %struct.__neon_float32x2x4_t @ld1_x4_v2f32(float* %addr) {
1278 ; CHECK-LABEL: ld1_x4_v2f32:
1279 ; CHECK: ld1.2s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1280   %val = call %struct.__neon_float32x2x4_t @llvm.aarch64.neon.ld1x4.v2f32.p0f32(float* %addr)
1281   ret %struct.__neon_float32x2x4_t %val
1282 }
1283
1284 define %struct.__neon_int64x1x4_t @ld1_x4_v1i64(i64* %addr) {
1285 ; CHECK-LABEL: ld1_x4_v1i64:
1286 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1287   %val = call %struct.__neon_int64x1x4_t @llvm.aarch64.neon.ld1x4.v1i64.p0i64(i64* %addr)
1288   ret %struct.__neon_int64x1x4_t %val
1289 }
1290
1291 define %struct.__neon_float64x1x4_t @ld1_x4_v1f64(double* %addr) {
1292 ; CHECK-LABEL: ld1_x4_v1f64:
1293 ; CHECK: ld1.1d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1294   %val = call %struct.__neon_float64x1x4_t @llvm.aarch64.neon.ld1x4.v1f64.p0f64(double* %addr)
1295   ret %struct.__neon_float64x1x4_t %val
1296 }
1297
1298 declare %struct.__neon_int8x16x4_t @llvm.aarch64.neon.ld1x4.v16i8.p0i8(i8*) nounwind readonly
1299 declare %struct.__neon_int16x8x4_t @llvm.aarch64.neon.ld1x4.v8i16.p0i16(i16*) nounwind readonly
1300 declare %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld1x4.v4i32.p0i32(i32*) nounwind readonly
1301 declare %struct.__neon_float32x4x4_t @llvm.aarch64.neon.ld1x4.v4f32.p0f32(float*) nounwind readonly
1302 declare %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld1x4.v2i64.p0i64(i64*) nounwind readonly
1303 declare %struct.__neon_float64x2x4_t @llvm.aarch64.neon.ld1x4.v2f64.p0f64(double*) nounwind readonly
1304
1305 define %struct.__neon_int8x16x4_t @ld1_x4_v16i8(i8* %addr) {
1306 ; CHECK-LABEL: ld1_x4_v16i8:
1307 ; CHECK: ld1.16b { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1308   %val = call %struct.__neon_int8x16x4_t @llvm.aarch64.neon.ld1x4.v16i8.p0i8(i8* %addr)
1309   ret %struct.__neon_int8x16x4_t %val
1310 }
1311
1312 define %struct.__neon_int16x8x4_t @ld1_x4_v8i16(i16* %addr) {
1313 ; CHECK-LABEL: ld1_x4_v8i16:
1314 ; CHECK: ld1.8h { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1315   %val = call %struct.__neon_int16x8x4_t @llvm.aarch64.neon.ld1x4.v8i16.p0i16(i16* %addr)
1316   ret %struct.__neon_int16x8x4_t %val
1317 }
1318
1319 define %struct.__neon_int32x4x4_t @ld1_x4_v4i32(i32* %addr) {
1320 ; CHECK-LABEL: ld1_x4_v4i32:
1321 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1322   %val = call %struct.__neon_int32x4x4_t @llvm.aarch64.neon.ld1x4.v4i32.p0i32(i32* %addr)
1323   ret %struct.__neon_int32x4x4_t %val
1324 }
1325
1326 define %struct.__neon_float32x4x4_t @ld1_x4_v4f32(float* %addr) {
1327 ; CHECK-LABEL: ld1_x4_v4f32:
1328 ; CHECK: ld1.4s { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1329   %val = call %struct.__neon_float32x4x4_t @llvm.aarch64.neon.ld1x4.v4f32.p0f32(float* %addr)
1330   ret %struct.__neon_float32x4x4_t %val
1331 }
1332
1333 define %struct.__neon_int64x2x4_t @ld1_x4_v2i64(i64* %addr) {
1334 ; CHECK-LABEL: ld1_x4_v2i64:
1335 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1336   %val = call %struct.__neon_int64x2x4_t @llvm.aarch64.neon.ld1x4.v2i64.p0i64(i64* %addr)
1337   ret %struct.__neon_int64x2x4_t %val
1338 }
1339
1340 define %struct.__neon_float64x2x4_t @ld1_x4_v2f64(double* %addr) {
1341 ; CHECK-LABEL: ld1_x4_v2f64:
1342 ; CHECK: ld1.2d { {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}}, {{v[0-9]+}} }, [x0]
1343   %val = call %struct.__neon_float64x2x4_t @llvm.aarch64.neon.ld1x4.v2f64.p0f64(double* %addr)
1344   ret %struct.__neon_float64x2x4_t %val
1345 }